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

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