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)

1. Propagate -y: If auto mode active, append -y to args
2. Execute: Skill(skill_name, args) — blocking, wait for completion
3. Advance: chain_loader done to proceed to next step

javascript
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