00-meta-chain-flow-150

# 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
```bash
# 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.