snipcodeit · snipcodeit · Feb 27, 2026 · Feb 27, 2026 · Feb 27, 2026 · Feb 27, 2026
@@ -135,22 +135,65 @@ mkdir -p "$QUICK_DIR"
 
 ## GSD Milestone Pipeline Pattern
 
-Used by `/mgw:run` for large issues (gsd:new-milestone route).
+Used by `/mgw:run` for large issues (gsd:new-milestone route) and `/mgw:milestone` for
+milestone-level orchestration. This is the full lifecycle — each phase goes through
+plan -> execute -> verify before moving to the next.
 
 ```bash
 # 1. Init milestone
 MILESTONE_INIT=$(node ~/.claude/get-shit-done/bin/gsd-tools.cjs init new-milestone 2>/dev/null)
 
-# 2. Resolve models
+# 2. Create ROADMAP (autonomous from issue data, or interactive fallback)
+# Spawn roadmapper agent -> user confirmation checkpoint -> proceed
+
+# 3. Resolve models
 PLANNER_MODEL=$(node ~/.claude/get-shit-done/bin/gsd-tools.cjs resolve-model gsd-planner --raw)
 EXECUTOR_MODEL=$(node ~/.claude/get-shit-done/bin/gsd-tools.cjs resolve-model gsd-executor --raw)
 VERIFIER_MODEL=$(node ~/.claude/get-shit-done/bin/gsd-tools.cjs resolve-model gsd-verifier --raw)
 
-# 3. For each phase in ROADMAP.md:
-#    a. Spawn planner (gsd-planner)
-#    b. Spawn executor(s) (gsd-executor)
-#    c. Spawn verifier (gsd-verifier)
-#    d. Post phase update comment on issue
+# 4. Discover phases from ROADMAP
+ROADMAP_ANALYSIS=$(node ~/.claude/get-shit-done/bin/gsd-tools.cjs roadmap analyze)
+# Extract: phase list with numbers, names, slugs
+
+# 5. Per-phase lifecycle loop:
+# for each phase:
+  # a. Init phase and create directory
+  PHASE_INIT=$(node ~/.claude/get-shit-done/bin/gsd-tools.cjs init plan-phase "${PHASE_NUM}")
+  mkdir -p "${phase_dir}"
+
+  # b. Spawn planner (gsd-planner) -> creates PLAN.md files
+  # Task(subagent_type="gsd-planner", ...)
+
+  # c. Init execute-phase
+  EXEC_INIT=$(node ~/.claude/get-shit-done/bin/gsd-tools.cjs init execute-phase "${PHASE_NUM}")
+
+  # d. Spawn executor (gsd-executor) -> creates SUMMARY.md files
+  # Task(subagent_type="gsd-executor", ...)
+
+  # e. Spawn verifier (gsd-verifier) -> creates VERIFICATION.md
+  # Task(subagent_type="gsd-verifier", ...)
+
+  # f. Post phase-complete comment on issue
+  # gh issue comment ...
+
+# 6. Complete milestone (archive phases, clean ROADMAP, tag release)
+# Called from milestone.md post_loop when all issues finish
+# Follows gsd:complete-milestone workflow
+```
+
+**Artifacts created per phase:**
+```
+.planning/phases/{NN}-{slug}/
+  {phase}-{plan}-PLAN.md        (from planner)
+  {phase}-{plan}-SUMMARY.md     (from executor)
+  {phase}-VERIFICATION.md       (from verifier)
+```
+
+**Artifacts created on milestone completion:**
+```
+.planning/milestones/
+  v{X.Y}-ROADMAP.md             (archived roadmap)
+  v{X.Y}-REQUIREMENTS.md        (archived requirements)
 ```
 
 ## Utility Patterns
@@ -270,7 +313,7 @@ and codebase to classify, then MGW presents the result and offers follow-up acti
 | Standard spawn template | run.md, issue.md, pr.md, ask.md, review.md |
 | Comment classification | run.md (pre-flight), review.md (standalone) |
 | Quick pipeline | run.md |
-| Milestone pipeline | run.md |
+| Milestone pipeline | run.md, milestone.md |
 | Question classification | ask.md |
 | Model resolution | run.md |
 | Utility patterns | run.md, pr.md, issue.md, sync.md, link.md, update.md, ask.md |
@@ -668,7 +668,35 @@ gh release create "$RELEASE_TAG" --draft \
   --notes "$RELEASE_BODY" 2>/dev/null
 ```
 
-3. Advance current_milestone in project.json:
+3. Finalize GSD milestone state (archive phases, clean up):
+```bash
+# Only run if .planning/phases exists (GSD was used for this milestone)
+if [ -d ".planning/phases" ]; then
+  EXECUTOR_MODEL=$(node ~/.claude/get-shit-done/bin/gsd-tools.cjs resolve-model gsd-executor --raw)
+  Task(
+    prompt="
+<files_to_read>
+- ./CLAUDE.md (Project instructions -- if exists, follow all guidelines)
+- .planning/ROADMAP.md (Current roadmap to archive)
+- .planning/REQUIREMENTS.md (Requirements to archive)
+</files_to_read>
+
+Complete the GSD milestone. Follow the complete-milestone workflow:
+@~/.claude/get-shit-done/workflows/complete-milestone.md
+
+This archives the milestone's ROADMAP and REQUIREMENTS to .planning/milestones/,
+cleans up ROADMAP.md for the next milestone, and tags the release in git.
+
+Milestone: ${MILESTONE_NAME}
+",
+    subagent_type="gsd-executor",
+    model="${EXECUTOR_MODEL}",
+    description="Complete GSD milestone: ${MILESTONE_NAME}"
+  )
+fi
+```
+
+4. Advance current_milestone in project.json:
 ```bash
 python3 -c "
 import json
@@ -680,7 +708,7 @@ with open('${MGW_DIR}/project.json', 'w') as f:
 "
 ```
 
-4. Display completion banner:
+5. Display completion banner:
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  MGW ► MILESTONE ${MILESTONE_NUM} COMPLETE ✓
@@ -709,7 +737,7 @@ Draft release created: ${RELEASE_TAG}
 ───────────────────────────────────────────────────────────────
 ```
 
-5. Check if next milestone exists and offer auto-advance (only if no failures in current).
+6. Check if next milestone exists and offer auto-advance (only if no failures in current).
 
 **If some issues failed:**
 
@@ -732,7 +760,7 @@ Milestone NOT closed. Resolve failures and re-run:
   /mgw:milestone ${MILESTONE_NUM}
 ```
 
-6. Post final results table as GitHub comment on the first issue in the milestone:
+7. Post final results table as GitHub comment on the first issue in the milestone:
 ```bash
 gh issue comment ${FIRST_ISSUE_NUMBER} --body "$FINAL_RESULTS_COMMENT"
 ```

@@ -536,29 +536,166 @@ VERIFIER_MODEL=$(node ~/.claude/get-shit-done/bin/gsd-tools.cjs resolve-model gs
    Update pipeline_stage to "planning" (at `${REPO_ROOT}/.mgw/active/`).
 
 2. **If resuming with pipeline_stage = "planning" and ROADMAP.md exists:**
-   Read ROADMAP.md to find phases. For each phase:
+   Discover phases from ROADMAP and run the full per-phase GSD lifecycle:
 
-   a. Spawn discuss + plan via task agents (following gsd:plan-phase workflow)
-   b. Spawn executor(s) via task agents (following gsd:execute-phase workflow)
-   c. Spawn verifier
-   d. Post phase update comment directly (no sub-agent):
+   ```bash
+   ROADMAP_ANALYSIS=$(node ~/.claude/get-shit-done/bin/gsd-tools.cjs roadmap analyze)
+   # Parse ROADMAP_ANALYSIS JSON for list of phases:
+   # Each phase has: phase_number, phase_name, phase_slug
+   PHASE_LIST=$(echo "$ROADMAP_ANALYSIS" | python3 -c "
+   import json, sys
+   data = json.load(sys.stdin)
+   for p in data.get('phases', []):
+       print(f\"{p['number']}|{p['name']}|{p.get('slug', '')}\")
+   ")
+   ```
+
+   For each phase in order:
+
+   **a. Scaffold phase directory, then init:**
+
+   `init plan-phase` requires the phase directory to exist before it can locate it.
+   Use `scaffold phase-dir` first (which creates the directory from ROADMAP data),
+   then call `init plan-phase` to get planner/checker model assignments.
+
+   ```bash
+   # Generate slug from phase name (lowercase, hyphens, no special chars)
+   PHASE_SLUG=$(echo "${PHASE_NAME}" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9]/-/g' | sed 's/--*/-/g' | sed 's/^-//;s/-$//')
+
+   # Scaffold creates the directory and returns the path
+   SCAFFOLD=$(node ~/.claude/get-shit-done/bin/gsd-tools.cjs scaffold phase-dir --phase "${PHASE_NUMBER}" --name "${PHASE_SLUG}")
+   phase_dir=$(echo "$SCAFFOLD" | python3 -c "import json,sys; print(json.load(sys.stdin)['directory'])")
+
+   # Now init plan-phase can find the directory for model resolution
+   PHASE_INIT=$(node ~/.claude/get-shit-done/bin/gsd-tools.cjs init plan-phase "${PHASE_NUMBER}")
+   # Parse PHASE_INIT JSON for: planner_model, checker_model
+   ```
+
+   **b. Spawn planner agent (gsd:plan-phase):**
+   ```
+   Task(
+     prompt="
+   <files_to_read>
+   - ./CLAUDE.md (Project instructions -- if exists, follow all guidelines)
+   - .agents/skills/ (Project skills -- if dir exists, list skills, read SKILL.md for each, follow relevant rules)
+   - .planning/ROADMAP.md (Phase definitions and requirements)
+   - .planning/STATE.md (If exists -- project state)
+   </files_to_read>
+
+   You are the GSD planner. Plan phase ${PHASE_NUMBER}: ${PHASE_NAME}.
+
+   Read and follow the plan-phase workflow:
+   @~/.claude/get-shit-done/workflows/plan-phase.md
+
+   Phase directory: ${phase_dir}
+   Phase number: ${PHASE_NUMBER}
+
+   Create PLAN.md file(s) in the phase directory. Each plan must have:
+   - Frontmatter with phase, plan, type, wave, depends_on, files_modified, autonomous, requirements, must_haves
+   - Objective, context, tasks, verification, success criteria, output sections
+   - Each task with files, action, verify, done fields
+
+   Commit the plan files when done.
+   ",
+     subagent_type="gsd-planner",
+     model="${PLANNER_MODEL}",
+     description="Plan phase ${PHASE_NUMBER}: ${PHASE_NAME}"
+   )
+   ```
+
+   **c. Verify plans exist:**
+   ```bash
+   PLAN_COUNT=$(ls ${phase_dir}/*-PLAN.md 2>/dev/null | wc -l)
+   if [ "$PLAN_COUNT" -eq 0 ]; then
+     echo "ERROR: No plans created for phase ${PHASE_NUMBER}. Skipping phase execution."
+     # Post error comment and continue to next phase
+     gh issue comment ${ISSUE_NUMBER} --body "> **MGW** \`phase-error\` Phase ${PHASE_NUMBER} planning produced no plans. Skipping." 2>/dev/null || true
+     continue
+   fi
+   ```
+
+   **d. Init execute-phase and spawn executor agent (gsd:execute-phase):**
+   ```bash
+   EXEC_INIT=$(node ~/.claude/get-shit-done/bin/gsd-tools.cjs init execute-phase "${PHASE_NUMBER}")
+   # Parse EXEC_INIT JSON for: executor_model, verifier_model, phase_dir, plans, incomplete_plans, plan_count
+   ```
+   ```
+   Task(
+     prompt="
+   <files_to_read>
+   - ./CLAUDE.md (Project instructions -- if exists, follow all guidelines)
+   - .agents/skills/ (Project skills -- if dir exists, list skills, read SKILL.md for each, follow relevant rules)
+   - ${phase_dir}/*-PLAN.md (Plans to execute)
+   </files_to_read>
+
+   You are the GSD executor. Execute all plans for phase ${PHASE_NUMBER}: ${PHASE_NAME}.
+
+   Read and follow the execute-phase workflow:
+   @~/.claude/get-shit-done/workflows/execute-phase.md
+
+   Phase: ${PHASE_NUMBER}
+   Phase directory: ${phase_dir}
+
+   Execute each plan's tasks in wave order. For each plan:
+   1. Execute all tasks
+   2. Commit each task atomically
+   3. Create SUMMARY.md in the phase directory
+
+   Do NOT update ROADMAP.md or STATE.md directly -- those are managed by GSD tools.
+   ",
+     subagent_type="gsd-executor",
+     model="${EXECUTOR_MODEL}",
+     description="Execute phase ${PHASE_NUMBER}: ${PHASE_NAME}"
+   )
+   ```
+
+   **e. Spawn verifier agent (gsd:verify-phase):**
+   ```
+   Task(
+     prompt="
+   <files_to_read>
+   - ./CLAUDE.md (Project instructions -- if exists, follow all guidelines)
+   - .agents/skills/ (Project skills -- if dir exists, list skills, read SKILL.md for each, follow relevant rules)
+   - ${phase_dir}/*-PLAN.md (Plans with must_haves)
+   - ${phase_dir}/*-SUMMARY.md (Execution summaries)
+   </files_to_read>
+
+   Verify phase ${PHASE_NUMBER}: ${PHASE_NAME} goal achievement.
+
+   Read and follow the verify-phase workflow:
+   @~/.claude/get-shit-done/workflows/verify-phase.md
+
+   Phase: ${PHASE_NUMBER}
+   Phase directory: ${phase_dir}
+
+   Check must_haves from plan frontmatter against actual codebase.
+   Create VERIFICATION.md in the phase directory.
+   ",
+     subagent_type="gsd-verifier",
+     model="${VERIFIER_MODEL}",
+     description="Verify phase ${PHASE_NUMBER}: ${PHASE_NAME}"
+   )
+   ```
+
+   **f. Post phase-complete comment directly (no sub-agent):**
    ```bash
    PHASE_TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+   VERIFICATION_STATUS=$(grep -m1 "^## " "${phase_dir}/"*-VERIFICATION.md 2>/dev/null | head -1 || echo "Verification complete")
    PHASE_BODY=$(cat <<COMMENTEOF
 > **MGW** · \`phase-complete\` · ${PHASE_TIMESTAMP}
 > ${MILESTONE_CONTEXT}
 
-### Phase ${phase_num} Complete — ${phase_name}
+### Phase ${PHASE_NUMBER} Complete — ${PHASE_NAME}
 
-${brief_summary_from_executor}
+Execution complete. See ${phase_dir} for plans, summaries, and verification.
 
-**Verification:** ${verification_status}
+**Verification:** ${VERIFICATION_STATUS}
 COMMENTEOF
 )
    gh issue comment ${ISSUE_NUMBER} --body "$PHASE_BODY" 2>/dev/null || true
    ```
 
-   After all phases complete → update pipeline_stage to "verifying" (at `${REPO_ROOT}/.mgw/active/`).
+   After ALL phases complete → update pipeline_stage to "verifying" (at `${REPO_ROOT}/.mgw/active/`).
 </step>
 
 <step name="post_execution_update">