/cm-skill-chain

name: cm-skill-chain
description: Skill Chain Engine — compose skills into automated pipelines. One task triggers multi-skill workflows with progress tracking, auto-detection, and step management.

Skill Chain Engine

> **TRIZ #40 Composite Materials** — Skills compose into pipelines. > One command → full workflow → automated step progression.

When to Use

ALWAYS trigger for: chain, pipeline, workflow, multi-step, end-to-end, "run the whole thing", "full process", "feature pipeline", "bug fix flow", "from scratch to deploy", "brainstorm to ship", "skill chain", "full pipeline"

Quick Reference

| Command | Description | |---------|-------------| | `cody chain list` | Show all available chains | | `cody chain info <id>` | Show chain pipeline details | | `cody chain auto "task"` | Auto-detect best chain & start | | `cody chain start <id> "task"` | Start specific chain | | `cody chain status [exec-id]` | Show progress | | `cody chain advance <exec-id>` | Complete current step, move to next | | `cody chain skip <exec-id>` | Skip current step | | `cody chain abort <exec-id>` | Cancel chain | | `cody chain history` | View past chain runs |

Naming Convention

Step names use short-form identifiers — the `cm-` prefix is stripped by convention. Full skill names: `cm-brainstorm-idea`, `cm-planning`, `cm-tdd`, `cm-execution`, `cm-quality-gate`, `cm-safe-deploy`, `cm-debugging`, `cm-content-factory`, `cm-ads-tracker`, `cm-project-bootstrap`, `cm-code-review`. All skills now use the `cm-` prefix convention.

Built-in Chains

🚀 feature-development (up to 3 active steps)

`brainstorm-idea* → planning → tdd → execution → quality-gate → safe-deploy*` *optional steps — only activated when task context scores them relevant

🐛 bug-fix (3 steps)

`debugging → tdd → quality-gate`

📝 content-launch (3 steps)

`content-factory → ads-tracker → cm-cro-methodology`

🏗️ new-project (up to 3 active steps)

`project-bootstrap → planning → tdd → execution → quality-gate → safe-deploy*` *optional steps selected by task relevance

🔍 cm-code-review (3 steps)

`cm-code-review → quality-gate → safe-deploy`

Intelligent Skill Selection (v5.1)

Chains no longer execute every step blindly. `selectTopSkills()` dynamically selects the **top 3 most relevant steps** for each task:

Task: "fix login timeout bug"
  → Scores each step by keyword overlap with task description
  → Mandatory steps (condition='always', optional=false) always included first
  → Optional steps ranked by relevance score, capped at 3 total
  → Result: debugging (score 105) → tdd (score 101) → quality-gate (score 100)

**Why it matters (SkillsBench research):**

• 2-3 focused skills → **+18.6pp** task performance
• 4+ skills → **+5.9pp**
• Monolithic loading → **-2.9pp**

If a chain has more than 3 mandatory steps, all mandatory steps run and a performance advisory is logged.

Workflow

1. **Start**: Use `chain auto` for auto-detection or `chain start` for specific chains 2. **Execute**: Work through each skill step, using `@[/skill-name]` to invoke 3. **Advance**: When step is done, run `chain advance <id> "summary"` 4. **Repeat**: Continue until all steps complete 5. **Track**: Use `chain status` to monitor progress anytime

Integration with Other Skills

• **cm-continuity**: Chain progress persists across sessions via CONTINUITY.md working memory
• **cm-execution**: Each chain step delegates to cm-execution for actual implementation
• **cm-quality-gate**: Automatically runs at end of each development chain
• **Context Bus (v5)**: Every chain automatically maintains `.cm/context-bus.json` — shared state across all steps

Context Bus — Inter-Skill Coordination (v5)

When `chain start` runs, the context bus is initialized automatically:

chain start feature-development "add payment flow"
→ Creates .cm/context-bus.json with:
    pipeline: "feature-development"
    session_id: "<uuid>"
    current_step: "brainstorm-idea"
    shared_context: {}
    resource_state: { skeleton_generated: null, learnings_indexed: null, ... }

When `chain advance` runs after each skill completes:

chain advance <exec-id> "summary of what was done"
→ Updates context-bus.json:
    current_step: "planning"   ← moved forward
    shared_context.brainstorm-idea: { summary, affected_files, output_path }

**What downstream skills gain:**

• `cm-planning` can read brainstorm output path → no re-read of full filesystem
• `cm-tdd` can see which files planning created → targeted test generation
• `cm-quality-gate` knows exactly which files changed → focused review

**Reading the bus:**

cm continuity bus          # terminal pretty-print
cm_bus_read                # MCP tool (Claude Desktop)
cm://pipeline/current      # URI resolver (in skill prompts)

**Publishing to the bus (inside a skill):**

cm_bus_write skill=cm-planning summary="tasks.md created" output_path=openspec/...

For AI Agents

When dispatching tasks that match a chain pattern:

1. Check if task matches a chain: suggestChain(taskTitle)
2. If match found, suggest to user: "This task matches the X chain pipeline"
3. If user agrees, start the chain and invoke skills in order
4. At the START of each skill step:
   → Read cm://pipeline/current to see upstream skill outputs
   → Check shared_context to avoid re-doing work
5. After completing each skill, advance the chain:
   → chain advance <id> "summary"
   → This updates context bus + CONTINUITY.md simultaneously