Paths: File paths (

shared/

,

references/

,

../ln-*

) are relative to skills repo root. If not found at CWD, locate this SKILL.md directory and go up one level for repo root.

• Parse kanban board and show available Stories for user selection
• Ask business questions in ONE batch before execution; make technical decisions autonomously
• Spawn worker via TeamCreate for selected Story (single worker)
• Drive selected Story through 4 stages: ln-300 -> ln-310 -> ln-400 -> ln-500
• Sync with develop + generate report after quality gate PASS; merge only on user confirmation
• Handle failures, retries, and escalation to user

• One Story ready for processing — user picks which one
• Need end-to-end automation: task planning -> validation -> execution -> quality gate -> merge confirmation
• Want controlled Story processing with user confirmation before merge

references/kanban_parser.md

1. Auto-discover

   docs/tasks/kanban_board.md

   (or Linear API via storage mode detection)
2. Extract project brief from target project's CLAUDE.md (NOT skills repo):

   project_brief = {
     name: <from H1 or first line>,
     tech: <from Development Commands / tech references>,
     type: <inferred: "CLI", "API", "web app", "library">,
     key_rules: <2-3 critical rules>
   }
   IF not found: project_brief = { name: basename(project_root), tech: "unknown" }

3. Parse all status sections: Backlog, Todo, In Progress, To Review, To Rework
4. Extract Story list with: ID, title, status, Epic name, task presence
5. Filter: skip Stories in Done, Postponed, Canceled
6. Detect task presence per Story:
   • Has

     _(tasks not created yet)_

     → no tasks → Stage 0
   • Has task lines (4-space indent) → tasks exist → Stage 1+
7. Determine target stage per Story (see

   references/pipeline_states.md

   Stage-to-Status Mapping)
8. Show available Stories and ask user to pick ONE:

   Project: {project_brief.name} ({project_brief.tech})
   
   Available Stories:
   | # | Story | Status | Stage | Skill | Epic |
   |---|-------|--------|-------|-------|------|
   | 1 | PROJ-42: Auth endpoint | To Review | 3 | ln-500 | Epic: Auth |
   | 2 | PROJ-55: CRUD users | Backlog (no tasks) | 0 | ln-300 | Epic: Users |
   | 3 | PROJ-60: Dashboard | Todo | 2 | ln-400 | Epic: UI |
   
   AskUserQuestion: "Which story to process? Enter # or Story ID."

9. Store selected story. Extract story brief for selected story only:

   description = get_issue(selected_story.id).description
   story_briefs[id] = parse <!-- ORCHESTRATOR_BRIEF_START/END --> markers
   IF no markers: story_briefs[id] = { tech: project_brief.tech, keyFiles: "unknown" }

1. Load selected Story description (metadata only)
2. Scan for business ambiguities — questions where:
   • Answer cannot be found in codebase, docs, or standards
   • Answer requires business/product decision (payment provider, auth flow, UI preference)
3. Collect ALL business questions into single AskUserQuestion:

   "Before starting Story {selected_story.id}:
    Which payment provider? (Stripe/PayPal/both)
    Auth flow — JWT or session-based?"

4. Technical questions — resolve using project_brief:
   • Library versions: MCP Ref / Context7 (for

     project_brief.tech

     ecosystem)
   • Architecture patterns:

     project_brief.key_rules

   • Standards compliance: ln-310 Phase 2 handles this
5. Store answers in shared context (pass to worker via spawn prompt)

.claude/settings.local.json

• defaultMode

  =

  "bypassPermissions"

  (required for workers)

• hooks.Stop

  registered →

  pipeline-keepalive.sh

• hooks.TeammateIdle

  registered →

  worker-keepalive.sh

references/settings_template.json

cp

#!/bin/bash

undefined

feature/{id}-{slug}

model: "opus"

effort_for_stage(0) = "low"

effort_for_stage(1) = "medium"

effort_for_stage(2) = "medium"

effort_for_stage(3) = "medium"

1. Ensure

   develop

   branch exists:

   IF `develop` branch not found locally or on origin:
     git branch develop $(git symbolic-ref --short HEAD)   # Create from current default branch
     git push -u origin develop
   git checkout develop               # Start pipeline from develop

2. Create team:

   TeamCreate(team_name: "pipeline-{YYYY-MM-DD}-{HHmm}")

1. Process worker messages (reactive message handling)

references/phases/phase4_handlers.md

• Stage 0 COMPLETE / ERROR (task planning outcomes)
• Stage 1 COMPLETE (GO / NO-GO validation outcomes with retry logic)
• Stage 2 COMPLETE / ERROR (execution outcomes)
• Stage 3 COMPLETE (PASS/CONCERNS/WAIVED/FAIL quality gate outcomes with rework cycles)
• Worker crash detection (3-step protocol: flag → probe → respawn)

2. Active done-flag verification (proactive health monitoring)

references/phases/phase4_heartbeat.md

• Lost message detection (done-flag exists but state not advanced)
• Synthetic recovery from checkpoint + kanban verification (all 4 stages)
• Fallback to probe protocol when checkpoint missing
• Structured heartbeat output (single story status line)
• Helper functions (skill_name_from_stage, predict_next_step)

3. Heartbeat state persistence

Phase 4a Section B: Ask user for merge confirmation

(Section A: sync+report already executed by Stage 3 PASS handler)

 Merge feature/{id}-{slug} to develop?"

**`determine_stage(story)` routing:** See `references/pipeline_states.md` Stage-to-Status Mapping table.

references/phases/phase4a_git_merge.md

• Section A: Sync with develop (rebase → fallback to merge), collect metrics, append story report, verify kanban/Linear — executed automatically after Stage 3 PASS
• Section B: Ask user for merge confirmation (AskUserQuestion) — post-loop
• Section C: Squash merge into develop, worktree cleanup, context refresh — only if user confirms
• Section D: Preserve branch, output manual merge instructions — if user declines

Pipeline Report — {date}

Stage Duration Breakdown

           FOR N IN 0..3 IF both timestamps exist}

Code Output Metrics

Cost Estimate

Infrastructure Issues

Operational Recommendations

• IF quality_cycles[id] > 0: "Needed {N} quality cycles. Improve task specs or acceptance criteria."
• IF validation_retries[id] > 0: "Failed validation. Review Story/Task structure."
• IF crash_count[id] > 0: "Worker crashed {N} times. Check for context-heavy operations."
• IF story_state[id] == "PAUSED": "Story requires manual intervention."
• IF infra_issues with type "hook": "Hook configuration errors. Verify settings.local.json and .claude/hooks/."
• IF infra_issues with type "git": "Git conflicts encountered. Rebase feature branches more frequently."
• IF all DONE with 0 retries AND no infra_issues: "Clean run — no issues detected."

Worktree already removed in Phase 4a Section C

Preserve worktree — user needs it for manual merge

• Lead = single writer to kanban_board.md. Workers report results via SendMessage; lead updates the board
• Re-read board after each stage completion for fresh state
• Update algorithm: Follow

  shared/references/kanban_update_algorithm.md

  for Epic grouping and indentation

1. Single Story processing. One worker at a time. User selects which Story to process
2. Delegate mode. Lead coordinates only — never invoke ln-300/ln-310/ln-400/ln-500 directly. Workers do all execution
3. Skills as-is. Never modify or bypass existing skill logic. Workers call

   Skill("ln-310-story-validator", args)

   exactly as documented
4. Kanban verification. Workers update Linear/kanban via skills. Lead re-reads and ASSERTs expected state after each stage. In file mode, lead resolves merge conflicts
5. Quality cycle limit. Max 2 quality FAILs per Story (original + 1 rework cycle). After 2nd FAIL, escalate to user
6. Merge only on confirmation. After quality gate PASS, sync with develop and ask user. Merge only if confirmed. Feature branch preserved if declined
7. Re-read kanban. After every stage completion, re-read board for fresh state. Never cache
8. Graceful shutdown. Always shutdown workers via shutdown_request. Never force-kill

• Running ln-300/ln-310/ln-400/ln-500 directly from lead instead of delegating to workers
• Processing multiple stories without user selection
• Auto-merging to develop without user confirmation
• Lead skipping kanban verification after worker updates (workers write via skills, lead MUST re-read + ASSERT)
• Skipping quality gate after execution
• Merging to develop before quality gate PASS
• Caching kanban state instead of re-reading
• Reading

  ~/.claude/teams/*/inboxes/*.json

  directly (messages arrive automatically)
• Using

  sleep

  + filesystem polling for message checking
• Parsing internal Claude Code JSON formats (permission_request, idle_notification)
• Reusing same worker across stages (context exhaustion — spawn fresh worker per stage)
• Processing messages without verifying sender matches worker_map (stale message confusion from old/dead workers)

1. Parse kanban board (Phase 1 steps 1-7)
2. Show available Stories table
3. AskUserQuestion: "Which story to plan for? Enter # or Story ID."
4. Show execution plan for selected Story
5. Write plan to plan file, call ExitPlanMode

undefined

1. TeamCreate("pipeline-{date}")
2. Create worktree + feature branch: feature/{id}-{slug}
3. Spawn worker -> Stage {N} ({skill_name})
4. Drive through remaining stages until quality gate
5. Sync with develop, generate report
6. Ask for merge confirmation
7. Cleanup

undefined

• Message handlers:

  references/phases/phase4_handlers.md

  (Stage 0-3 ON handlers, crash detection)
• Heartbeat & verification:

  references/phases/phase4_heartbeat.md

  (Active done-flag checking, structured heartbeat output)
• Git flow:

  references/phases/phase4a_git_merge.md

  (Sync, report, merge confirmation, worktree cleanup)

• Known issues:

  references/known_issues.md

  (production-discovered problems and self-recovery)
• Message protocol:

  references/message_protocol.md

• Worker health:

  references/worker_health_contract.md

• Checkpoint format:

  references/checkpoint_format.md

• Settings template:

  references/settings_template.json

• Hooks:

  references/hooks/pipeline-keepalive.sh

  ,

  references/hooks/worker-keepalive.sh

• Kanban parsing:

  references/kanban_parser.md

• Pipeline states:

  references/pipeline_states.md

• Worker prompts:

  references/worker_prompts.md

• Kanban update algorithm:

  shared/references/kanban_update_algorithm.md

• Storage mode detection:

  shared/references/storage_mode_detection.md

• Auto-discovery patterns:

  shared/references/auto_discovery_pattern.md

• ../ln-300-task-coordinator/SKILL.md

• ../ln-310-story-validator/SKILL.md

• ../ln-400-story-executor/SKILL.md

• ../ln-500-story-quality-gate/SKILL.md