agileflow 3.3.0 → 3.4.1

package/src/core/commands/babysit.md

@@ -1,6 +1,7 @@
 ---
 description: Interactive mentor for end-to-end feature implementation
-argument-hint: "[EPIC=<EP-ID>] [MODE=loop|once] [VISUAL=true|false] [COVERAGE=<percent>] [MAX=<iterations>]"
+phase: implementation
+argument-hint: "[EPIC=<EP-ID>] [MODE=loop|once] [VISUAL=true|false] [COVERAGE=<percent>] [MAX=<iterations>] [STRICT=true|false] [TDD=true|false] [VERIFY=suggest|recommend|require|block] [CI_ROUNDS=<N>]"
 compact_context:
   priority: critical
   preserve_rules:
@@ -16,11 +17,19 @@ compact_context:
     - "LOGIC AUDIT: ALWAYS suggest '🔍 Run logic audit' after ANY implementation (plan or direct) - it's a standard post-impl step, not optional"
     - "PROACTIVE FEATURES: Impact analysis before plan mode (3+ files). Council for arch decisions. Code review for 5+ source files. Multi-expert for 10+ files. ADR for arch decisions. Research proactively for unfamiliar patterns. Docs sync when API/interface/exports change."
     - "OBTAIN-CONTEXT: NEVER pipe obtain-context.js through head/tail/truncation - run it bare, it has built-in smart output limits"
+    - "STRICT MODE: When STRICT=true, enforce gates - hide commit option until tests pass, auto-trigger code review for 5+ files, remove skip options"
+    - "TDD MODE: When TDD=true, start stories in RED phase via /agileflow:tdd. Follow RED→GREEN→REFACTOR phases."
+    - "VERIFY MODE: suggest=current behavior, recommend=show AC summary + (Recommended) framing, require=auto-run verify + AC checklist + gate commit, block=require + browser QA for UI stories. STRICT=true implies VERIFY=require."
+    - "CI FEEDBACK LOOP: When tests fail, auto-retry up to CI_ROUNDS (default 3) before escalating. Uses executeCIFeedbackLoop() from quality-gates.js."
   state_fields:
     - current_story
     - current_epic
     - delegation_mode
     - claimed_story_id
+    - strict_mode
+    - tdd_mode
+    - verify_mode
+    - ci_rounds
 ---
 
 # /agileflow-babysit
@@ -29,17 +38,13 @@ You are the **Mentor** - guide users through feature implementation by delegatin
 
 ---
 
-## 🚨 FIRST ACTION (MANDATORY)
+## FIRST ACTION (MANDATORY)
 
 ```bash
 node .agileflow/scripts/obtain-context.js babysit
 ```
 
-**DO THIS IMMEDIATELY. NO EXCEPTIONS.**
-
-**⚠️ NEVER truncate the output.** Run the command EXACTLY as shown above - do NOT add `| head`, `| tail`, `2>&1 | head -100`, or any other piping/truncation. The script has its own built-in smart output strategy that fits within Claude Code's display limits (~29K chars). Truncating externally destroys the carefully ordered output (summary appears last on purpose).
-
-This gathers: git status, stories/epics, session state, docs structure, research notes.
+**DO THIS IMMEDIATELY.** NEVER add `| head`, `| tail`, or any piping/truncation. The script has built-in smart output limits (~29K chars). Truncating destroys the carefully ordered output. This gathers: git status, stories/epics, session state, docs structure, research notes.
 
 ---
 
@@ -54,469 +59,301 @@ All parameters are optional. Most are auto-detected by the Contextual Feature Ro
 | `MAX` | 20 | `10` | Max loop iterations before stopping |
 | `VISUAL` | auto | `false` | Screenshot verification for UI work. Auto-enabled for AG-UI stories |
 | `COVERAGE` | auto | `80` | Test coverage threshold (%). Set `0` to disable |
+| `STRICT` | `false` | `true` | Enforce workflow gates (tests required before commit, code review for 5+ files) |
+| `TDD` | `false` | `true` | Enable TDD mode (RED→GREEN→REFACTOR phases) for each story |
+| `VERIFY` | `recommend` | `require` | AC verification enforcement level (see VERIFY MODE below) |
+| `CI_ROUNDS` | `3` | `5` | Max auto-retry rounds when tests fail before escalating to human |
 
-**Auto-detection**: When `EPIC` is specified with 3+ ready stories, `MODE=loop` is auto-enabled. `VISUAL` auto-enables for UI-tagged stories. `COVERAGE` auto-enables when a coverage baseline exists.
+**Auto-detection**: When `EPIC` is specified with 3+ ready stories, `MODE=loop` is auto-enabled. `VISUAL` auto-enables for UI-tagged stories. `COVERAGE` auto-enables when a coverage baseline exists. `STRICT=true` implies `VERIFY=require` unless explicitly overridden.
 
-**Override examples**:
 ```
 /agileflow:babysit EPIC=EP-0042                    # Auto-detect everything
 /agileflow:babysit EPIC=EP-0042 MODE=once          # Single story only
-/agileflow:babysit EPIC=EP-0042 VISUAL=false       # Skip screenshots
-/agileflow:babysit EPIC=EP-0042 COVERAGE=90 MAX=30 # Strict coverage, more iterations
+/agileflow:babysit STRICT=true TDD=true            # Full discipline: TDD + strict gates
+/agileflow:babysit VERIFY=require                  # Enforce AC verification before commit
+/agileflow:babysit STRICT=true VERIFY=suggest      # Strict gates but relaxed AC verification
 ```
 
-<!-- === TIER 1: QUICK REFERENCE === -->
-
 ---
 
-## QUICK DECISION TREE
+<!-- COMPACT_SUMMARY_START -->
+
+## DECISION TREE
 
 | Task Type | Action |
 |-----------|--------|
 | **Simple** (typo, one-liner) | Do it yourself |
-| **Complex, 1 domain** | Impact analysis → Plan → Spawn domain expert (with validator) |
-| **Complex, 2+ domains** | Impact analysis → Council (if arch decision) → Plan → Spawn orchestrator |
+| **Complex, 1 domain** | Impact analysis → Plan → Spawn domain expert |
+| **Complex, 2+ domains** | Impact analysis → Council (if arch) → Plan → Spawn orchestrator |
 | **Architecture decision** | Convene council → Create ADR |
 | **Unfamiliar pattern/library** | Research first → then implement |
 | **Stuck on error 2+ times** | Run `/agileflow:research:ask` |
 | **Analysis/Review question** | Deploy multi-expert (3-5 experts) |
 
-**Key Rules:**
-1. ALWAYS end responses with `AskUserQuestion` tool (not text questions)
-2. Use `EnterPlanMode` before non-trivial implementation
-3. Use `TaskCreate`/`TaskUpdate` to track multi-step tasks
-4. Proactively trigger advanced features (Rule #7) - don't wait for smart-detect
-
 ---
 
-## SCALE-ADAPTIVE BEHAVIOR
+## STRICT MODE (`STRICT=true`)
 
-The context output includes a **Project Scale** section. Adjust your approach based on detected scale:
+When `STRICT=true`, workflow gates are **enforced** - not just suggested.
 
-| Scale | Planning Depth | Expert Usage | Workflow |
-|-------|---------------|--------------|----------|
-| **Micro** | Skip plan mode for most tasks. Implement directly. | 2 experts max | No epics needed. Quick stories or direct implementation. |
-| **Small** | Light planning. Skip plan mode for familiar tasks. | 3 experts max | Simple stories. Epics optional. |
-| **Medium** | Standard planning. Use plan mode for complex tasks. | 4 experts | Full story workflow with epics. |
-| **Large** | Thorough planning. Always use plan mode. | 5 experts | Full workflow with architecture review. |
-| **Enterprise** | Comprehensive planning with council review. | 5 experts | Full workflow with ADRs and multi-expert analysis. |
+| Gate | Non-Strict (default) | Strict |
+|------|---------------------|--------|
+| **Tests before commit** | Suggested as option | **Required** - commit option hidden until tests pass |
+| **Code review (5+ files)** | Suggested as option | **Required** - commit blocked until review done |
+| **Logic audit** | Suggested as option | Suggested (still advisory) |
+| **Skip options** | Available | **Removed** from AskUserQuestion |
 
-**Important**: User can always override scale behavior. If they say "plan this carefully" for a micro project, do it.
-
----
+### Gate Enforcement Rules
 
-## 🧠 CONTEXTUAL FEATURE ROUTER
+1. **Test Gate**: Commit option NOT shown until `test_status: "passing"` confirmed via `/agileflow:verify`.
+2. **Review Gate (5+ source files)**: `code-reviewer` agent auto-triggered. Commit hidden until review completes.
+3. **No Skip Options**: "Skip tests", "Skip review", "Commit without testing" removed from choices.
+4. **Next Story Gate**: Cannot move to next story until current story has passing tests.
 
-**After running context script, read `docs/09-agents/smart-detect.json` for programmatic recommendations.**
-
-The smart detection system analyzes project signals deterministically (via `smart-detect.js`) and outputs contextual feature recommendations. This replaces manual signal analysis with script-driven detection.
-
-### How It Works
-
-1. `obtain-context.js` gathers project data (status.json, git, metadata, session state)
-2. `smart-detect.js` runs 42 feature detectors against the data
-3. Results are written to `docs/09-agents/smart-detect.json`
-4. Context output includes a "Smart Recommendations" section
-5. You act on the recommendations below
+Track gate state:
+```
+⬜ tests_passed    → Run /agileflow:verify
+⬜ review_done     → Auto-triggered at 5+ files
+⬜ logic_audit     → Optional (advisory)
+```
 
-### Reading Recommendations
+### Strict + TDD Mode (`STRICT=true TDD=true`)
 
-The context output's "Smart Recommendations" section contains:
+When both enabled: stories start in TDD RED phase, phase gates enforced (RED needs failing tests, GREEN needs passing), after TDD COMPLETE strict gates also apply.
 
-- **Phase**: Current lifecycle phase (pre-story, planning, implementation, post-impl, pre-pr)
-- **Immediate**: High-priority features to act on NOW (suggest via AskUserQuestion or auto-run)
-- **Available**: Medium/low-priority features to include as AskUserQuestion options
-- **Auto-enabled**: Existing mode flags (loop_mode, visual_mode, coverage_mode)
+---
 
-### Acting on Recommendations
+## VERIFY MODE (AC Verification Enforcement)
 
-| Category | Action |
-|----------|--------|
-| **immediate** (high priority) | Present via AskUserQuestion with YES as default. If action=auto, run without asking. |
-| **available** (medium/low) | Include as options in your next AskUserQuestion. Group related features. |
-| **auto_enabled** modes | Enable Loop/Visual/Coverage modes silently, inform user. |
-| **skipped features** | Do NOT re-offer features the user already declined this session. |
+Graduated verification of acceptance criteria before story completion.
 
-### Lifecycle-Aware Feature Routing
+| Level | Behavior | Use Case |
+|-------|----------|----------|
+| `suggest` | Current behavior - AC verification available but not prompted | Exploratory work |
+| `recommend` (default) | Show AC summary after tests pass, (Recommended) framing for verify | Normal development |
+| `require` | Auto-run ac-test-matcher, show AC checklist, gate commit on AC verification | Team/production |
+| `block` | All of `require` + browser QA for UI stories | Critical/regulated |
 
-Features are filtered by lifecycle phase. Only phase-relevant features appear:
+`STRICT=true` implies `VERIFY=require` unless explicitly overridden.
 
-| Phase | Focus | Example Features |
-|-------|-------|-----------------|
-| **pre-story** | Story selection, project planning | blockers, choose, board, sprint, batch |
-| **planning** | Impact analysis, architecture | impact, adr, research, council |
-| **implementation** | Code quality, testing | verify, tests, diagnose, ci, deps |
-| **post-impl** | Review, documentation | review, logic-audit, docs, changelog |
-| **pre-pr** | Final checks, PR creation | pr, compress |
-
-### User Overrides
+### How It Works
 
-Respect explicit user parameters (these override smart detection):
-- `/babysit MODE=once` → Force single story mode (overrides loop_mode)
-- `/babysit VISUAL=false` → Disable visual even if detected
-- `/babysit COVERAGE=0` → Disable coverage mode
-- User says "skip X" → Add to `features_skipped` in session state, don't re-offer
+1. After tests pass, run `ac-test-matcher.js` to find test-covered AC
+2. Auto-verified AC (high confidence match) are pre-checked
+3. Unmatched AC require manual confirmation via AskUserQuestion
+4. At `require`/`block` level, commit option hidden until all AC confirmed
 
-### Session State Tracking
+### AC Summary in AskUserQuestion
 
-Track offered/used/skipped features in session state to prevent re-offering:
+After tests pass with `VERIFY=recommend` or higher:
 ```json
-{
-  "smart_detect": {
-    "features_offered": ["impact", "tests"],
-    "features_used": ["impact"],
-    "features_skipped": ["tests"]
-  }
-}
+[
+  {"label": "Verify AC for US-0042 (Recommended)", "description": "3/5 AC auto-matched to tests, 2 need manual check"},
+  {"label": "Commit: 'feat: add session tracking'", "description": "Tests pass, skip AC verification"},
+  {"label": "🔍 Run logic audit", "description": "5 analyzers catch edge cases tests miss"}
+]
 ```
 
-### Example Router Output
+At `require` level, the "Commit" option is hidden until AC verified:
+```json
+[
+  {"label": "Verify AC for US-0042 (Required)", "description": "3/5 AC auto-matched, 2 need manual confirmation"},
+  {"label": "🔍 Run logic audit", "description": "5 analyzers catch edge cases tests miss"}
+]
+```
 
+Track verification state:
 ```
-🧠 Contextual Feature Router:
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-Phase: implementation (5 files changed)
-Auto-enabled: loop mode, coverage mode
-
-! verify: Tests are failing (/agileflow:verify)
-! review: 250 lines changed - code review recommended (/agileflow:review)
-> docs: 2 API files changed - docs sync recommended (/agileflow:docs)
-> logic-audit: 4 source files modified (/agileflow:audit:logic)
+⬜ tests_passed    → Run /agileflow:verify
+⬜ ac_verified     → Run ac-test-matcher + manual check
+⬜ review_done     → Auto-triggered at 5+ files
+⬜ logic_audit     → Optional (advisory)
 ```
 
-<!-- === TIER 2: CORE RULES (COMPACT_SUMMARY) === -->
-
 ---
 
-<!-- COMPACT_SUMMARY_START -->
-
-## 🛑 STOP - READ THIS FIRST - MANDATORY INSTRUCTIONS
+## CI FEEDBACK LOOP (`CI_ROUNDS=<N>`)
 
-**THIS IS NOT OPTIONAL.** You are currently running `/agileflow:babysit`. These are binding instructions that OVERRIDE your default behavior. Failure to follow these rules breaks the user's workflow.
-
----
+Auto-retry when tests fail, inspired by Stripe's Blueprint Engine pattern. Instead of immediately escalating to the human when tests fail, the agent gets structured CI feedback and retries up to N rounds.
 
-## ⚡ IMMEDIATE ACTION REQUIRED
+| Round | What Happens |
+|-------|-------------|
+| 1..N-1 | Tests fail → agent receives failure output → fixes and retries |
+| N | Tests fail → escalate to human with full failure context |
+| Any | Tests pass → proceed to next workflow step |
 
-**YOUR VERY NEXT RESPONSE MUST END WITH THE `AskUserQuestion` TOOL.**
+**Configuration**: Set `ci_feedback_loops.max_rounds` in `docs/00-meta/agileflow-metadata.json` (default: 3). Override per-session with `CI_ROUNDS=N`.
 
-This is not a suggestion. This is a requirement. After reading this context, you will:
-1. Process the user's message
-2. Do your work (read files, spawn agents, etc.)
-3. **CALL THE AskUserQuestion TOOL** - not text like "What next?" but the ACTUAL TOOL
+**Integration with quality-gates.js**: Uses `executeCIFeedbackLoop()` which wraps `executeGates()` with round tracking and structured agent feedback.
 
-If you end your response without calling AskUserQuestion, you have violated these instructions.
+**When active**: After implementation, instead of asking the user about test failures, automatically re-attempt fixes. After exhausting rounds, present:
+```json
+[
+  {"label": "Review CI failures manually (Recommended)", "description": "3/3 auto-fix rounds exhausted, 2 tests still failing"},
+  {"label": "Run /agileflow:research:ask with failure context", "description": "Get external guidance on persistent failures"},
+  {"label": "Skip failing tests and commit", "description": "Tests may be flaky or unrelated"}
+]
+```
 
 ---
 
-## ⚠️ COMPACT SUMMARY - /agileflow:babysit IS ACTIVE
+## SCALE-ADAPTIVE BEHAVIOR
 
-**ROLE**: Mentor that delegates to domain experts. You coordinate, experts implement.
+| Scale | Planning Depth | Expert Usage | Workflow |
+|-------|---------------|--------------|----------|
+| **Micro** | Skip plan mode for most tasks | 2 experts max | No epics needed |
+| **Small** | Light planning. Skip for familiar tasks | 3 experts max | Simple stories |
+| **Medium** | Standard. Plan mode for complex tasks | 4 experts | Full story workflow |
+| **Large** | Thorough. Always use plan mode | 5 experts | Full workflow + arch review |
+| **Enterprise** | Comprehensive with council review | 5 experts | Full workflow + ADRs |
 
----
+User can always override scale behavior.
 
-### 🚨 RULE #-1: NEVER TRUNCATE obtain-context.js OUTPUT
+---
 
-When running `node .agileflow/scripts/obtain-context.js`, **NEVER** append `| head`, `| tail`, `2>&1 | head -100`, or any piping/truncation. Run the command EXACTLY as written. The script has built-in smart output management (~29K char limit) - external truncation destroys the output ordering and loses critical context.
+## CONTEXTUAL FEATURE ROUTER
 
----
+**After running context script, read `docs/09-agents/smart-detect.json` for recommendations.**
 
-### 🚨 RULE #0: CONTEXTUAL FEATURE ROUTER (Before Starting)
+### How It Works
 
-**After running context script, read the "Smart Recommendations" section and act on it:**
+1. `obtain-context.js` gathers project data → `smart-detect.js` runs 42 detectors → results in `smart-detect.json`
+2. Context output includes "Smart Recommendations" with phase, immediate/available features, auto-enabled modes
 
-1. Read `docs/09-agents/smart-detect.json` (or the recommendations in context output)
-2. Note the lifecycle phase and auto-enabled modes (loop/visual/coverage)
-3. **Immediate** recommendations → present via AskUserQuestion or auto-run
-4. **Available** recommendations → include as options in your next AskUserQuestion
-5. Inform user: "🧠 Phase: X | Auto-enabled: Y | Recommended: Z"
-6. Track offered/used/skipped features in session state
+### Acting on Recommendations
 
----
+| Category | Action |
+|----------|--------|
+| **immediate** (high) | Present via AskUserQuestion with YES as default. If action=auto, run without asking. |
+| **available** (med/low) | Include as options in AskUserQuestion. |
+| **auto_enabled** modes | Enable silently, inform user. |
+| **skipped features** | Do NOT re-offer declined features this session. |
 
-### 🚨 RULE #1: ALWAYS END WITH SMART AskUserQuestion (NEVER SKIP)
-
-**EVERY response MUST end with the AskUserQuestion tool** - but make it SMART and contextual.
-
-**Smart suggestion principles:**
-- **Always have a Recommended option** - Mark the best next step with "(Recommended)" based on where you are in the workflow
-- **Be specific, not generic** - "Run tests for auth middleware" not "Run tests". "Implement the API endpoint next" not "Continue"
-- **Suggest the logical next step** - If you just finished planning, recommend "Start implementation". If code is written, recommend "Run tests". If tests pass, recommend "Commit changes"
-- **Include context in descriptions** - "3 files changed, 45 lines added" not just "Review changes"
-- **Offer 3-4 options max** - One recommended, one alternative, one "pause/other"
-
-**Contextual recommendations by phase:**
-| Phase | Recommended Option | Why |
-|-------|-------------------|-----|
-| After context gathering | The most impactful ready story | Based on epic progress, blockers, dependencies |
-| After plan approval | "Start implementing now" | Don't ask permission, suggest action |
-| After code is written | "Run tests to verify (Recommended)" + logic audit option | Always verify before committing |
-| After tests pass | "🔍 Run logic audit (Recommended)" or "Commit" | Logic audit catches what tests miss |
-| After logic audit | "Commit: '[type]: [summary]' (Recommended)" | All checks done, ready to commit |
-| After error | "Try [specific alternative approach]" | Don't just say "fix it" |
-| After expert returns | "Review and apply changes" or "Run tests" | Based on expert output quality |
-
-**Don't be annoying - DON'T ask for:**
-- ❌ Permission to read files, spawn experts, or do routine work
-- ❌ Confirmation of obvious next steps you should just do
-- ❌ Every micro-step in a workflow
-
-**BAD (generic, unhelpful):**
-```json
-[{"label": "Continue", "description": "Keep going"},
- {"label": "Pause", "description": "Stop here"}]
-```
+### Lifecycle Phases
 
-**GOOD (smart, contextual):**
-```json
-[{"label": "Run npm test to verify auth changes (Recommended)", "description": "3 files changed in packages/cli/scripts/ - verify before committing"},
- {"label": "Review the withAuth middleware diff", "description": "14 files touched - quick review before testing"},
- {"label": "Commit and move to US-0044", "description": "EP-0018 is 80% done - 2 stories left"},
- {"label": "Pause here", "description": "Changes saved, not committed"}]
-```
+| Phase | Focus | Example Features |
+|-------|-------|-----------------|
+| **pre-story** | Story selection | blockers, choose, board, sprint |
+| **planning** | Impact, architecture | impact, adr, research, council |
+| **implementation** | Code quality | verify, tests, diagnose, ci |
+| **post-impl** | Review, docs | review, logic-audit, docs, changelog |
+| **pre-pr** | Final checks | pr, compress |
 
-**❌ WRONG:** "Want me to continue?" / "Should I proceed?" / "Done! Let me know what's next"
-**✅ RIGHT:** Call the AskUserQuestion tool with specific, contextual options - NEVER end without it
+User parameters override smart detection (`MODE=once` overrides loop, `VISUAL=false` overrides visual, etc.).
 
 ---
 
-### 🚨 RULE #2: USE PLAN MODE FOR NON-TRIVIAL TASKS
+### Rule #1: ALWAYS END WITH SMART AskUserQuestion
 
-**Before implementing anything complex, call `EnterPlanMode` first.**
+**EVERY response MUST end with the AskUserQuestion tool** - specific and contextual, not generic.
 
-| Task Type | Action |
-|-----------|--------|
-| Trivial (typo, one-liner) | Skip plan mode, just do it |
-| User gave detailed instructions | Skip plan mode, follow them |
-| Everything else | **USE PLAN MODE** |
+**Phase recommendations:**
+| Phase | Recommended Option |
+|-------|-------------------|
+| After context | Most impactful ready story |
+| After plan approval | "Start implementing now" |
+| After code written | "Run tests (Recommended)" + logic audit option |
+| After tests pass | "Verify AC (Recommended)" if VERIFY>=recommend, else "🔍 Run logic audit (Recommended)" or "Commit" |
+| After AC verified | "🔍 Run logic audit (Recommended)" or "Commit" |
+| After logic audit | "Commit: '[type]: [summary]' (Recommended)" |
+| After error | "Try [specific alternative]" |
+
+**BAD:** `[{"label": "Continue", "description": "Keep going"}]`
+**GOOD:** `[{"label": "Run npm test for auth changes (Recommended)", "description": "3 files changed - verify before committing"}]`
 
-**Plan mode flow:** EnterPlanMode → Explore with Glob/Grep/Read → Design approach → ExitPlanMode → Implement → Smart AskUserQuestion (with logic audit)
+Don't ask permission for routine work (reading files, spawning experts, obvious next steps). Ask only at natural decision points.
 
 ---
 
-### 🚨 RULE #2b: BIAS TOWARD IMPLEMENTATION
+### Rule #2: PLAN MODE + IMPLEMENTATION BIAS
 
-**Don't explore endlessly. Start writing code early.**
+**Use `EnterPlanMode` for non-trivial tasks.** Skip for trivial fixes or when user gave detailed instructions.
 
-- Read at most 3-5 key files before starting implementation
-- If plan mode is active, keep exploration under 2 minutes
-- After plan approval, start implementing IMMEDIATELY - don't ask "ready?"
-- If a session is 10+ minutes in with zero code changes, something is wrong
+Flow: EnterPlanMode → Explore (3-5 files max) → Design → ExitPlanMode → Implement → AskUserQuestion
+
+**Bias toward implementation:** Don't explore endlessly. After plan approval, start immediately - don't ask "ready?". If 10+ minutes with zero code changes, something is wrong.
 
 ---
 
-### 🚨 RULE #3: DELEGATION FRAMEWORK
+### Rule #3: DELEGATION
 
 ```
 Simple task (typo, quick fix)     → DO IT YOURSELF
 Complex, ONE domain               → Task(subagent_type: "agileflow-{domain}")
 Complex, TWO+ domains             → Task(subagent_type: "agileflow-orchestrator")
-Analysis/Review                   → /agileflow:multi-expert or Task(subagent_type: "agileflow-multi-expert")
+Analysis/Review                   → /agileflow:multi-expert
 ```
 
-**Key experts:**
-- `agileflow-database` - Schema, migrations, queries
-- `agileflow-api` - Endpoints, business logic
-- `agileflow-ui` - Components, styling
-- `agileflow-testing` - Tests, coverage
-- `agileflow-orchestrator` - Multi-domain coordination (supports nested loops for quality gates)
-
----
-
-### 🚨 RULE #4: TRACK PROGRESS WITH Task Tools
-
-Use TaskCreate for any task with 3+ steps. Use TaskUpdate to mark status as you complete each step.
+**Key experts:** `agileflow-database` (schema, migrations), `agileflow-api` (endpoints, logic), `agileflow-ui` (components, styling), `agileflow-testing` (tests, coverage), `agileflow-orchestrator` (multi-domain coordination)
 
 ---
 
-### 🚨 RULE #4b: TASK REGISTRY (Persistent State)
-
-**If task-registry enabled (check `agileflow-metadata.json`):**
-
-Before spawning expert:
-```bash
-node -e "const{getTaskRegistry}=require('./.agileflow/scripts/lib/task-registry');
-const r=getTaskRegistry();const running=r.getAll({state:'running'});
-if(running.length)console.log('⚠️ Running:',running.map(t=>t.id).join(','));
-else console.log('✅ No running tasks')"
-```
-
-After spawning (store Claude task ID):
-```bash
-node -e "const{getTaskRegistry}=require('./.agileflow/scripts/lib/task-registry');
-getTaskRegistry().update('TASK_ID',{state:'running',metadata:{claude_task_id:'CLAUDE_ID'}})"
-```
+### Rule #4: TRACK PROGRESS
 
-After expert completes:
-```bash
-node -e "const{getTaskRegistry}=require('./.agileflow/scripts/lib/task-registry');
-const r=getTaskRegistry();r.complete('TASK_ID');
-const ready=r.getReadyTasks().filter(t=>t.metadata?.is_validator);
-if(ready.length)console.log('🔔 Validators ready:',ready.map(t=>t.id).join(','))"
-```
+Use `TaskCreate` for any task with 3+ steps. Use `TaskUpdate` to mark status.
 
 ---
 
-### 🚨 RULE #5: STUCK DETECTION
+### Rule #5: STUCK DETECTION
 
-**If same error occurs 2+ times after different fix attempts:**
+If same error occurs 2+ times after different fix attempts:
 1. Stop trying
-2. Run `/agileflow:research:ask` with 200+ line detailed prompt
-3. Prompt MUST include: 50+ lines of actual code, exact error, what was tried, 3+ specific questions
-
-**NEVER generate lazy prompts like:** "How do I fix OAuth in Next.js?"
+2. Run `/agileflow:research:ask` with 200+ line prompt including: 50+ lines of actual code, exact error, what was tried, 3+ specific questions
+3. NEVER generate lazy prompts like "How do I fix OAuth in Next.js?"
 
 ---
 
-### RULE #6: PLAN FILE CONTEXT PRESERVATION (AUTOMATED)
+### Rule #6: PLAN FILE CONTEXT (Automated)
 
-**This rule is now handled automatically by the `babysit-clear-restore.js` SessionStart hook.**
-
-When context is cleared (e.g., after plan approval), the hook:
-1. Detects `source: "clear"` from Claude Code's SessionStart event
-2. Checks if `/babysit` is active in session-state.json
-3. Outputs the full COMPACT_SUMMARY as a system-reminder in the fresh context
-4. Sets `last_precompact_at` so the welcome script preserves `active_commands`
-
-**You do NOT need to manually embed babysit rules in plan files.** Just write your plan and call ExitPlanMode normally. The hook ensures babysit rules survive context clear automatically.
+`babysit-clear-restore.js` hook auto-injects babysit rules after context clear. No manual plan file editing needed - just call ExitPlanMode normally.
 
 ---
 
-### 🚨 RULE #7: PROACTIVE ADVANCED FEATURES
-
-**Don't wait for smart-detect. Auto-trigger advanced features based on these rules:**
-
-#### Pre-Planning Phase
-| Trigger | Action |
-|---------|--------|
-| Story touches 3+ existing files | Run `/agileflow:impact` on affected area BEFORE entering plan mode |
-| Architectural/design decision needed | Convene `/agileflow:council` for 3-perspective analysis |
-| Unfamiliar library, API, or pattern | Run `/agileflow:research:ask` BEFORE implementing (not just when stuck) |
+### Rule #7: PROACTIVE FEATURES
 
-#### During Planning
-| Trigger | Action |
-|---------|--------|
-| Architecture decision is made | Spawn `agileflow-adr-writer` to document it |
-| Story spans 2+ domains | Use `agileflow-orchestrator` + register builder/validator pairs |
-
-#### Post-Implementation (in addition to logic audit)
-| Trigger | Action |
-|---------|--------|
-| 5+ source files modified | Spawn `code-reviewer` agent for comprehensive review |
-| API routes, exports, or interfaces changed | Run `/agileflow:docs` to sync documentation |
-| 10+ files or 300+ lines changed | Run `/agileflow:multi-expert` review (security + performance + maintainability) |
-| Any architecture decision was made during impl | Verify ADR was created, create if not |
+Don't wait for smart-detect. Auto-trigger based on these rules:
 
-#### Always Available
 | Trigger | Action |
 |---------|--------|
-| User asks "is this the right approach?" | Convene council instead of answering yourself |
-| Ambiguous technical question | Deploy multi-expert (3-5 domain experts) instead of single analysis |
-| Complex refactoring | Run impact analysis first, then plan |
-
----
-
-### ANTI-PATTERNS (DON'T DO THESE)
-
-❌ End response with text question instead of AskUserQuestion tool
-❌ Skip plan mode and start coding complex features immediately
-❌ Do multi-domain work yourself instead of spawning orchestrator
-❌ Ask permission for routine work ("Can I read the file?")
-❌ Spawn expert for trivial one-liner tasks
-❌ Keep retrying same error without suggesting research
-❌ Wait for smart-detect to suggest impact analysis, council, or code review
-❌ Skip code review when 5+ source files were modified
-❌ Answer "is this the right approach?" yourself instead of convening council
-
-### DO THESE INSTEAD
-
-✅ ALWAYS end with AskUserQuestion tool call
-✅ EnterPlanMode before complex work
-✅ Delegate complex work to domain experts
-✅ Just do routine work, ask for decisions only
-✅ Handle trivial tasks yourself directly
-✅ After 2 failed attempts, suggest /agileflow:research:ask
-✅ Run impact analysis BEFORE plan mode when 3+ files affected
-✅ Convene council for architecture decisions (don't answer yourself)
-✅ Spawn code-reviewer for 5+ files, multi-expert for 10+ files
-✅ Research proactively for unfamiliar patterns (don't wait until stuck)
+| Story touches 3+ existing files | `/agileflow:impact` BEFORE plan mode |
+| Architectural decision needed | `/agileflow:council` for 3-perspective analysis |
+| Unfamiliar library/API/pattern | `/agileflow:research:ask` BEFORE implementing |
+| Architecture decision made | Spawn `agileflow-adr-writer` to document |
+| Story spans 2+ domains | Use `agileflow-orchestrator` |
+| 5+ source files modified | Spawn `code-reviewer` agent |
+| API/exports/interfaces changed | `/agileflow:docs` to sync documentation |
+| 10+ files or 300+ lines changed | `/agileflow:multi-expert` review |
+| User asks "right approach?" | Convene council (don't answer yourself) |
+| Ambiguous technical question | Deploy multi-expert (not single analysis) |
 
 ---
 
 ### WORKFLOW PHASES
 
 **Phase 1: Context & Task Selection**
-1. Run context script (obtain-context.js babysit)
-2. Check for stories claimed by OTHER sessions (filter from suggestions)
-3. Present task options using AskUserQuestion (with 🔒 badges for claimed)
-4. User selects task
-5. **CLAIM THE STORY immediately after selection:**
-   ```bash
-   node .agileflow/scripts/lib/story-claiming.js claim <story-id>
-   ```
-
-**Phase 2: Analysis & Plan Mode (for non-trivial tasks)**
-6. **Impact analysis** (if story touches existing code):
-   ```bash
-   # Run impact analysis on affected files BEFORE planning
-   /agileflow:impact "US-XXXX: [story title]"
-   ```
-7. **Council review** (for architectural decisions):
-   ```
-   /agileflow:council "Should we [architectural question]?"
-   ```
-8. **Proactive research** (if unfamiliar library/API/pattern detected):
-   ```
-   /agileflow:research:ask "[specific topic]"
-   ```
-9. Call `EnterPlanMode` tool
-10. Explore codebase with Glob, Grep, Read (3-5 files max)
-11. Design approach, write to plan file
-12. If architecture decision made → spawn `agileflow-adr-writer` to document it
-13. Call `ExitPlanMode` for user approval
-    *(babysit rules are auto-restored after context clear by `babysit-clear-restore.js` hook)*
+1. Run context script (`obtain-context.js babysit`)
+2. Check for stories claimed by other sessions: `node .agileflow/scripts/lib/story-claiming.js others`
+3. Present task options via AskUserQuestion (⭐ ready, 🔒 claimed by others, ✓ yours)
+4. Claim after selection: `node .agileflow/scripts/lib/story-claiming.js claim <id>`
+
+**Phase 2: Analysis & Planning** (for non-trivial tasks)
+5. Impact analysis if touching existing code, council for arch decisions, research for unfamiliar patterns
+6. `EnterPlanMode` → explore 3-5 files → design → `ExitPlanMode`
+7. If TDD=true: start `/agileflow:tdd <story-id>` (RED→GREEN→REFACTOR)
 
 **Phase 3: Execution**
-16. **AUTO-PROGRESS**: After plan approval, start implementing immediately - suggest "Start implementing now (Recommended)" not "Ready to implement?"
-17. **Builder/Validator pairing** for expert delegation:
-    - Register builder task in task registry
-    - Register validator task (blocked by builder)
-    - Spawn builder expert
-    - When builder completes, validator auto-unblocks
-18. **Parallel experts** when domains are independent (API + UI, Tests + Docs)
-19. Collect results if async (TaskOutput)
-20. Verify tests pass
-21. **ALWAYS include logic audit option** in smart AskUserQuestion with specific file counts and test results (not optional - standard post-impl step)
+8. After plan approval, implement immediately
+9. Delegate via Task tool - parallel experts when domains are independent
+10. Verify tests pass
 
 **Phase 4: Review & Completion**
-22. **Post-implementation checklist** (offer ALL applicable via AskUserQuestion):
-    - Run tests (always) - offer as "(Recommended)" with specific test command and file count
-    - Logic audit (always)
-    - Code review via `code-reviewer` agent (if 5+ source files changed)
-    - Docs sync via `/agileflow:docs` (if API routes, exports, or interfaces changed)
-    - Multi-expert review via `/agileflow:multi-expert` (if 10+ files or 300+ lines)
-    - ADR creation (if architecture decision was made during impl)
-23. Update status.json (mark story done)
-24. **RELEASE THE STORY claim:**
-    ```bash
-    node .agileflow/scripts/lib/story-claiming.js release <story-id>
-    ```
-25. Present next steps via smart AskUserQuestion
-
-**Post-Implementation Options** (offer ALL applicable via smart AskUserQuestion):
-- "Run tests to verify (Recommended)" - always, with specific test command and file count
-- "🔍 Run logic audit on N modified files" - always, 5 analyzers check edge cases, race conditions, type bugs
-- "📝 Run code review on N files" - if 5+ source files changed, comprehensive security/performance/maintainability review
-- "📚 Sync docs for changed APIs" - if API routes, exports, or interfaces changed
-- "🔬 Run multi-expert review" - if 10+ files or 300+ lines changed
-- "📋 Create ADR for [decision]" - if architecture decision was made
-- "Commit: '[type]: [summary]'" - with specific commit message suggestion
-- "Continue to next story" - with story ID and epic progress
-- "Pause here" - with summary of what's saved/uncommitted
+11. Offer via AskUserQuestion: tests, AC verification (VERIFY mode), logic audit, code review (5+ files), docs sync (API changes), multi-expert (10+ files), ADR (if arch decision)
+12. STRICT/VERIFY gate check: hide commit until gates pass (tests + AC at require/block level)
+13. Update status.json (including ac_status), release story claim: `node .agileflow/scripts/lib/story-claiming.js release <id>`
 
 ---
 
-### KEY FILES TO REMEMBER
+### KEY FILES
 
 | File | Purpose |
 |------|---------|
@@ -526,332 +363,94 @@ When context is cleared (e.g., after plan approval), the hook:
 
 ---
 
-### SUGGESTIONS PRIORITY (for task selection)
+### STORY CLAIMING
 
-**BEFORE suggesting stories, check for claims:**
+**Before suggesting stories:**
 ```bash
 node .agileflow/scripts/lib/story-claiming.js others
 ```
 
-**Story badges in suggestions:**
-| Badge | Meaning | Include in suggestions? |
-|-------|---------|------------------------|
-| ⭐ | Ready, available | YES - prioritize these |
-| 🔒 | Claimed by other session | NO - exclude or show disabled |
-| ✓ | Claimed by this session | YES - show as "continue" |
-
-**Priority order (for unclaimed stories):**
-1. ⭐ READY stories (all AC complete, no blockers)
-2. Blocked with simple unblock
-3. Near-complete epics (80%+ done)
-4. README TODOs
-5. New features
-
-**Example with claim filtering:**
-```json
-[
-  {"label": "US-0042: Auth API ⭐ (Recommended)", "description": "Ready to implement"},
-  {"label": "US-0038: User Profile ✓", "description": "Continue your work"},
-  {"label": "US-0041: Settings 🔒", "description": "Claimed by Session 2 - skip"},
-  {"label": "Other", "description": "Tell me what you want"}
-]
-```
-
-Present top 3-5 via AskUserQuestion, always include "Other" option.
-
----
-
-### STATE NARRATION (emit in responses)
-
-| Marker | When |
-|--------|------|
-| 📍 | Working on story/phase |
-| 🔀 | Spawning parallel experts |
-| 🔄 | Loop iterations |
-| ⚠️ | Errors |
-| ✅ | Completions |
-| 🔍 | Running logic audit |
-
----
+| Badge | Meaning | Action |
+|-------|---------|--------|
+| ⭐ | Ready, available | Prioritize |
+| 🔒 | Claimed by other session | Exclude or show disabled |
+| ✓ | Claimed by this session | Continue working |
 
-### LOGIC AUDIT INTEGRATION
-
-**ALWAYS suggest logic audit after ANY implementation** - whether from a plan, direct coding, or expert delegation. This is a standard post-implementation step, not optional.
-
-**Smart AskUserQuestion after implementation:**
-```xml
-<invoke name="AskUserQuestion">
-<parameter name="questions">[{
-  "question": "Implementation complete (3 files changed, 85 lines added). What's next?",
-  "header": "Next step",
-  "multiSelect": false,
-  "options": [
-    {"label": "Run npm test in packages/cli/ (Recommended)", "description": "3 files changed in scripts/ - verify before committing"},
-    {"label": "🔍 Run logic audit on 3 modified files", "description": "5 analyzers check for edge cases, race conditions, type bugs - catches issues tests miss"},
-    {"label": "Commit: 'feat: add session tracking'", "description": "Skip verification - only if changes are trivial"},
-    {"label": "Pause here", "description": "Changes saved, not committed"}
-  ]
-}]</parameter>
-</invoke>
-```
+**Priority order** (unclaimed): READY stories → blocked with simple unblock → near-complete epics (80%+) → README TODOs → new features
 
-**After tests pass, suggest logic audit again if not yet run:**
-```xml
-<invoke name="AskUserQuestion">
-<parameter name="questions">[{
-  "question": "All 4373 tests pass. Ready to finalize?",
-  "header": "Next step",
-  "multiSelect": false,
-  "options": [
-    {"label": "🔍 Run logic audit on 3 modified files (Recommended)", "description": "5 analyzers catch edge cases tests miss - quick check before commit"},
-    {"label": "Commit: 'feat: add session tracking'", "description": "All tests pass, skip logic audit"},
-    {"label": "Continue to US-0044", "description": "EP-0018 is 85% done - 2 stories left"},
-    {"label": "Pause here", "description": "Tests pass, changes not committed"}
-  ]
-}]</parameter>
-</invoke>
+```bash
+node .agileflow/scripts/lib/story-claiming.js claim US-0042   # After selection
+node .agileflow/scripts/lib/story-claiming.js release US-0042  # After completion
 ```
 
-**When user selects "🔍 Run logic audit":**
-1. Identify files that were modified during implementation
-2. Run: `/agileflow:audit:logic <modified-files> DEPTH=quick`
-3. Review findings with user
-4. Offer to fix any P0/P1 issues immediately
-5. Then present next steps again with smart AskUserQuestion
-
 ---
 
-### SMART ASKUSERQUESTION EXAMPLES
-
-After implementation:
-- "Run `npm test` in packages/cli/ (Recommended)" + "3 files changed in scripts/ - verify before committing"
-- "🔍 Run logic audit on 3 modified files" + "5 analyzers check edge cases, race conditions, type bugs"
-- "Pause here" + "Changes saved, not committed"
-
-After tests pass (logic audit NOT yet run):
-- "🔍 Run logic audit on 3 modified files (Recommended)" + "Quick check catches what tests miss - edge cases, race conditions"
-- "Commit: 'fix: resolve tmux socket path'" + "All 4373 tests pass, skip audit"
-- "Continue to US-0044" + "EP-0018 is 85% done"
+### LOGIC AUDIT
 
-After tests pass (logic audit already done):
-- "Commit: 'fix: resolve tmux socket path' (Recommended)" + "All tests pass, logic audit clean"
-- "Review diff before committing" + "14 files touched across 3 directories"
+**ALWAYS suggest after ANY implementation** (plan, direct coding, or expert delegation).
 
-After error:
-- "Try alternative: use execFileSync instead (Recommended)" + "Current approach has shell injection risk"
-- "Run /agileflow:research:ask" + "Same error occurred twice"
+After tests pass (audit not yet run), suggest as (Recommended):
+```json
+[
+  {"label": "🔍 Run logic audit on 3 modified files (Recommended)", "description": "5 analyzers catch edge cases tests miss"},
+  {"label": "Commit: 'feat: add session tracking'", "description": "All tests pass, skip audit"},
+  {"label": "Continue to US-0044", "description": "EP-0018 is 85% done"}
+]
+```
 
----
+When selected: run `/agileflow:code:logic <modified-files> DEPTH=quick`, review findings, offer to fix P0/P1.
 
-### REMEMBER AFTER COMPACTION
-
-- `/agileflow:babysit` IS ACTIVE - follow these rules
-- **OBTAIN-CONTEXT**: NEVER pipe `obtain-context.js` through `| head`/`| tail`/truncation - run bare, it manages its own output limits
-- **CONTEXTUAL ROUTER**: Read smart-detect.json for recommendations, act on immediate items
-- **SMART AskUserQuestion**: Always specific, always contextual, always with (Recommended) option
-- **BIAS TOWARD IMPLEMENTATION**: Read 3-5 files max then start coding
-- Plan mode FIRST for non-trivial tasks
-- Delegate complex work to experts
-- If stuck 2+ times → research prompt
-- Use state narration markers (📍🔀🔄⚠️✅) for visibility
-- **LOGIC AUDIT - ALWAYS SUGGEST**: After ANY implementation (plan or direct), ALWAYS include "🔍 Run logic audit" as an option. After tests pass but before commit, make it (Recommended).
-- **PROACTIVE ADVANCED FEATURES**: Don't wait for smart-detect:
-  - Impact analysis BEFORE plan mode (3+ existing files touched)
-  - Council for architectural decisions
-  - Code review agent for 5+ files post-impl
-  - Multi-expert review for 10+ files or 300+ lines
-  - ADR for any architecture decision made
-  - Research PROACTIVELY for unfamiliar patterns (not just when stuck)
-  - Docs sync when API/interface files change
-- **PLAN FILE CONTEXT - AUTOMATED:**
-  `babysit-clear-restore.js` SessionStart hook auto-injects babysit rules on context clear.
-  No manual plan file editing needed - just call ExitPlanMode normally.
-- **STORY CLAIMING - CRITICAL:**
-  1. BEFORE suggesting: `node .agileflow/scripts/lib/story-claiming.js others` → exclude 🔒
-  2. AFTER user selects: `node .agileflow/scripts/lib/story-claiming.js claim <id>`
-  3. WHEN done: `node .agileflow/scripts/lib/story-claiming.js release <id>`
 ---
 
-## 🛑 FINAL ACTION REQUIRED - DO NOT SKIP
-
-**BEFORE SENDING YOUR RESPONSE, YOU MUST:**
-
-Call the `AskUserQuestion` tool with relevant options for the user's next steps.
-
-**DO NOT** end with text like "What would you like to do?" or "Let me know!"
-**DO** call the actual AskUserQuestion tool.
-
-If you fail to do this, you have broken the /agileflow:babysit contract.
+**YOUR RESPONSE MUST END WITH `AskUserQuestion` TOOL CALL.**
 
 <!-- COMPACT_SUMMARY_END -->
 
-<!-- === TIER 3: REFERENCE - DETAILED SECTIONS === -->
-
 ---
 
 <!-- SECTION: loop-mode -->
 ## LOOP MODE (Autonomous Execution)
 
-Loop mode is **auto-enabled** when:
-- Epic has 3+ ready stories
-- Test framework is detected (`npm test` exists)
-- Stories have acceptance criteria
-
-To force single-story mode, say "just work on one story" or specify `MODE=once`.
-
-**Example (auto-detected):**
-```
-/agileflow:babysit EPIC=EP-0042
-→ 🧠 Auto-enabled: Loop Mode (5 ready stories)
-```
-
-**Example (explicit override):**
-```
-/agileflow:babysit EPIC=EP-0042 MODE=once
-→ Single story mode (user override)
-```
-
-### How Loop Mode Works
-
-1. **Initialization**: Writes loop config to `session-state.json`
-2. **First Story**: Picks first "ready" story, marks it "in_progress"
-3. **Work**: You implement the story normally
-4. **Stop Hook**: When you stop, `ralph-loop.js` runs:
-   - Runs `npm test` (or configured test command)
-   - If tests pass → marks story complete, loads next story
-   - If tests fail → shows failures, you continue fixing
-5. **Loop**: Continues until epic complete or MAX iterations reached
-
-### Parameters
+Auto-enabled when: epic has 3+ ready stories, test framework detected, stories have AC. Force single-story with `MODE=once`.
 
-See the [Parameters](#parameters) table above for the full reference. All loop mode parameters are documented there.
-
-**Note:** Most parameters are auto-detected by the Contextual Feature Router. Only specify if you need to override the detected values.
+### How It Works
 
-### To Start Loop Mode
+1. **Init**: Writes loop config to `session-state.json`
+2. **Pick**: First "ready" story → marks "in_progress"
+3. **Work**: Implement normally
+4. **Stop Hook**: `ralph-loop.js` runs `npm test` → pass = complete + load next, fail = continue fixing
+5. **Loop**: Until epic complete or MAX iterations
 
-After running the context script, if loop mode is auto-detected (or explicitly specified):
+### Starting Loop Mode
 
 ```bash
-# Initialize the loop
 node scripts/ralph-loop.js --init --epic=EP-0042 --max=20
-
-# With Visual Mode for UI development
-node scripts/ralph-loop.js --init --epic=EP-0042 --max=20 --visual
-
-# With Coverage Mode - iterate until 80% coverage
-node scripts/ralph-loop.js --init --epic=EP-0042 --max=20 --coverage=80
-```
-
-Or manually write to session-state.json:
-
-```json
-{
-  "ralph_loop": {
-    "enabled": true,
-    "epic": "EP-0042",
-    "current_story": "US-0015",
-    "iteration": 0,
-    "max_iterations": 20,
-    "visual_mode": false,
-    "screenshots_verified": false,
-    "coverage_mode": false,
-    "coverage_threshold": 80,
-    "coverage_baseline": 0,
-    "coverage_current": 0,
-    "coverage_verified": false
-  }
-}
-```
-
-### Discretion Conditions (Metadata Config)
-
-Conditions are configured in `docs/00-meta/agileflow-metadata.json` (not a CLI parameter):
-
-```json
-{
-  "ralph_loop": {
-    "conditions": [
-      "**all tests passing**",
-      "**no linting errors**",
-      "**no type errors**"
-    ]
-  }
-}
-```
-
-**Available conditions:**
-- `**all tests passing**` - Tests must pass
-- `**coverage above N%**` - Coverage threshold (e.g., `**coverage above 80%**`)
-- `**no linting errors**` - `npm run lint` must pass
-- `**no type errors**` - `npx tsc --noEmit` must pass
-- `**build succeeds**` - `npm run build` must pass
-- `**all screenshots verified**` - Screenshots need `verified-` prefix
-- `**all acceptance criteria verified**` - AC marked complete in status.json
-
-### Coverage Mode
-
-When `COVERAGE=<percent>` is specified, the loop adds test coverage verification:
-
-```
-/agileflow:babysit EPIC=EP-0042 MODE=loop COVERAGE=80
+node scripts/ralph-loop.js --init --epic=EP-0042 --max=20 --visual     # With screenshots
+node scripts/ralph-loop.js --init --epic=EP-0042 --max=20 --coverage=80 # With coverage
 ```
 
-**Coverage Mode behavior:**
-1. After tests pass, runs coverage check command
-2. Parses `coverage/coverage-summary.json` (Jest/NYC format)
-3. Compares line coverage to threshold
-4. Requires minimum 2 iterations before completion
-5. Story completes only when coverage ≥ threshold AND confirmed
-
-### Visual Mode
-
-When `VISUAL=true` is specified, the loop adds screenshot verification:
-
-```
-/agileflow:babysit EPIC=EP-0042 MODE=loop VISUAL=true
-```
+### Discretion Conditions
 
-**Visual Mode behavior:**
-1. After tests pass, runs `screenshot-verifier.js`
-2. Checks all screenshots in `screenshots/` have `verified-` prefix
-3. Requires minimum 2 iterations before completion
-4. Prevents premature completion for UI work
+Configured in `docs/00-meta/agileflow-metadata.json`:
+- `**all tests passing**`, `**coverage above N%**`, `**no linting errors**`, `**no type errors**`, `**build succeeds**`, `**all screenshots verified**`, `**all acceptance criteria verified**`
 
-### Visual Mode Auto-Detection
+### Coverage Mode (`COVERAGE=<percent>`)
 
-**Check the context output** from `obtain-context.js` for Visual E2E status.
+After tests pass, checks `coverage/coverage-summary.json`. Story completes only when coverage >= threshold AND confirmed. Minimum 2 iterations.
 
-**If "📸 VISUAL E2E TESTING: ENABLED" appears**, proactively suggest VISUAL mode for UI work.
+### Visual Mode (`VISUAL=true`)
 
-**Detection criteria for VISUAL=true:**
-| Indicator | Suggest VISUAL? |
-|-----------|-----------------|
-| Epic mentions "UI", "component", "styling" | Yes |
-| Stories have owner: AG-UI | Yes |
-| Files involve src/components/, *.css, *.tsx | Yes |
-| Work is API/backend only | No |
-| Work is CLI/scripts only | No |
+After tests pass, checks screenshots have `verified-` prefix. Auto-suggest for AG-UI stories, epic mentions "UI"/"component", or files in `src/components/`.
 
-### Loop Control Commands
+### Loop Control
 
 ```bash
-node scripts/ralph-loop.js --status   # Check loop status
-node scripts/ralph-loop.js --stop     # Stop the loop
-node scripts/ralph-loop.js --reset    # Reset loop state
+node scripts/ralph-loop.js --status   # Check status
+node scripts/ralph-loop.js --stop     # Stop loop
+node scripts/ralph-loop.js --reset    # Reset state
 ```
 
-### When to Use Loop Mode
-
-**Good for:**
-- Working through a well-defined epic with clear stories
-- Test-driven development (tests define "done")
-- Batch processing multiple stories overnight
-
-**Not good for:**
-- Exploratory work without clear acceptance criteria
-- Stories requiring human review before proceeding
-- Complex multi-domain work needing coordination
+**Good for**: Well-defined epics, TDD, batch processing. **Not for**: Exploratory work, human review needed, complex multi-domain.
 <!-- END_SECTION -->
 
 ---
@@ -859,105 +458,47 @@ node scripts/ralph-loop.js --reset    # Reset loop state
 <!-- SECTION: delegation -->
 ## DELEGATION FRAMEWORK (DETAILED)
 
-### Decision Tree
-
-**Ask yourself: What's the scope?**
+### Decision Matrix
 
 | Scope | Action | Example |
 |-------|--------|---------|
-| **Simple** | Do yourself | Fix typo, add field, small tweak |
-| **Complex, 1 domain** | Spawn expert | "Add user table" → Database Expert |
-| **Complex, 2+ domains** | Spawn orchestrator | "Add profile with API and UI" → Orchestrator |
-| **Analysis/Review** | Multi-expert | "Is this secure?" → Multiple experts analyze |
-
-### When to Spawn Experts
-
-**SPAWN when task:**
-- Spans multiple files
-- Requires deep domain knowledge
-- Would benefit from specialist focus
-- Involves significant implementation
-
-**DO YOURSELF when task:**
-- Is a quick fix (< 5 minutes)
-- Involves single obvious change
-- Is coordination/status work
-- Takes less effort than delegating
+| **Simple** | Do yourself | Fix typo, add field |
+| **Complex, 1 domain** | Spawn expert | "Add user table" → `agileflow-database` |
+| **Complex, 2+ domains** | Spawn orchestrator | "Profile with API + UI" → `agileflow-orchestrator` |
+| **Analysis/Review** | Multi-expert | "Is this secure?" → multiple experts |
 
 ### Domain Experts
 
-| Domain | Expert | Keywords | When to Use |
-|--------|--------|----------|-------------|
-| **Database** | `agileflow-database` | schema, migration, SQL, table, model, query | Schema design, migrations, queries |
-| **API** | `agileflow-api` | endpoint, REST, route, controller, GraphQL | Backend endpoints, business logic |
-| **UI** | `agileflow-ui` | component, frontend, style, CSS, React | Frontend components, styling |
-| **Testing** | `agileflow-testing` | test, spec, coverage, mock, fixture | Test implementation, coverage |
-| **Security** | `agileflow-security` | auth, JWT, OAuth, XSS, vulnerability | Security implementation, audits |
-| **Performance** | `agileflow-performance` | optimize, cache, latency, profiling | Performance optimization |
-| **CI/CD** | `agileflow-ci` | workflow, pipeline, GitHub Actions, build | CI/CD configuration |
-| **DevOps** | `agileflow-devops` | deploy, Docker, Kubernetes, infrastructure | Deployment, infrastructure |
-| **Documentation** | `agileflow-documentation` | docs, README, JSDoc, API docs | Documentation writing |
+| Domain | Expert | When to Use |
+|--------|--------|-------------|
+| Database | `agileflow-database` | Schema, migrations, queries |
+| API | `agileflow-api` | Endpoints, business logic |
+| UI | `agileflow-ui` | Components, styling |
+| Testing | `agileflow-testing` | Tests, coverage |
+| Security | `agileflow-security` | Auth, vulnerabilities |
+| Performance | `agileflow-performance` | Optimization, caching |
+| CI/CD | `agileflow-ci` | Pipelines, workflows |
+| DevOps | `agileflow-devops` | Deployment, infrastructure |
+| Docs | `agileflow-documentation` | Documentation |
 
 ### Coordination Experts
 
-| Expert | When to Use |
-|--------|-------------|
-| `agileflow-orchestrator` | Multi-domain tasks (API + UI, Database + API + Tests) |
-| `agileflow-epic-planner` | Breaking down features into stories |
-| `agileflow-research` | Technical research, best practices |
-| `agileflow-adr-writer` | Architecture decisions |
+`agileflow-orchestrator` (multi-domain), `agileflow-epic-planner` (story breakdown), `agileflow-research` (technical research), `agileflow-adr-writer` (architecture decisions)
 
 ### Full Expert List
 
 <!-- {{AGENT_LIST}} -->
 
-### Single Expert Spawning
+### Spawning Examples
 
+**Single expert:**
 ```
-Task(
-  description: "Add sessions table",
-  prompt: "Create a sessions table for user login tracking. Include: id, user_id, token, ip_address, user_agent, created_at, expires_at. Follow existing schema patterns.",
-  subagent_type: "agileflow-database"
-)
+Task(description: "Add sessions table", prompt: "Create sessions table with id, user_id, token, ip_address, user_agent, created_at, expires_at. Follow existing patterns.", subagent_type: "agileflow-database")
 ```
 
-### Orchestrator Spawning (Multi-Domain)
-
+**Orchestrator (multi-domain):**
 ```
-Task(
-  description: "Implement user profile feature",
-  prompt: "Implement user profile with: 1) API endpoint GET/PUT /api/profile, 2) React ProfilePage component. Coordinate parallel experts.",
-  subagent_type: "agileflow-orchestrator"
-)
-```
-
-The orchestrator will:
-1. Spawn API + UI experts in parallel
-2. Collect results
-3. Synthesize and report conflicts
-4. Return unified outcome
-
-### Parallel Experts (Manual Coordination)
-
-```
-# Spawn in parallel
-Task(
-  description: "Create profile API",
-  prompt: "Implement GET/PUT /api/profile endpoint",
-  subagent_type: "agileflow-api",
-  run_in_background: true
-)
-
-Task(
-  description: "Create profile UI",
-  prompt: "Create ProfilePage component with form",
-  subagent_type: "agileflow-ui",
-  run_in_background: true
-)
-
-# Collect results
-TaskOutput(task_id: "<api_id>", block: true)
-TaskOutput(task_id: "<ui_id>", block: true)
+Task(description: "User profile feature", prompt: "Implement: 1) GET/PUT /api/profile, 2) ProfilePage component. Coordinate parallel experts.", subagent_type: "agileflow-orchestrator")
 ```
 
 ### Dependency Rules
@@ -965,32 +506,10 @@ TaskOutput(task_id: "<ui_id>", block: true)
 | If... | Then... |
 |-------|---------|
 | B needs A's output | Run A first, wait, then B |
-| A and B are independent | Run in parallel |
+| A and B independent | Run in parallel |
 | Unsure | Run sequentially (safer) |
 
-**Common dependencies:**
-- Database schema → then API (API uses schema)
-- API endpoint → then UI (UI calls API)
-- Implementation → then tests (tests need code)
-
-### Retry with Backoff
-
-When an expert task fails:
-
-```
-Attempt 1: Immediate retry
-Attempt 2: Wait 5 seconds, then retry
-Attempt 3: Wait 15 seconds, then retry (final)
-```
-
-**When to retry:**
-- Expert returns error or timeout
-- TaskOutput shows failure state
-
-**When NOT to retry:**
-- User explicitly asked to stop
-- Expert completed but result was wrong
-- Multiple experts all failed same way
+Common: Database → API → UI → Tests
 <!-- END_SECTION -->
 
 ---
@@ -998,126 +517,31 @@ Attempt 3: Wait 15 seconds, then retry (final)
 <!-- SECTION: plan-mode -->
 ## PLAN MODE (DETAILED)
 
-**Plan mode is your primary tool for non-trivial tasks.** It allows you to explore the codebase, understand patterns, and design an approach BEFORE committing to implementation.
+### When to Use
 
-### When to Use Plan Mode
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│                    PLAN MODE DECISION                        │
-├─────────────────────────────────────────────────────────────┤
-│                                                              │
-│  What's the task?                                            │
-│       │                                                      │
-│       ├─► Trivial (typo, obvious one-liner)                 │
-│       │       └─► Skip plan mode, just do it                │
-│       │                                                      │
-│       ├─► User gave detailed instructions with files        │
-│       │       └─► Skip plan mode, follow instructions       │
-│       │                                                      │
-│       └─► Everything else                                   │
-│               └─► USE PLAN MODE                             │
-│                   EnterPlanMode → Explore → Design → Exit   │
-│                                                              │
-└─────────────────────────────────────────────────────────────┘
-```
-
-### Why Plan Mode Matters
-
-| Without Plan Mode | With Plan Mode |
-|-------------------|----------------|
-| Guess at patterns | Understand existing conventions |
-| Miss edge cases | Discover edge cases early |
-| Redo work when wrong | Get alignment before coding |
-| User surprises | User approves approach |
-
-### Plan Mode Flow (with Context Preservation)
-
-1. **Enter** - Call `EnterPlanMode` tool
-2. **Explore** - Use Glob, Grep, Read to understand:
-   - How similar features are implemented
-   - What patterns exist in the codebase
-   - What files will need changes
-   - What dependencies exist
-3. **Design** - Write plan to the plan file:
-   - Implementation steps
-   - Files to modify/create
-   - Key decisions and trade-offs
-   - Testing approach
-4. **Approve** - Call `ExitPlanMode` for user review
-5. **Execute** - Implement (babysit rules auto-restored after context clear by `babysit-clear-restore.js` hook)
-
-### Plan Mode Examples
-
-**Example 1: Add New Feature**
-```
-User: "Add a logout button to the header"
-
-→ EnterPlanMode
-→ Read header component to understand structure
-→ Grep for existing auth patterns
-→ Check how other buttons are styled
-→ Write plan: "Add logout button next to profile, use existing Button component, call auth.logout()"
-→ ExitPlanMode
-→ User approves
-→ Implement
-```
-
-**Example 2: Fix Bug**
-```
-User: "Users are seeing stale data after update"
-
-→ EnterPlanMode
-→ Grep for caching patterns
-→ Read data fetching logic
-→ Identify cache invalidation issue
-→ Write plan: "Add cache invalidation after mutation in useUpdateProfile hook"
-→ ExitPlanMode
-→ User approves
-→ Implement
-```
-
-**Example 3: Complex Multi-Domain**
-```
-User: "Add user preferences with API and UI"
+| Task Type | Action |
+|-----------|--------|
+| Trivial (typo, one-liner) | Skip, just do it |
+| User gave detailed instructions | Skip, follow them |
+| Everything else | **USE PLAN MODE** |
 
-→ EnterPlanMode
-→ Explore API patterns, UI patterns, database schema
-→ Write plan with: database changes, API endpoints, UI components
-→ ExitPlanMode
-→ User approves
-→ Spawn orchestrator to coordinate experts
-```
+### Flow
 
-### Plan Mode Anti-Patterns
+1. **Enter** - Call `EnterPlanMode`
+2. **Explore** - Glob, Grep, Read (3-5 files: patterns, dependencies, conventions)
+3. **Design** - Write plan: steps, files, decisions, testing approach
+4. **Approve** - Call `ExitPlanMode` (babysit rules auto-restored after context clear)
+5. **Execute** - Implement immediately after approval
 
-❌ **DON'T:** Skip plan mode and start coding immediately
-```
-User: "Add email notifications"
-[immediately starts writing code without exploring]
-```
+### Example
 
-✅ **DO:** Always plan first for non-trivial tasks
 ```
 User: "Add email notifications"
 → EnterPlanMode
-→ Explore notification patterns, email service setup
-→ Design approach
-→ ExitPlanMode
-→ Implement
-```
-
-❌ **DON'T:** Use plan mode for trivial tasks
-```
-User: "Fix the typo in README"
-→ EnterPlanMode [unnecessary overhead]
-```
-
-✅ **DO:** Just fix trivial tasks directly
-```
-User: "Fix the typo in README"
-[fixes typo directly]
-"Fixed. What's next?"
+→ Explore notification patterns, email service
+→ Write plan: service setup, template system, trigger points
+→ ExitPlanMode → User approves
+→ Implement (spawn experts if multi-domain)
 ```
 <!-- END_SECTION -->
 
@@ -1128,97 +552,50 @@ User: "Fix the typo in README"
 
 ### When to Use Task Registry
 
-| Scenario | Use Task Registry? |
-|----------|-------------------|
-| Simple single-expert task | Optional |
+| Scenario | Use? |
+|----------|------|
+| Simple single-expert | Optional |
 | Multi-expert coordination | Recommended |
 | Long-running work (>30 min) | Recommended |
 | Builder/Validator pairing | Required |
 
-### Task Registry Workflow
+**Check if enabled:** `docs/00-meta/agileflow-metadata.json` → `features.taskRegistry.enabled`
 
-**1. Check for Running Duplicates:**
-```bash
-node -e "
-const{getTaskRegistry}=require('./.agileflow/scripts/lib/task-registry');
-const running=getTaskRegistry().getAll({state:'running',subagent_type:'agileflow-api'});
-running.forEach(t=>console.log('⚠️',t.id,':',t.description));
-"
-```
+### Workflow
 
-**2. Register Task:**
 ```bash
-node -e "
-const{getTaskRegistry}=require('./.agileflow/scripts/lib/task-registry');
-const{linkTaskToStory}=require('./.agileflow/scripts/lib/status-task-bridge');
-const r=getTaskRegistry();
-const result=r.create({description:'DESCRIPTION',subagent_type:'AGENT',story_id:'STORY_ID'});
-if(result.success){linkTaskToStory('STORY_ID',result.task.id);console.log('✅',result.task.id)}
-"
-```
-
-**3. Spawn Expert (normal Task call):**
-```
-Task(
-  description: "...",
-  prompt: "...",
-  subagent_type: "agileflow-api",
-  run_in_background: true
-)
+# Check for running duplicates before spawning
+node -e "const{getTaskRegistry}=require('./.agileflow/scripts/lib/task-registry');
+const running=getTaskRegistry().getAll({state:'running'});
+if(running.length)console.log('⚠️ Running:',running.map(t=>t.id).join(','));
+else console.log('✅ No running tasks')"
 ```
 
-**4. Update Registry with Claude Task ID:**
-After Task() returns, store mapping for later TaskOutput:
 ```bash
+# Register task
 node -e "const{getTaskRegistry}=require('./.agileflow/scripts/lib/task-registry');
-getTaskRegistry().update('REGISTRY_ID',{metadata:{claude_task_id:'CLAUDE_ID'}})"
+const{linkTaskToStory}=require('./.agileflow/scripts/lib/status-task-bridge');
+const r=getTaskRegistry();
+const result=r.create({description:'DESC',subagent_type:'AGENT',story_id:'STORY_ID'});
+if(result.success){linkTaskToStory('STORY_ID',result.task.id);console.log('✅',result.task.id)}"
 ```
 
-**5. On Completion:**
-```bash
-node -e "
-const{getTaskRegistry}=require('./.agileflow/scripts/lib/task-registry');
-const r=getTaskRegistry();r.complete('TASK_ID',{result:'success'});
-// Check for unblocked validators
-const validators=r.getReadyTasks().filter(t=>t.metadata?.is_validator);
-validators.forEach(v=>console.log('🔔 Validator ready:',v.id));
-"
-```
+After expert completes, call `r.complete('TASK_ID')` and check for unblocked validators.
 
-### Builder/Validator Auto-Chaining
+### Builder/Validator Pairing
 
 Register both at start - validator blocked by builder:
 
 ```bash
-# Builder
-BUILDER=$(node -e "
-const{getTaskRegistry}=require('./.agileflow/scripts/lib/task-registry');
+BUILDER=$(node -e "const{getTaskRegistry}=require('./.agileflow/scripts/lib/task-registry');
 const r=getTaskRegistry().create({description:'Implement API',subagent_type:'agileflow-api',story_id:'US-0042'});
-console.log(r.task.id)
-")
-
-# Validator (blocked)
-node -e "
-const{getTaskRegistry}=require('./.agileflow/scripts/lib/task-registry');
-getTaskRegistry().create({description:'Validate API',subagent_type:'agileflow-api-validator',story_id:'US-0042',blockedBy:['$BUILDER'],metadata:{is_validator:true}})
-"
+console.log(r.task.id)")
+
+node -e "const{getTaskRegistry}=require('./.agileflow/scripts/lib/task-registry');
+getTaskRegistry().create({description:'Validate API',subagent_type:'agileflow-api-validator',story_id:'US-0042',blockedBy:['$BUILDER'],metadata:{is_validator:true}})"
 ```
 
 When builder completes, validator auto-unblocks.
-
-### Enable Task Registry
-
-Add to `docs/00-meta/agileflow-metadata.json`:
-
-```json
-{
-  "features": {
-    "taskRegistry": {
-      "enabled": true
-    }
-  }
-}
-```
 <!-- END_SECTION -->
 
 ---
@@ -1226,218 +603,20 @@ Add to `docs/00-meta/agileflow-metadata.json`:
 <!-- SECTION: stuck -->
 ## STUCK DETECTION (DETAILED)
 
-When you encounter repeated errors or problems you can't solve, **proactively suggest external research** instead of continuing to try and fail.
-
-### Error Complexity Classification
-
-**Immediate research suggestion** (don't retry more than once):
-- External API/library version mismatches
-- "Cannot find module" for unfamiliar packages
-- OAuth/authentication flow errors
-- Build/bundler configuration errors (webpack, vite, esbuild)
-- Errors from libraries you don't deeply understand
-- Cryptic errors with no clear solution
-
-**Research after 2 attempts** (try twice, then suggest):
-- Type errors persisting after fix attempts
-- Runtime errors with unclear stack traces
-- Test failures that don't match expectations
-- Integration errors between components
-- Database/ORM errors you haven't seen before
-
-**Keep trying** (simple errors, no research needed):
-- Typos, syntax errors
-- Missing imports for known modules
-- Obvious null checks
-- Simple logic errors with clear stack traces
-
-### When Stuck Is Detected
-
-1. **Acknowledge the situation clearly**:
-
-```
-I've tried [N] approaches but we're still hitting [error].
-
-This seems like a case where external research would help -
-the issue involves [library/API/pattern] that needs more
-context than I currently have.
-```
-
-2. **Gather context automatically**:
-   - Read the relevant files being modified
-   - Capture the full error message and stack trace
-   - List what approaches were already tried
-   - Note the exact versions of libraries involved
-
-3. **Generate comprehensive research prompt**:
-
-Run `/agileflow:research:ask` with detailed context:
-
-```
-TOPIC="[Specific error/problem description]"
-ERROR="[Exact error message]"
-```
-
-The research prompt MUST include:
-- **50+ lines of actual code** from your codebase
-- **Exact error messages** verbatim
-- **What was already tried** with results
-- **3+ specific questions** about the problem
-
-4. **Present to user**:
+### Error Classification
 
-```
-I've generated a detailed research prompt for ChatGPT/Claude web/Perplexity.
-
-It includes:
-- Your current code implementation
-- The exact error we're hitting
-- What I've already tried
-- Specific questions to answer
+**Immediate research (don't retry):** External API mismatches, "Cannot find module" for unfamiliar packages, OAuth errors, build/bundler config, cryptic library errors.
 
-Copy the prompt, paste it into your preferred AI tool, and when you
-get the answer, paste it back here. I'll save it to your research
-folder and continue implementing.
-```
+**Research after 2 attempts:** Persistent type errors, unclear runtime errors, unexpected test failures, integration errors, unfamiliar DB/ORM errors.
 
-### Anti-Pattern: Lazy Research Prompts
+**Keep trying (no research):** Typos, syntax errors, missing imports, obvious null checks, clear logic errors.
 
-**NEVER generate basic prompts like:**
-
-```
-"How do I fix OAuth in Next.js?"
-```
-
-**ALWAYS generate detailed prompts with:**
-- Actual code from the codebase (50+ lines)
-- Exact error messages (verbatim, in code blocks)
-- What was already tried (with specific results)
-- Specific questions (not vague)
-
-**Example good prompt:**
-```markdown
-# OAuth Implementation Error in Next.js 14
-
-## Current Setup
-- Next.js 14.0.4 with App Router
-- next-auth 5.0.0-beta.4
-- Google OAuth provider
-
-## Current Code
-[50+ lines of actual implementation from src/app/api/auth/...]
-
-## Error
-\`\`\`
-Error: [auth] unauthorized_client
-  at AuthHandler (node_modules/next-auth/src/lib/...)
-\`\`\`
-
-## What I've Tried
-1. Verified client ID/secret - credentials are correct
-2. Checked redirect URI in Google Console - matches localhost:3000
-3. Cleared cookies and tried incognito - same error
-
-## Specific Questions
-1. Why does next-auth throw unauthorized_client when credentials are correct?
-2. Is there a known issue with next-auth 5.0.0-beta.4 and Google OAuth?
-3. What additional configuration is needed for App Router?
-```
+### When Stuck
 
-### Integration with Research Commands
-
-When stuck detection triggers:
-1. Use `/agileflow:research:ask` to generate the detailed prompt
-2. After user returns with results, use `/agileflow:research:import` to save
-3. Link the research to the current story if applicable
-4. Continue implementing with the new knowledge
-<!-- END_SECTION -->
-
----
-
-<!-- SECTION: tools -->
-## TOOL USAGE (DETAILED)
-
-### AskUserQuestion
-
-**USE for:**
-- Initial task selection
-- Choosing between approaches
-- Architectural decisions
-- End of every response (to keep user engaged)
-- After completing a task (offer next steps)
-
-**DON'T use for (avoid being annoying):**
-- Routine operations ("Can I read this file?" → just read it)
-- Spawning experts ("Should I spawn the API expert?" → just spawn it)
-- Obvious next steps that don't need confirmation
-- Asking the same question repeatedly
-- Interrupting workflow when you already know what to do
-- Asking permission for every small action
-
-**Balance:**
-Use AskUserQuestion at natural pause points (task completion, decision needed) but NOT for every micro-step. If you know the next action, do it. Ask only when user input genuinely helps.
-
-**Format:**
-```xml
-<invoke name="AskUserQuestion">
-<parameter name="questions">[{
-  "question": "What would you like to work on?",
-  "header": "Choose task",
-  "multiSelect": false,
-  "options": [
-    {"label": "US-0042: User API (READY) ⭐", "description": "Ready to implement"},
-    {"label": "Create new story", "description": "Start something new"},
-    {"label": "Other", "description": "Tell me what you want"}
-  ]
-}]</parameter>
-</invoke>
-```
-
-### Task Tools (TaskCreate, TaskUpdate, TaskList, TaskGet)
-
-**USE:** Track all workflow steps. Create tasks with TaskCreate, update status with TaskUpdate.
-
-```xml
-<!-- Create a task -->
-<invoke name="TaskCreate">
-<parameter name="subject">Run context script</parameter>
-<parameter name="description">Gather project context using obtain-context.js</parameter>
-<parameter name="activeForm">Running context script</parameter>
-</invoke>
-
-<!-- Mark task in progress -->
-<invoke name="TaskUpdate">
-<parameter name="taskId">1</parameter>
-<parameter name="status">in_progress</parameter>
-</invoke>
-
-<!-- Mark task completed -->
-<invoke name="TaskUpdate">
-<parameter name="taskId">1</parameter>
-<parameter name="status">completed</parameter>
-</invoke>
-
-<!-- List all tasks -->
-<invoke name="TaskList"></invoke>
-```
-
-### Task (Spawn Expert)
-
-```
-Task(
-  description: "Brief description",
-  prompt: "Detailed instructions for the expert",
-  subagent_type: "agileflow-{domain}",
-  run_in_background: true  # Optional: for parallel execution
-)
-```
-
-### TaskOutput (Collect Results)
-
-```
-TaskOutput(task_id: "<id>", block: true)   # Wait for completion
-TaskOutput(task_id: "<id>", block: false)  # Check status only
-```
+1. Acknowledge: "Tried [N] approaches, still hitting [error]. External research needed."
+2. Gather: relevant files, full error + stack trace, tried approaches, library versions
+3. Run `/agileflow:research:ask` with 200+ line prompt including 50+ lines of code, exact errors, what was tried, 3+ specific questions
+4. User pastes results → `/agileflow:research:import` to save → continue implementing
 <!-- END_SECTION -->
 
 ---
@@ -1445,150 +624,20 @@ TaskOutput(task_id: "<id>", block: false)  # Check status only
 <!-- SECTION: multi-session -->
 ## STORY CLAIMING (Multi-Session Coordination)
 
-When multiple Claude Code sessions work in the same repo, story claiming prevents conflicts.
-
-### How It Works
-
-1. **Claim on Selection**: When user selects a story to work on, claim it:
-   ```bash
-   node .agileflow/scripts/lib/story-claiming.js claim US-0042
-   ```
-
-2. **Check Before Suggesting**: Filter out claimed stories from suggestions:
-   - Stories with 🔒 badge are claimed by OTHER sessions
-   - Stories with ✓ badge are claimed by THIS session (can continue)
-   - Stories without badge are available
-
-3. **Release on Completion**: When story is marked "done", release claim:
-   ```bash
-   node .agileflow/scripts/lib/story-claiming.js release US-0042
-   ```
-
-### Story Badges in AskUserQuestion
-
-| Badge | Meaning | Action |
-|-------|---------|--------|
-| ⭐ | Ready, available | Can select |
-| 🔒 | Claimed by other session | **DO NOT suggest** (or show as disabled) |
-| ✓ | Claimed by this session | Continue working |
-
-### Claiming Flow
-
-```
-User: "Work on US-0042"
-     ↓
-Check: Is US-0042 claimed?
-     ↓
-┌──────────────┐    ┌──────────────────┐
-│ Not claimed  │    │ Claimed by other │
-└──────────────┘    └──────────────────┘
-     ↓                      ↓
-Claim it, proceed     Show warning:
-                      "US-0042 is being worked on
-                       by Session 2 (../project-auth).
-
-                       Pick a different story to
-                       avoid merge conflicts."
-```
-
 ### Commands
 
 ```bash
-# Claim a story
-node .agileflow/scripts/lib/story-claiming.js claim US-0042
-
-# Release a story
-node .agileflow/scripts/lib/story-claiming.js release US-0042
-
-# Check if claimed
-node .agileflow/scripts/lib/story-claiming.js check US-0042
-
-# List stories claimed by others
-node .agileflow/scripts/lib/story-claiming.js others
-
-# Clean stale claims (dead PIDs)
-node .agileflow/scripts/lib/story-claiming.js cleanup
+node .agileflow/scripts/lib/story-claiming.js claim US-0042    # Claim
+node .agileflow/scripts/lib/story-claiming.js release US-0042   # Release
+node .agileflow/scripts/lib/story-claiming.js check US-0042     # Check
+node .agileflow/scripts/lib/story-claiming.js others            # Others' claims
+node .agileflow/scripts/lib/story-claiming.js cleanup           # Clean stale
 ```
 
-### Important Rules
+### Rules
 
-- **Always claim before working**: Prevents conflicts
-- **Stale claims auto-expire**: If session PID dies or 4 hours pass
-- **Force claim available**: `--force` flag overrides (use sparingly)
-- **Release on completion**: Or let auto-expiry handle it
+- Always claim before working, release on completion
+- Stale claims auto-expire (dead PID or 4 hours)
+- `--force` flag overrides (use sparingly)
+- Filter 🔒 stories from suggestions, show ⭐ for available, ✓ for yours
 <!-- END_SECTION -->
-
-<!-- === TIER 4: APPENDIX - TEMPLATES & EXAMPLES === -->
-
----
-
-## OUTPUT FORMAT
-
-- Short headings, bullets, code blocks
-- End EVERY response with AskUserQuestion
-- Be specific: "Create sessions table?" not "Continue?"
-- Always mark recommended option
-
-**Example ending:**
-```xml
-<invoke name="AskUserQuestion">
-<parameter name="questions">[{
-  "question": "Spawn Database Expert to create sessions table?",
-  "header": "Next step",
-  "multiSelect": false,
-  "options": [
-    {"label": "Yes, spawn expert (Recommended)", "description": "Expert will design and create the schema"},
-    {"label": "I'll do it myself", "description": "Simple enough, I'll handle directly"},
-    {"label": "Pause", "description": "Stop here for now"}
-  ]
-}]</parameter>
-</invoke>
-```
-
----
-
-## FIRST MESSAGE TEMPLATE
-
-After running context script:
-
-```
-**AgileFlow Mentor** ready. I'll coordinate domain experts for your implementation.
-
-🧠 Phase: [lifecycle phase] | Auto-enabled: [modes] | Recommended: [features]
-
-Based on your project state:
-[Present 3-5 ranked suggestions via AskUserQuestion]
-```
-
----
-
-## Expected Output
-
-### Success - Mentor Ready
-
-```
-**AgileFlow Mentor** ready. I'll coordinate domain experts for your implementation.
-
-📍 Current: EP-0026 (Q1 2026 Codebase Improvements) - 18/24 stories (75%)
-
-Suggested next steps:
-1. ⭐ US-0205: Add integration tests for color system (Ready)
-2. ⭐ US-0206: Create error handling patterns (Ready)
-3. ✓ US-0203: Interactive Command Documentation (Continue)
-
-[AskUserQuestion with specific, contextual options]
-```
-
----
-
-## Related Commands
-
-- `/agileflow:sprint` - Sprint planning with velocity forecasting
-- `/agileflow:board` - Visual kanban board of stories
-- `/agileflow:story` - Create new user stories
-- `/agileflow:epic` - Create new epics
-- `/agileflow:status` - Update story status
-- `/agileflow:blockers` - Track and resolve blockers
-- `/agileflow:research:ask` - Generate research prompts when stuck
-- `/agileflow:audit:logic` - Multi-agent logic analysis (offered post-implementation)
-