---
id: catlog22/Claude-Code-Workflow/ccw-chain
version: "aecac4a9"
license: MIT
install: manual
updated: 2026-06-18
---

# ccw-chain — CCW Chain orchestrates multi-step workflows by analyzing user intent, routing to the appropriate chain, and executing skill pipelines through progressive step loading. It supports auto mode for hands-off execution, delegation between chains, and variable propagation across the entire workflow.

Publisher: catlog22 · Stars: 2142 · Updated: 2026-06-18

Install (manual): `git clone https://github.com/catlog22/Claude-Code-Workflow`

## SKILL.md

# 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

```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


[View on SkillFed](https://skillfed.io/catlog22/Claude-Code-Workflow/ccw-chain) · [View on GitHub](https://github.com/catlog22/Claude-Code-Workflow)