Chain

1. Ordered skill list — sequence of skills to run
2. Parallelism markers — which skills can run concurrently (+)
3. Arguments — per-skill args (in parentheses or from context)
4. Stop conditions — --stop-on-fail is ON by default. Use --force to override.
5. Context topic — what the chain is about (inferred from conversation)

Step 2: Validate

Before executing, silently verify:

• All skills exist in the skill registry (docs/skill-registry.md)
• No circular dependencies
• Parallel skills are truly independent (no output→input dependency)

If validation fails, tell the user what's wrong and suggest a fix. Do NOT ask for permission to proceed with valid chains.

Step 3: Execute

For each step in the chain:

1. Load context from previous step — pass relevant outputs forward

   • Research findings → feed into project creation
   • Project structure → feed into planning skills
   • Plan outputs → feed into build/review skills
   • Keep a running chain_context object with key findings per step

2. Run the skill — invoke via the Skill tool (or Agent for complex skills)

   • For parallel skills: launch simultaneously using multiple tool calls
   • For sequential skills: wait for completion before next step

3. Capture output — extract:

   • status: success | partial | failed | infeasible
   • key_findings: 3-5 bullet summary of what the skill produced
   • artifacts: file paths, URLs, or resources created
   • stop_signal: boolean — should the chain halt?

4. Check stop condition:

   • If stop_signal is true AND --stop-on-fail is on: halt chain, report why
   • If status is "infeasible": halt chain, report findings, suggest alternatives
   • Otherwise: continue to next step

Step 4: Report

After chain completes (or halts), give the user a single summary:

## Chain Complete: [topic]

### Steps Executed
1. ✓ /skill1 — [one-line result]
2. ✓ /skill2 — [one-line result]
3. ✗ /skill3 — [why it stopped] (if applicable)

### Key Artifacts
- [file/resource 1]
- [file/resource 2]

### What's Next
- [suggested next action based on chain output]

Context Passing Rules

Skills don't natively share state, so YOU are the glue. Between steps:

Parallel Execution

When skills are marked parallel (+):

• Launch all parallel skills simultaneously
• Wait for ALL to complete before moving to next sequential step
• Merge outputs into chain_context
• If any parallel skill fails with --stop-on-fail, cancel remaining parallel skills

Stop-on-Fail Semantics

A skill signals "fail/infeasible" when:

• /diglet finds the approach is not technically feasible
• /qa returns a health score below 30%
• /review finds critical blocking issues
• Any skill explicitly says "this won't work" or "not feasible"

When stopped:

• Report what was learned
• Suggest pivots or alternatives
• Save findings to project files (don't waste the research)

Extensibility

This skill works with ANY skill in the registry. When new skills are added:

• They automatically work in chains — no changes needed here
• Just follow the context-passing pattern: extract key_findings from output, feed to next skill
• If a new skill has special chain behavior, add a row to the Context Passing Rules table above

Rules

• No review pauses. The whole point is autonomous execution. Don't ask "should I continue?" between steps.
• Do report progress. Brief status lines between skills are fine: "✓ Research complete, starting project creation..."
• Stop on infeasibility. If research says "this can't work", don't create a project for something that can't work.
• Save everything. Even if the chain stops early, save research outputs and partial work to files.
• Respect skill protocols. Each skill has its own rules (e.g., diglet saves to research-reports/). Follow them.