---

name: 00-meta-chain-flow-150 description: "[00] META. Orchestrate skills into dynamic chains for complex tasks. Analyzes the task, discovers available skills, builds an optimal chain, explains why each skill is needed, and executes step-by-step with user confirmation. Use for any complex task requiring multiple thinking/research/analysis steps. Triggers on "plan this", "how to approach", "what's the strategy", "build a plan", or any multi-step problem requiring skill orchestration."

Meta-Chain-Flow 150 Protocol

Core Principle: Orchestrate skills dynamically. Analyze the task, discover available skills, build the right chain, explain the reasoning, execute step-by-step with confirmation.

What This Skill Does

This is a meta-skill — an orchestrator that:

• Analyzes the task to understand what's needed
• Discovers available skills (finds where they are, what exists)
• Builds a chain of appropriate skills in the right order
• Explains why each skill is in the chain
• Executes step-by-step with user confirmation
• Adapts the chain as new information emerges

The Orchestration Model

🔗 CHAIN-FLOW 150 (Orchestrator)
        ↓
[1. Analyze Task] → What type of problem is this?
        ↓
[2. Discover Skills] → What skills are available? Where?
        ↓
[3. Build Chain] → Which skills? In what order?
        ↓
[4. Explain Why] → Justify each skill in the chain
        ↓
[5. Execute] → Step by step with confirmation
        ↓
[6. Adapt] → Modify chain if situation changes

Skill Discovery

Chain-Flow finds available skills by:

Where to Look for Skills

📁 SKILL LOCATIONS (search in order)
├── ./.codex/skills/          # Project skills folder (canonical)
├── ./skills/                 # Legacy project skills (if present)
├── ./.claude/skills/         # Legacy project Claude skills (if present)
├── ~/.claude/skills/         # Personal skills (home directory, if present)
├── Plugin skills             # From installed plugins
└── Built-in capabilities     # Agent's native abilities

How to Discover Skills

# Find all skill directories
ls -la ./.codex/skills/ 2>/dev/null
ls -la ./skills/ 2>/dev/null
ls -la ./.claude/skills/ 2>/dev/null
ls -la ~/.claude/skills/ 2>/dev/null

# Read each SKILL.md to understand capabilities
cat ./.codex/skills/*/SKILL.md | head -20  # Read descriptions

Discovery Process

1. Scan directories — Find all folders with SKILL.md
2. Read name + description — Understand what each skill does
3. Map triggers — Know when each skill applies
4. Build skill inventory — Create list of available skills
5. Match to task — Select relevant skills for current task

The 150% Orchestration Rule

• 100% Core: Build appropriate skill chain + execute with confirmation
• 50% Enhancement: Explain reasoning + adapt chain dynamically

When to Use This Skill

Universal trigger: Any complex task that needs multiple skills combined.

Specific triggers:

• Complex multi-step problems
• Tasks requiring research + thinking + execution
• When you're not sure which approach to take
• Strategic planning for projects
• Any request where single skill isn't enough

Key insight: Most real problems need chains of skills, not single skills.

Chain Building Process

Step 1: ANALYZE THE TASK

Understand what the task requires:

• What's the nature of the problem?
• What types of thinking/research/execution needed?
• What's the complexity level?
• What are the unknowns?

Step 2: DISCOVER AVAILABLE SKILLS

Find what skills are available:

🔍 Skill Discovery:
- Scanning ./.codex/skills/ ...
- Scanning ./skills/ ...
- Scanning ./.claude/skills/ ...
- Scanning ~/.claude/skills/ ...

Found Skills:
├── goal-clarity-150    — Clarify objectives and success criteria
├── research-deep-150   — Deep research from internal + external sources
├── impact-map-150      — Map what changes affect
├── action-plan-150     — Create actionable plans with steps/risks
├── deep-think-150      — Quality reasoning and analysis
├── max-quality-150     — High quality execution
├── 74-mid-session-save-150    — Mid-session checkpoint for continuity
├── gated-exec-150      — Execute with confirmation gates
├── proof-grade-150     — Verify facts with confidence levels
├── integrity-check-150 — Final quality self-check
├── task-track-150      — Manage task lifecycle and status
├── tidy-up-150         — Quick cleanup after milestones
├── ask-ai-150          — Consult external AI models
└── skill-forge-150     — Create new skills when needed

Reading descriptions to match task requirements...

Step 3: BUILD THE CHAIN

Construct the skill sequence:

• Which skills are relevant?
• What's the logical order?
• Are there dependencies between skills?

Step 4: EXPLAIN THE CHAIN

Justify each skill:

📋 Proposed Chain:

1. goal-clarity-150
   WHY: Task requirements are ambiguous, need to clarify first

2. research-deep-150  
   WHY: Need to understand current system + best practices

3. impact-map-150
   WHY: Changes will affect multiple components

4. deep-think-150
   WHY: Architecture decision with trade-offs

5. max-quality-150
   WHY: Critical feature, needs high quality execution

Step 5: EXECUTE WITH CONFIRMATION

Go step by step:

🔗 Chain Execution:

Step 1/5: goal-clarity-150
[Execute skill...]
✅ Complete. Proceed to Step 2? (Yes/No/Modify chain)

Step 6: ADAPT IF NEEDED

Modify chain based on new information:

🔄 Chain Adaptation:

New information discovered: Security implications found
→ Adding: security-check skill after impact-map
→ Updated chain: 1→2→3→3.5(new)→4→5

Continue with updated chain? (Yes/No)

Output Format

When using Chain-Flow 150:

🔗 **Chain-Flow 150 Activated**

**Task Analysis:**
[Understanding of what's needed]

**Skills Discovered:**
- [List of available skills with brief descriptions]

**Proposed Chain:**

1. [skill-name] → WHY: [justification]
2. [skill-name] → WHY: [justification]
3. [skill-name] → WHY: [justification] ...

**Execution Plan:**
- Estimated steps: [N]
- Confirmation: After each skill
- Adaptation: Will modify if needed

**Ready to begin chain execution?**

Chain Execution Format

During execution:

🔗 **Chain-Flow: Step [X/N]**

**Current Skill:** [skill-name]
**Purpose:** [why this skill now]

[Skill execution output...]

**Step Complete:** ✅

**Next:** [next-skill-name]
**Continue?** (Yes / No / Modify Chain / Skip to Step N)

Common Chain Patterns

Pattern: New Feature Development

goal-clarity-150 → research-deep-150 → impact-map-150 → 
action-plan-150 → max-quality-150

Pattern: Complex Project

goal-clarity-150 → research-deep-150 → impact-map-150 → 
deep-think-150 → action-plan-150 → max-quality-150

Pattern: Bug Investigation

research-deep-150 (logs, git) → impact-map-150 → 
deep-think-150 → action-plan-150 (fix steps) → max-quality-150

Pattern: Architecture Decision

goal-clarity-150 → research-deep-150 (options) → 
deep-think-150 (trade-offs) → impact-map-150 → action-plan-150

Pattern: Code Review

research-deep-150 (understand) → impact-map-150 → 
deep-think-150 (issues) → max-quality-150 (feedback)

Pattern: Migration/Refactoring

goal-clarity-150 → impact-map-150 → research-deep-150 → 
action-plan-150 (detailed steps) → max-quality-150

Operational Rules

1. DISCOVER FIRST: Always find what skills are available
2. JUSTIFY EACH: Explain why each skill is in the chain
3. CONFIRM STEPS: Get user confirmation between skills
4. ADAPT FREELY: Modify chain when new information emerges
5. SKIP ALLOWED: User can skip skills if not needed
6. CHAIN IS FLEXIBLE: Not rigid — adjust to reality

Failure Modes & Recovery

Failure	Detection	Recovery
Wrong chain	Results don't help	Re-analyze, rebuild chain
Missing skill	Gap in chain	Add skill or use alternative
Wrong order	Dependencies broken	Reorder chain
Over-engineering	Too many skills	Simplify chain
Under-engineering	Skipped needed skill	Add missing skill

Examples

❌ Without Chain-Flow

User: "Add payment processing to the app"
AI: [Jumps straight to coding]
Result: Missed security requirements, broke existing checkout, 
no understanding of payment gateway options

✅ With Chain-Flow 150

User: "Add payment processing to the app"

🔗 Chain-Flow 150 Activated

Task Analysis:
Complex integration task with security, external APIs, 
and business logic implications.

Skills Discovered:
- goal-clarity-150, research-deep-150, impact-map-150
- action-plan-150, deep-think-150, max-quality-150

Proposed Chain:

1. goal-clarity-150
   WHY: Payment requirements vary (subscriptions? one-time? refunds?)
   
2. research-deep-150
   WHY: Need to evaluate Stripe vs PayPal vs others + security standards
   
3. impact-map-150
   WHY: Touches checkout, user accounts, database, notifications
   
4. deep-think-150
   WHY: Architecture decision for payment service integration

5. action-plan-150
   WHY: Create detailed implementation plan with rollback points
   
6. max-quality-150
   WHY: Payment code must be high quality (money involved)

Ready to begin? Starting with goal-clarity-150...

---

🔗 Chain-Flow: Step 1/5

Current Skill: goal-clarity-150
Purpose: Clarify payment requirements before research

[Executing goal-clarity-150...]

Questions:
- One-time payments, subscriptions, or both?
- Which currencies?
- Refund policy needed?
- PCI compliance level required?

[User answers...]

Step Complete: ✅
Requirements documented.

Next: research-deep-150
Continue? (Yes/No/Modify)

Relationship to Other Skills

Chain-Flow is the orchestrator — it doesn't replace other skills, it combines them:

                    🔗 CHAIN-FLOW-150
                    (Orchestrator)
                         ↓
    ┌────────────────────┼────────────────────┐
    ↓                    ↓                    ↓
goal-clarity    research-deep         impact-map
    ↓                    ↓                    ↓
deep-think         max-quality          [others]

---

Remember: Complex problems need chains of skills, not single skills. Chain-Flow builds the right chain, explains why, and executes step-by-step with your confirmation. You stay in control while getting the benefit of orchestrated skill application.