mindsystem-cc 3.19.0 → 3.21.0

package/commands/ms/doctor.md

@@ -13,11 +13,15 @@ allowed-tools:
 ---
 
 <objective>
-Run comprehensive health checks on project configuration. Detect and fix structural drift across 6 categories: subsystem vocabulary, milestone directory structure, phase archival, knowledge files, phase summaries, and PLAN cleanup.
+Run health checks on project configuration. Detect and fix structural drift across 8 categories: subsystem vocabulary, milestone directory structure, milestone naming convention, phase archival, knowledge files, phase summaries, PLAN cleanup, and CLI wrappers.
 
-Idempotent — safe to run repeatedly.
+Idempotent.
 </objective>
 
+<execution_context>
+@~/.claude/mindsystem/workflows/doctor-fixes.md
+</execution_context>
+
 <context>
 @.planning/config.json
 @.planning/MILESTONES.md
@@ -68,7 +72,7 @@ Proceed to next step.
 Run the diagnostic scan:
 
 ```bash
-~/.claude/mindsystem/scripts/doctor-scan.sh
+ms-tools doctor-scan
 ```
 
 Capture the full output. Parse each check's Status (PASS/FAIL/SKIP) and detail lines.
@@ -84,10 +88,12 @@ Display results as a markdown table:
 |--------------------------|--------|----------------------------------|
 | Subsystem vocabulary     | PASS   | 9 subsystems, all artifacts OK   |
 | Milestone directories    | FAIL   | 2 flat files need restructuring  |
+| Milestone naming         | FAIL   | 2 version-prefixed dirs need migration |
 | Phase archival           | FAIL   | 8 orphaned phase directories     |
 | Knowledge files          | FAIL   | Directory missing                |
 | Phase summaries          | FAIL   | 2 milestones missing summaries   |
 | PLAN cleanup             | FAIL   | 9 leftover PLAN.md files         |
+| CLI wrappers             | FAIL   | ms-tools not on PATH             |
 ```
 
 Populate Result and Details from scan output. Use concise detail summaries.
@@ -109,210 +115,22 @@ If "Skip" → go to `report`.
 
 If "Review each" → use AskUserQuestion for each failed check with its details and options: "Fix" / "Skip". Only run fixes for accepted checks.
 
-Apply fixes in dependency order: fix_subsystems → fix_milestone_dirs → fix_phase_archival → fix_plan_cleanup → fix_knowledge. Skip any fix whose check passed or was skipped by user.
-</step>
-
-<step name="fix_subsystems">
-**Only if Subsystem Vocabulary failed.**
-
-If subsystems array is empty (State A):
-
-1. Scan all artifacts for existing values:
-
-```bash
-~/.claude/mindsystem/scripts/scan-artifact-subsystems.sh --values-only
-```
-
-2. Read `.planning/PROJECT.md` and `.planning/ROADMAP.md`.
-
-3. Derive 5-12 canonical subsystem identifiers from:
-   - Unique values found in artifacts
-   - Project domain from PROJECT.md
-   - Phase structure from ROADMAP.md
-
-   Rules:
-   - Lowercase, single-word or hyphenated (e.g., "auth", "real-time", "ui")
-   - Merge synonyms into one canonical value (pick shortest/most common)
-   - Cover all existing usage plus obvious gaps
-   - Include infrastructure-level subsystems if relevant (api, database, infra, testing)
-
-4. Present the proposed list with merge mappings (e.g., "authentication" -> "auth").
-
-5. Use AskUserQuestion:
-   - header: "Subsystems"
-   - question: "These subsystems were derived from your project. Look good?"
-   - options:
-     - "Looks good" — accept and apply
-     - "Add/remove some" — iterate on the list
-     - "Start over" — re-derive from scratch
-
-6. After confirmation: update `config.json` (subsystems as first field), standardize existing artifact `subsystem:` fields using Edit tool.
-
-If subsystems exist but artifacts have mismatches (State B):
-
-1. Classify each artifact as OK/MISMATCH/MISSING.
-2. For MISMATCH: propose closest canonical value.
-3. For MISSING: propose based on artifact content/path.
-4. Apply fixes using Edit tool.
-
-Commit:
-
-```bash
-git add .planning/config.json
-git add .planning/phases/*/*-SUMMARY.md 2>/dev/null
-git add .planning/adhoc/*-SUMMARY.md 2>/dev/null
-git add .planning/debug/*.md 2>/dev/null
-git add .planning/debug/resolved/*.md 2>/dev/null
-git add .planning/todos/pending/*.md 2>/dev/null
-git add .planning/todos/done/*.md 2>/dev/null
-```
-
-```bash
-git commit -m "$(cat <<'EOF'
-chore(doctor): fix subsystem vocabulary
-
-Standardized subsystem configuration and artifact values.
-EOF
-)"
-```
-</step>
-
-<step name="fix_milestone_dirs">
-**Only if Milestone Directory Structure failed.**
-
-For each flat file like `milestones/v0.1-ROADMAP.md`:
-
-1. Extract version prefix (e.g., `v0.1`).
-2. Create versioned directory if it doesn't exist: `mkdir -p .planning/milestones/v0.1`
-3. `git mv` the file, stripping the version prefix from the filename:
-   `git mv .planning/milestones/v0.1-ROADMAP.md .planning/milestones/v0.1/ROADMAP.md`
-
-Commit:
-
-```bash
-git add .planning/milestones/
-```
-
-```bash
-git commit -m "$(cat <<'EOF'
-chore(doctor): restructure milestone directories
-
-Moved flat milestone files into versioned directories.
-EOF
-)"
-```
-</step>
-
-<step name="fix_phase_archival">
-**Only if Phase Archival failed.**
-
-Parse MILESTONES.md for completed milestones and their phase ranges (`**Phases completed:** X-Y`).
-
-For each completed milestone with orphaned phases in `.planning/phases/`:
-
-1. Determine the version and phase range from MILESTONES.md.
-2. Ensure the milestone directory exists: `mkdir -p .planning/milestones/{version}`
-3. Run the archive script:
-
-```bash
-~/.claude/mindsystem/scripts/archive-milestone-phases.sh <start> <end> <version>
-```
-
-This simultaneously:
-- Consolidates PHASE-SUMMARIES.md (fixes Phase Summaries check)
-- Deletes raw artifacts (CONTEXT, DESIGN, RESEARCH, SUMMARY, UAT, VERIFICATION)
-- Moves phase directories to milestone archive
+Apply fixes in dependency order: fix_subsystems → fix_milestone_dirs → fix_milestone_naming → fix_phase_archival → fix_plan_cleanup → fix_knowledge. Skip any fix whose check passed or was skipped by user.
 
-**If MILESTONES.md doesn't have parseable phase ranges:** Use AskUserQuestion to ask the user for the phase range for each milestone.
-
-After archive completes, clean up leftover PLAN files in archived phases (fixes PLAN Cleanup check):
-
-```bash
-find .planning/milestones/*/phases/ -name "*-PLAN.md" -delete 2>/dev/null
-```
-
-Commit:
-
-```bash
-git add .planning/phases/ .planning/milestones/
-```
-
-```bash
-git commit -m "$(cat <<'EOF'
-chore(doctor): archive completed milestone phases
-
-Consolidated summaries, deleted raw artifacts, moved phase directories.
-EOF
-)"
-```
+Phase summaries are resolved by fix_phase_archival. CLI wrappers require manual PATH configuration (no automated fix).
 </step>
 
-<step name="fix_plan_cleanup">
-**Only if PLAN Cleanup failed AND fix_phase_archival did not already handle it.**
-
-Delete leftover PLAN files in completed phase directories:
-
-```bash
-find .planning/milestones/*/phases/ -name "*-PLAN.md" -delete 2>/dev/null
-```
-
-For any leftover PLANs in `phases/` belonging to completed milestones (identified by the scan), delete those too.
-
-Commit:
-
-```bash
-git add .planning/
-```
-
-```bash
-git commit -m "$(cat <<'EOF'
-chore(doctor): clean up leftover PLAN files
-
-Removed PLAN files from completed phase directories.
-EOF
-)"
-```
-</step>
-
-<step name="fix_knowledge">
-**Only if Knowledge Files failed.**
-
-Spawn a `general-purpose` subagent (Task tool) to generate knowledge files retroactively. Provide the subagent with:
-
-- Subsystem vocabulary from config.json
-- Instructions to read all PHASE-SUMMARIES.md from `milestones/*/PHASE-SUMMARIES.md` AND any remaining SUMMARY files in `phases/`
-- The knowledge template at `~/.claude/mindsystem/templates/knowledge.md`
-- Instructions to read any existing knowledge files and merge (rewrite semantics — current state, not append)
-- Instructions to create `.planning/knowledge/` directory if missing
-- Instructions to write `.planning/knowledge/{subsystem}.md` for each missing subsystem
-
-After subagent completes, verify files exist:
-
-```bash
-ls .planning/knowledge/*.md
-```
-
-Commit:
-
-```bash
-git add .planning/knowledge/
-```
-
-```bash
-git commit -m "$(cat <<'EOF'
-chore(doctor): generate knowledge files
-
-Created per-subsystem knowledge files from phase summaries.
-EOF
-)"
-```
+<step name="apply_fixes">
+Execute fix steps from doctor-fixes workflow in dependency order. For "Fix all": run all
+applicable steps. For "Review each": run only user-accepted steps. Skip any step whose
+check passed.
 </step>
 
 <step name="verify">
 Re-run the diagnostic scan:
 
 ```bash
-~/.claude/mindsystem/scripts/doctor-scan.sh
+ms-tools doctor-scan
 ```
 
 All checks should now PASS. If any still fail, report which checks remain and why.
@@ -328,10 +146,12 @@ Final summary table:
 |--------------------------|--------|----------------------------------|
 | Subsystem vocabulary     | PASS   | ...                              |
 | Milestone directories    | PASS   | ...                              |
+| Milestone naming         | PASS   | ...                              |
 | Phase archival           | PASS   | ...                              |
 | Knowledge files          | PASS   | ...                              |
 | Phase summaries          | PASS   | ...                              |
 | PLAN cleanup             | PASS   | ...                              |
+| CLI wrappers             | PASS   | ...                              |
 
 All checks passed.
 ```
@@ -342,11 +162,11 @@ Include counts: checks total, passed, fixed during this run.
 </process>
 
 <success_criteria>
-- [ ] Each fix group committed atomically
-- [ ] Re-scan verifies all checks pass after fixes
 - [ ] User confirms fix strategy before changes (Fix all / Review each / Skip)
-- [ ] Fixes applied in dependency order: subsystems → dirs → archival → cleanup → knowledge
 - [ ] Results displayed as markdown table before any action
-- [ ] All 6 categories reported with PASS/FAIL/SKIP
+- [ ] Re-scan verifies all checks pass after fixes
+- [ ] Each fix group committed atomically
+- [ ] Fixes applied in dependency order: subsystems → dirs → milestone naming → archival → cleanup → knowledge
+- [ ] All 8 categories reported with PASS/FAIL/SKIP
 - [ ] Clean project reports all PASS with no fix prompts
 </success_criteria>

package/commands/ms/execute-phase.md

@@ -30,10 +30,9 @@ Context budget: ~15% orchestrator, 100% fresh per subagent.
 <context>
 Phase: $ARGUMENTS
 
-**Normalize phase number:**
+**Resolve phase:**
 ```bash
-PHASE_ARG="$ARGUMENTS"
-PHASE=$(printf "%02d" "$PHASE_ARG" 2>/dev/null || echo "$PHASE_ARG")
+ms-tools find-phase "$ARGUMENTS"
 ```
 
 @.planning/ROADMAP.md
@@ -53,7 +52,7 @@ PHASE=$(printf "%02d" "$PHASE_ARG" 2>/dev/null || echo "$PHASE_ARG")
    - Build list of incomplete plans
 
 3. **Validate and read execution order**
-   - Run `validate-execution-order.sh` on phase directory
+   - Run `ms-tools validate-execution-order` on phase directory
    - Parse EXECUTION-ORDER.md wave structure
    - Report wave structure to user
 
@@ -62,7 +61,7 @@ PHASE=$(printf "%02d" "$PHASE_ARG" 2>/dev/null || echo "$PHASE_ARG")
    - Spawn `ms-executor` for each plan in wave (parallel Task calls)
    - Wait for completion (Task blocks)
    - Verify SUMMARYs created
-   - Run `update-state.sh` to update plan progress
+   - Run `ms-tools update-state` to update plan progress
    - Proceed to next wave
 
 5. **Aggregate results**
@@ -85,7 +84,7 @@ PHASE=$(printf "%02d" "$PHASE_ARG" 2>/dev/null || echo "$PHASE_ARG")
    - If changes made: commit as `refactor({phase}): code review improvements`
 
 8. **Generate phase patch**
-   - Run: `~/.claude/mindsystem/scripts/generate-phase-patch.sh ${PHASE_NUMBER}`
+   - Run: `ms-tools generate-phase-patch ${PHASE_NUMBER}`
    - Outputs to `.planning/phases/{phase_dir}/{phase}-changes.patch`
    - Verify: patch file exists OR skip message logged
    - Note: Patch captures all changes including simplifications
@@ -127,7 +126,19 @@ PHASE=$(printf "%02d" "$PHASE_ARG" 2>/dev/null || echo "$PHASE_ARG")
 <offer_next>
 **MANDATORY: Present copy/paste-ready next command.**
 
-After verification completes, route based on status:
+After verification completes:
+
+**First, surface user actions from all SUMMARYs:**
+
+Extract `## User Actions Required` sections from all `*-SUMMARY.md` files in the phase directory. If any contain actions (not "None"), present before route-specific content:
+
+```
+## ⚠ Action Required
+
+{Consolidated list from all SUMMARYs — deduplicate if overlapping}
+```
+
+Then route based on status:
 
 | Status | Route |
 |--------|-------|

package/commands/ms/help.md

@@ -22,24 +22,25 @@ Output ONLY the reference content below. Do NOT add:
 ## Start Here
 
 - If you already have `.planning/` in this repo: run `/ms:progress`.
-- If you’re starting in an existing codebase (brownfield): run `/ms:map-codebase`, then `/ms:new-project`.
 - Otherwise: run `/ms:new-project`.
 
 ## Quick Start
 
 ### Greenfield (new project)
 
-1. `/ms:new-project` - Initialize project with brief
-2. `/ms:research-project` - (optional) Research domain ecosystem
-3. `/ms:create-roadmap` - Define requirements and create roadmap
-4. `/ms:plan-phase 1` - Create detailed plan for first phase
-5. `/ms:execute-phase 1` - Execute with parallel agents
+1. `/ms:new-project` — Initialize project with brief
+2. `/ms:config` — (optional) Configure code reviewers and gitignore
+3. `/ms:research-project` — (optional) Research domain ecosystem
+4. `/ms:create-roadmap` — Define requirements and create roadmap
+5. `/ms:plan-phase 1` — Create detailed plan for first phase
+6. `/ms:execute-phase 1` — Execute with parallel agents
 
 ### Brownfield (existing codebase)
 
-1. `/ms:map-codebase` - Analyze existing code first
-2. `/ms:new-project` - Questions focus on what you’re adding/changing
-3. Continue with steps 2-5 above (codebase docs load automatically)
+1. `/ms:new-project` — Questions focus on business context and vision
+2. `/ms:map-codebase` — Analyze existing code
+3. `/ms:config` — (optional) Configure code reviewers and gitignore
+4. Continue with research/roadmap/plan/execute
 
 ## Staying Updated
 
@@ -62,8 +63,8 @@ Initialize → (Optional Research) → Roadmap → Plan → Execute → Verify
 ```
 
 Common deviations:
-- Existing repo: `/ms:map-codebase` before `/ms:new-project`
-- Plan looks wrong: `/ms:list-phase-assumptions <phase>` or `/ms:check-phase <phase>`
+- Existing repo: `/ms:map-codebase` after `/ms:new-project` (or before — either works)
+- Plan looks wrong: `/ms:discuss-phase <phase>` or `/ms:check-phase <phase>`
 - Unknown domain: `/ms:research-project` or `/ms:research-phase <phase>`
 - Phase prep: `/ms:discuss-phase` → `/ms:design-phase` → `/ms:research-phase` → `/ms:plan-phase` (all optional before plan)
 - Execution gaps: `/ms:plan-phase <phase> --gaps` then `/ms:execute-phase <phase>`
@@ -82,6 +83,16 @@ Initialize new project with brief and configuration.
 
 Usage: `/ms:new-project`
 
+**`/ms:config`**
+Configure Mindsystem preferences — code reviewers, gitignore patterns, git remote.
+
+- Use when: you want to set up code review agents, manage which .planning/ artifacts are git-ignored, or push your repo to GitHub.
+- Edits `.planning/config.json` and `.gitignore`
+- Suggests code reviewers based on tech stack (needs PROJECT.md)
+- Idempotent — run anytime to reconfigure
+
+Usage: `/ms:config`
+
 **`/ms:research-project`**
 Research domain ecosystem before creating roadmap.
 
@@ -111,18 +122,20 @@ Map an existing codebase for brownfield projects.
 - Analyzes codebase with parallel Explore agents
 - Creates `.planning/codebase/` with 7 focused documents
 - Covers stack, architecture, structure, conventions, testing, integrations, concerns
-- Use before `/ms:new-project` on existing codebases
+- Use on existing codebases (before or after `/ms:new-project`)
 
 Usage: `/ms:map-codebase`
 
 ### Phase Planning
 
 **`/ms:discuss-phase <number>`**
-Help articulate your vision for a phase before planning.
+Product-informed collaborative thinking before planning.
 
-- Captures how you imagine this phase working
-- Creates CONTEXT.md with your vision, essentials, and boundaries
-- Use when you have ideas about how something should look/feel
+- Loads milestone artifacts (PROJECT.md, REQUIREMENTS.md) for product context
+- Surfaces Claude's assumptions and validates before deep questioning
+- Offers competitor/UX research for user-facing phases
+- Grounds every question in target audience, industry patterns, and tradeoffs
+- Creates CONTEXT.md with your vision, essentials, and reasoning-backed decisions
 
 Usage: `/ms:discuss-phase 2`
 
@@ -160,15 +173,6 @@ Comprehensive ecosystem research for niche/complex domains.
 
 Usage: `/ms:research-phase 3`
 
-**`/ms:list-phase-assumptions <number>`**
-See what Claude is planning to do before it starts.
-
-- Shows Claude's intended approach for a phase
-- Lets you course-correct if Claude misunderstood your vision
-- No files created - conversational output only
-
-Usage: `/ms:list-phase-assumptions 3`
-
 **`/ms:plan-phase [number] [--gaps]`**
 Create detailed execution plan for a specific phase.
 
@@ -221,7 +225,7 @@ User acceptance testing of phase or plan.
 
 Usage: `/ms:verify-work 5`
 
-**`/ms:audit-milestone [version]`**
+**`/ms:audit-milestone [name]`**
 Audit milestone completion against original intent.
 
 - Use when: you think you’re “done” and want cross-phase integration + requirements coverage checked before archiving.
@@ -230,7 +234,7 @@ Audit milestone completion against original intent.
 - Maintains TECH-DEBT.md as single source of truth for debt items
 - Creates MILESTONE-AUDIT.md with gaps and tech debt
 
-Usage: `/ms:audit-milestone 1.0.0`
+Usage: `/ms:audit-milestone`
 
 ### Roadmap Management
 
@@ -280,18 +284,19 @@ Discover what to build next and start a new milestone.
 - Routes to create-roadmap or research-project
 
 Usage: `/ms:new-milestone`
-Usage: `/ms:new-milestone "v2.0 Features"`
+Usage: `/ms:new-milestone "Push Notifications"`
 
-**`/ms:complete-milestone <version>`**
-Archive completed milestone and prepare for next version.
+**`/ms:complete-milestone [name]`**
+Archive completed milestone and prepare for next.
 
 - Creates MILESTONES.md entry with stats
 - Extracts curated learnings for future milestone planning
 - Archives full details to milestones/ directory
-- Creates git tag for the release
-- Prepares workspace for next version
+- Prepares workspace for next milestone
+- Auto-detects current milestone from PROJECT.md if no argument provided
 
-Usage: `/ms:complete-milestone 1.0.0`
+Usage: `/ms:complete-milestone`
+Usage: `/ms:complete-milestone "MVP"`
 
 **`/ms:plan-milestone-gaps`**
 Create phases to close gaps identified by milestone audit.
@@ -443,6 +448,7 @@ Usage: `/ms:release-notes`
 
 ```
 /ms:new-project                 # Extract your idea through questions
+/ms:config                      # (optional) Configure code reviewers and gitignore
 /ms:research-project            # (recommended) Research domain ecosystem
 /ms:create-roadmap              # Define requirements and create phases
 /ms:plan-phase 1                # Create detailed plan
@@ -452,8 +458,9 @@ Usage: `/ms:release-notes`
 **Starting with existing code (brownfield):**
 
 ```
-/ms:map-codebase                # Step 1: Analyze existing code
-/ms:new-project                 # Step 2: Questions focus on what you're adding/changing
+/ms:new-project                 # Step 1: Questions focus on business context and vision
+/ms:map-codebase                # Step 2: Analyze existing code
+/ms:config                      # (optional) Configure code reviewers and gitignore
 /ms:research-project            # (optional) Research new domain areas
 /ms:create-roadmap              # Define requirements and create roadmap
 /ms:plan-phase 1                # Codebase docs load automatically
@@ -517,19 +524,19 @@ Common options:
 **Completing a milestone:**
 
 ```
-/ms:audit-milestone 1.0.0       # Verify before completing
-/ms:complete-milestone 1.0.0    # Archive and tag
+/ms:audit-milestone             # Verify before completing
+/ms:complete-milestone          # Archive milestone
 /ms:new-milestone               # Discover and start next milestone
 ```
 
 **Closing gaps from audit:**
 
 ```
-/ms:audit-milestone 1.0.0       # Finds gaps
+/ms:audit-milestone             # Finds gaps
 /ms:plan-milestone-gaps         # Creates phases to fix them
 /ms:plan-phase 6                # Plan first gap closure phase
 /ms:execute-phase 6
-/ms:audit-milestone 1.0.0       # Re-audit when done
+/ms:audit-milestone             # Re-audit when done
 ```
 
 **Capturing ideas during work:**

package/commands/ms/insert-phase.md

@@ -133,13 +133,36 @@ Confirm: "Created directory: $phase_dir"
 Insert the new phase entry into the roadmap:
 
 1. Find insertion point: immediately after Phase {after_phase}'s content (before next phase heading or "---")
-2. Insert new phase heading with (INSERTED) marker:
+
+2. Before writing the phase entry, analyze the description to determine pre-work flags:
+
+   **Discuss**: Default Likely — enumerate 2-4 assumptions or open questions specific
+   to the phase. Unlikely only for fully mechanical zero-decision work (version bump,
+   rename-only refactor, config-only change, pure deletion/cleanup).
+
+   **Design**: Likely when description involves UI work, visual elements, forms,
+   dashboards, or multi-screen flows. Unlikely for backend-only, API, infrastructure,
+   or established UI patterns.
+
+   **Research**: Likely when description mentions external APIs/services, new
+   libraries/frameworks, or unclear technical approach. Unlikely for established
+   internal patterns or well-documented conventions.
+
+   Use binary Likely/Unlikely with parenthetical reason. Include topics/focus only when Likely.
+
+3. Insert new phase heading with (INSERTED) marker and pre-work flags:
 
    ```
    ### Phase {decimal_phase}: {Description} (INSERTED)
 
    **Goal:** [Urgent work - to be planned]
    **Depends on:** Phase {after_phase}
+   **Discuss**: {Likely (reason) | Unlikely (reason)}
+   **Discuss topics**: {topics} ← only if Likely
+   **Design**: {Likely (reason) | Unlikely (reason)}
+   **Design focus**: {focus} ← only if Likely
+   **Research**: {Likely (reason) | Unlikely (reason)}
+   **Research topics**: {topics} ← only if Likely
    **Plans:** 0 plans
 
    Plans:
@@ -149,7 +172,7 @@ Insert the new phase entry into the roadmap:
    [To be added during planning]
    ```
 
-3. Write updated roadmap back to file
+4. Write updated roadmap back to file
 
 The "(INSERTED)" marker helps identify decimal phases as urgent insertions.
 
@@ -183,24 +206,13 @@ Phase {decimal_phase} inserted after Phase {after_phase}:
 Roadmap updated: {roadmap-path}
 Project state updated: .planning/STATE.md
 
----
-
-## ▶ Next Up
-
-**Phase {decimal_phase}: {description}** — urgent insertion
-
-`/ms:plan-phase {decimal_phase}`
-
-<sub>`/clear` first → fresh context window</sub>
+```
 
----
+Read `~/.claude/mindsystem/references/routing/next-phase-routing.md` and follow its instructions
+to present "Next Up" with pre-work context for Phase {decimal_phase}.
 
-**Also available:**
+After the "Next Up" section, add:
 - Review insertion impact: Check if Phase {next_integer} dependencies still make sense
-- Review roadmap
-
----
-```
 </step>
 
 <step name="update_last_command">