CCW Chain Orchestrator

Chain-based workflow orchestrator using

chain_loader

for progressive step loading and LLM-driven decision routing.

Discovery

1. chain_loader list

   — list all chains with triggers, entries, and descriptions
2. Match user intent to chain

   triggers.task_types

   /

   triggers.keywords

3. chain_loader inspect

   — preview chain node graph and available entries

4. chain_loader start

   — begin from default entry, named entry (

   entry_name

   ), or any node (

   node

   )

Execution Protocol

When

chain_loader

delivers a step node with a skill/command doc:

1. Read the loaded doc content to understand the skill's purpose and interface
2. Assemble the Skill call:

   Skill(skill_name, args)

   • First step:

     args = "${analysis.goal}"

   • Subsequent steps:

     args = ""

     (auto-receives session context)
   • Special args noted in step name (e.g.,

     --bugfix

     ,

     --hotfix

     ,

     --plan-only

     )
3. Propagate -y: If auto mode active, append

   -y

   to args
4. Execute:

   Skill(skill_name, args)

   — blocking, wait for completion
5. Advance:

   chain_loader done

   to proceed to next step

const autoYes = /\b(-y|--yes)\b/.test($ARGUMENTS);

function assembleCommand(skillName, args, previousResult) {
  if (!args && previousResult?.session_id) {
    args = `--session="${previousResult.session_id}"`;
  }
  if (autoYes && !args.includes('-y') && !args.includes('--yes')) {
    args = args ? `${args} -y` : '-y';
  }
  return { skill: skillName, args };
}

Auto Mode (

-y

/

--yes

)

• D1 Clarity Check: always choose "Clear" (skip clarification)
• Confirmation: skip, execute directly
• Error handling: auto-skip failed steps, continue pipeline
• Propagation:

  -y

  injected into every downstream Skill call

Delegation Protocol

When

chain_loader

returns

delegate_depth > 0

:

1. Continue normal execution (read content, assemble Skill, execute)
2. On

   returned_from_delegate: true

   , resume parent chain context
3. Variables received from child chain are available for subsequent steps

Preloaded Context

When

chain_loader start

returns

preloaded_keys

:

1. Preloaded content is available via

   chain_loader content

   for the entire session
2. Reference preloaded context when assembling Skill calls
3. Use preloaded memory/project context to inform all downstream steps

Progress Visualization

After each

chain_loader done

, call

chain_loader visualize

to show progress. Display the visualization in execution log for user awareness.

Variable Propagation

Intent analysis results (

task_type

,

goal

,

auto_yes

) are stored as chain variables.

assembleCommand()

reads variables from

chain_loader status

for Skill args. Variables automatically flow through delegation via

pass_variables

/

receive_variables

.

Phase-Level Execution (Skill Chain Delegation)

When the current chain is a skill-level chain (entered via delegation from a category chain):

1. Each step delivers phase doc content directly (not SKILL.md)
2. Execute phase instructions inline — do NOT wrap in

   Skill()

   call
3. Reference preloaded

   skill-context

   for orchestration patterns (TodoWrite, data flow, error handling)
4. Phase execution produces artifacts (files, session state) consumed by the next phase
5. The chain system controls phase progression — no need for internal phase orchestration

Architecture: Chain Definition Layers

• Category chains (8):

  ccw-chain/chains/

  — routing and orchestration (ccw-main, ccw-standard, etc.)
• Workflow skill chains (7):

  .claude/workflow-skills/*/chains/

  — skill-level chains with phase content
• Phase content:

  .claude/skills/*/phases/

  — original phase files, referenced via

  @skills/

  prefix
• Category chains delegate to workflow skill chains via

  findChainAcrossSkills()

  fallback
• Content refs:

  @phases/

  = skill-relative,

  @skills/

  = project

  .claude/skills/

  relative