mindsystem-cc 4.0.0 → 4.0.2

package/agents/ms-debugger.md

@@ -12,7 +12,6 @@ You are a Mindsystem debugger. You investigate bugs using systematic scientific
 You are spawned by:
 
 - `/ms:debug` command (interactive debugging)
-- `diagnose-issues` workflow (parallel UAT diagnosis)
 
 Your job: Find the root cause through hypothesis testing, maintain debug file state, optionally fix and verify (depending on mode).
 
@@ -94,7 +93,7 @@ ls .planning/debug/*.md 2>/dev/null | grep -v resolved
 2. `mkdir -p .planning/debug`
 3. Read project context for frontmatter:
    ```bash
-   jq -r '.subsystems[]' .planning/config.json 2>/dev/null
+   ms-tools config-get subsystems
    grep "^Phase:" .planning/STATE.md 2>/dev/null | head -1
    ```
 4. Create file with initial state including all 10 frontmatter fields:
@@ -368,7 +367,7 @@ Check for mode flags in prompt context:
 - Diagnose but don't fix
 - Stop after confirming root cause
 - Skip fix_and_verify step
-- Return root cause to caller (for plan-phase --gaps to handle)
+- Return root cause to caller
 
 **goal: find_and_fix** (default)
 - Find root cause, then fix and verify

package/agents/ms-verifier.md

@@ -257,7 +257,7 @@ score = (verified_truths / total_truths)
 
 ## Step 9: Structure Gap Output (If Gaps Found)
 
-When gaps are found, structure them in YAML frontmatter for consumption by `/ms:plan-phase --gaps`. Use the `gaps:` format shown in the VERIFICATION.md template below.
+When gaps are found, structure them in YAML frontmatter for gap triage. Use the `gaps:` format shown in the VERIFICATION.md template below.
 
 **Gap fields:** `truth` (observable truth that failed), `status` (failed | partial), `reason` (why it failed), `artifacts` (files with issues), `missing` (specific things to add/fix).
 
@@ -383,7 +383,7 @@ Consider `/ms:verify-work {phase}` to validate these through UAT.
 2. **{Truth 2}** — {reason}
    - Missing: {what needs to be added}
 
-Structured gaps in VERIFICATION.md frontmatter for `/ms:plan-phase --gaps`.
+Structured gaps in VERIFICATION.md frontmatter for gap triage.
 ```
 
 </output>
@@ -396,7 +396,7 @@ Structured gaps in VERIFICATION.md frontmatter for `/ms:plan-phase --gaps`.
 
 **DO NOT skip key link verification.** This is where 80% of stubs hide. The pieces exist but aren't connected.
 
-**Structure gaps in YAML frontmatter.** The planner (`/ms:plan-phase --gaps`) creates plans from your analysis.
+**Structure gaps in YAML frontmatter.** Gap triage routes gaps to the appropriate primitive based on scope analysis.
 
 **DO keep verification fast.** Use grep/file checks, not running the app. Goal is structural verification, not functional testing.
 
@@ -406,7 +406,7 @@ Structured gaps in VERIFICATION.md frontmatter for `/ms:plan-phase --gaps`.
 
 <success_criteria>
 
-- [ ] Gaps structured in YAML frontmatter (if gaps_found) — planner depends on this
+- [ ] Gaps structured in YAML frontmatter (if gaps_found) — gap triage depends on this
 - [ ] Key links verified — not just artifact existence; this is where stubs hide
 - [ ] Artifacts checked at all three levels (exists → substantive → wired)
 - [ ] SUMMARY.md claims verified against actual code, not trusted

package/bin/install.js

@@ -150,6 +150,10 @@ function isInteractive() {
  * @param {string} destPrefix - The destination prefix (e.g., 'commands/ms', 'agents')
  * @returns {Array<{relativePath: string, absolutePath: string}>}
  */
+// Directories and file patterns excluded from installation
+const EXCLUDED_DIRS = new Set(['.pytest_cache', '__pycache__', 'fixtures', 'node_modules', '.git', '.venv']);
+const EXCLUDED_FILE_PATTERNS = [/^test_/, /\.test\./, /\.spec\./];
+
 function collectFiles(baseDir, currentDir, destPrefix) {
   const files = [];
   if (!fs.existsSync(currentDir)) {
@@ -158,13 +162,17 @@ function collectFiles(baseDir, currentDir, destPrefix) {
 
   const entries = fs.readdirSync(currentDir, { withFileTypes: true });
   for (const entry of entries) {
+    if (EXCLUDED_DIRS.has(entry.name)) {
+      continue;
+    }
+
     const absolutePath = path.join(currentDir, entry.name);
     const relativeToCurrent = path.relative(baseDir, absolutePath);
     const relativePath = path.join(destPrefix, relativeToCurrent);
 
     if (entry.isDirectory()) {
       files.push(...collectFiles(baseDir, absolutePath, destPrefix));
-    } else {
+    } else if (!EXCLUDED_FILE_PATTERNS.some(p => p.test(entry.name))) {
       files.push({ relativePath, absolutePath });
     }
   }

package/commands/ms/add-todo.md

@@ -58,7 +58,7 @@ Infer priority, estimate, and subsystem from description and conversation contex
 | L | 5 | Multi-file feature, new subsystem area |
 | XL | 8 | Cross-cutting concern, architectural change |
 
-**Subsystem:** Read `jq -r '.subsystems[]' .planning/config.json 2>/dev/null`. Match against description and conversation context. Must match config.json vocabulary.
+**Subsystem:** Read `ms-tools config-get subsystems`. Match against description and conversation context. Must match config.json vocabulary.
 </step>
 
 <step name="confirm">

package/commands/ms/audit-milestone.md

@@ -191,7 +191,7 @@ Route by status (see `<offer_next>`).
 Read code review agent from config:
 
 ```bash
-CODE_REVIEW=$(cat .planning/config.json 2>/dev/null | jq -r '.code_review.milestone // empty')
+CODE_REVIEW=$(ms-tools config-get code_review.milestone)
 ```
 
 **If CODE_REVIEW = "skip":**

package/commands/ms/config.md

@@ -76,12 +76,10 @@ If "Custom": use AskUserQuestion for each tier (adhoc, phase, milestone) individ
 
 If "Skip code review": set all three values to `"skip"`.
 
-Update config.json with selected values via jq:
+Update config.json:
 
 ```bash
-jq '.code_review = {"adhoc": $a, "phase": $p, "milestone": $m}' \
-  --arg a "$ADHOC" --arg p "$PHASE" --arg m "$MILESTONE" \
-  .planning/config.json > .planning/config.tmp && mv .planning/config.tmp .planning/config.json
+ms-tools config-set code_review --json '{"adhoc": "'"$ADHOC"'", "phase": "'"$PHASE"'", "milestone": "'"$MILESTONE"'"}'
 ```
 
 </step>
@@ -119,7 +117,7 @@ If no selections: skip gitignore changes.
 Read current value:
 
 ```bash
-CURRENT=$(cat .planning/config.json 2>/dev/null | jq -r '.open_mockups // "auto"')
+CURRENT=$(ms-tools config-get open_mockups --default "auto")
 echo "Current open_mockups: $CURRENT"
 ```
 
@@ -136,10 +134,10 @@ Map selection to config value:
 - "Ask first" → `"ask"`
 - "Don't open" → `"off"`
 
-Update config.json with selected value via jq:
+Update config.json:
 
 ```bash
-jq --arg v "$VALUE" '.open_mockups = $v' .planning/config.json > .planning/config.tmp && mv .planning/config.tmp .planning/config.json
+ms-tools config-set open_mockups "$VALUE"
 ```
 
 </step>
@@ -149,7 +147,7 @@ jq --arg v "$VALUE" '.open_mockups = $v' .planning/config.json > .planning/confi
 Read current value:
 
 ```bash
-CURRENT=$(cat .planning/config.json 2>/dev/null | jq -r '.task_tracker.type // "not configured"')
+CURRENT=$(ms-tools config-get task_tracker.type --default "not configured")
 echo "Current task_tracker: $CURRENT"
 ```
 
@@ -175,13 +173,13 @@ If "Custom path": ask user for path via AskUserQuestion.
 Write to config.json:
 
 ```bash
-jq '.task_tracker = {"type": "linear", "cli": $cli}' --arg cli "$CLI_PATH" .planning/config.json > .planning/config.tmp && mv .planning/config.tmp .planning/config.json
+ms-tools config-set task_tracker --json '{"type": "linear", "cli": "'"$CLI_PATH"'"}'
 ```
 
 If "None / not yet":
 
 ```bash
-jq '.task_tracker = null' .planning/config.json > .planning/config.tmp && mv .planning/config.tmp .planning/config.json
+ms-tools config-delete task_tracker
 ```
 
 </step>

package/commands/ms/debug.md

@@ -93,7 +93,7 @@ Task(
 - Display root cause and evidence summary
 - Offer options:
   - "Fix now" — spawn ms-debugger with `goal: find_and_fix` and the debug file
-  - "Plan fix" — suggest /ms:plan-phase --gaps
+  - "Plan fix" — suggest `/ms:adhoc` for small fixes, `/ms:insert-phase` for larger scope
   - "Done" — leave the diagnosis
 
 **If `## CHECKPOINT REACHED`:**

package/commands/ms/design-phase.md

@@ -132,7 +132,7 @@ If exists, extract:
 Match subsystem(s) to this phase by comparing ROADMAP phase description against subsystem names in config.json. Load matching knowledge files:
 
 ```bash
-jq -r '.subsystems[]' .planning/config.json 2>/dev/null
+ms-tools config-get subsystems
 cat .planning/knowledge/{matched_subsystem}.md 2>/dev/null
 ```
 

package/commands/ms/execute-phase.md

@@ -75,7 +75,7 @@ ms-tools find-phase "$ARGUMENTS"
    - Creates VERIFICATION.md with detailed report
    - Route by status:
      - `passed` → continue to step 7
-     - `gaps_found` → present gaps, offer `/ms:plan-phase {X} --gaps`
+     - `gaps_found` → present gaps, route via gap-closure-routing.md triage
 
 7. **Code review (optional)**
    - Read `code_review.phase` from config.json (default: `ms-code-simplifier`)

package/commands/ms/help.md

@@ -61,13 +61,32 @@ Initialize → (Optional Research) → Roadmap → Plan → Execute → Verify
 
 Common deviations:
 - 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>`
+- Plan looks wrong: `/ms:discuss-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>`
 - New urgent work: `/ms:insert-phase <after> "<desc>"`
 - New non-urgent work: `/ms:add-todo "<desc>"`
 
+### Choosing the Right Command
+
+**"I found something that needs fixing"**
+
+| What you know | Best command | Why |
+|--------------|-------------|-----|
+| Quick fix, single context window | `/ms:adhoc` | Full pipeline (plan, execute, consolidate) in one session |
+| Blocking — must happen before next phase | `/ms:insert-phase` | Creates decimal phase (e.g., 5.1) with full plan-execute cycle |
+| Important but not urgent | `/ms:add-phase` | Appends to roadmap end, planned and executed in sequence |
+| Just capture it for later | `/ms:add-todo` | Flat-file capture with priority and estimate |
+
+**"I want to prepare before planning"**
+
+| What you need | Best command |
+|--------------|-------------|
+| Align on vision, validate assumptions | `/ms:discuss-phase` |
+| UI layouts, component specs, mockups | `/ms:design-phase` |
+| Stack research, ecosystem knowledge | `/ms:research-phase` |
+| All three (UI-heavy feature) | discuss, then design, then research, then plan |
+
 ### Project Initialization
 
 **`/ms:new-project`**
@@ -170,10 +189,10 @@ Comprehensive ecosystem research for niche/complex domains.
 
 Usage: `/ms:research-phase 3`
 
-**`/ms:plan-phase [number] [--gaps]`**
+**`/ms:plan-phase [number]`**
 Create detailed execution plan for a specific phase.
 
-- Use when: you're about to start a phase, or you need additional plans (including verifier-driven gap closure via `--gaps`).
+- Use when: you're about to start a phase.
 - Generates `.planning/phases/XX-phase-name/XX-YY-PLAN.md`
 - Breaks phase into concrete, actionable tasks
 - Includes verification criteria and success measures
@@ -202,16 +221,6 @@ Usage: `/ms:execute-phase 5`
 
 ### Verification
 
-**`/ms:check-phase <number>`**
-Verify phase plans before execution (optional quality gate).
-
-- Use when: the phase is complex or risky and you want a “will this actually achieve the goal?” sanity check before executing.
-- Spawns plan checker agent to analyze PLAN.md files
-- Checks requirement coverage, task completeness, dependencies
-- Use for complex phases before committing to execution
-
-Usage: `/ms:check-phase 5`
-
 **`/ms:verify-work [number]`**
 User acceptance testing of phase or plan.
 
@@ -479,11 +488,11 @@ Usage: `/ms:release-notes`
 
 ```
 /ms:plan-phase 5                 # Create one or more PLAN.md files
-/ms:check-phase 5                # (optional) Sanity check: plans will achieve goal
 /ms:execute-phase 5              # Execute; produces SUMMARY + VERIFICATION
-# If gaps found during verification:
-/ms:plan-phase 5 --gaps          # Create additional plans to close verifier gaps
-/ms:execute-phase 5              # Re-run until phase verifies cleanly
+# If gaps found during verification, follow triage recommendation:
+# Small gaps:    /ms:adhoc "Close phase 5 gaps: ..."
+# Larger gaps:   /ms:insert-phase 5 "Close verification gaps"
+# Minor polish:  /ms:add-todo "Phase 5 polish: ..."
 ```
 
 **Found a bug:**
@@ -493,9 +502,9 @@ Usage: `/ms:release-notes`
 # Then decide where the fix belongs:
 # - If it fits in a single context window:
 /ms:adhoc "Fix auth token refresh on 401"   # Knowledge-aware fix with consolidation
-# - If it's required to satisfy the current phase goal: add more plans to the current phase
-/ms:plan-phase 5                              # (or: /ms:plan-phase 5 --gaps after verification)
-/ms:execute-phase 5
+# - If it's required to satisfy the current phase goal:
+/ms:adhoc "Fix auth token refresh on 401"     # Small scope — single context
+/ms:insert-phase 5 "Close verification gaps"  # Larger scope — full plan-execute cycle
 # - If it's urgent but should happen before the next phase (and not worth renumbering):
 /ms:insert-phase 5 "Fix critical auth bug"     # Creates 05.1
 /ms:plan-phase 5.1
@@ -507,7 +516,7 @@ Usage: `/ms:release-notes`
 **Need to adjust scope (new info, new requirements, or a cut):**
 
 Common options:
-- If the current phase goal can’t be met: add more plans to the current phase (`/ms:plan-phase <current>` or `/ms:plan-phase <current> --gaps`) then `/ms:execute-phase <current>`
+- If the current phase goal can’t be met: `/ms:adhoc` for small gaps, `/ms:insert-phase` for larger gaps, `/ms:add-todo` for minor polish
 - Add work later: `/ms:add-phase "…"`
 - Insert urgent work before the next phase: `/ms:insert-phase <after> "…"`
 - Cut future work: `/ms:remove-phase <phase>`

package/commands/ms/plan-phase.md

@@ -1,7 +1,7 @@
 ---
 name: ms:plan-phase
 description: Create detailed execution plan for a phase (PLAN.md)
-argument-hint: "[phase] [--gaps]"
+argument-hint: "[phase]"
 allowed-tools:
   - Read
   - Bash
@@ -21,8 +21,6 @@ Create executable phase prompt with discovery, context injection, and task break
 Purpose: Break down roadmap phases into concrete, executable PLAN.md files that Claude can execute.
 Output: One or more PLAN.md files in the phase directory (.planning/phases/XX-name/{phase}-{plan}-PLAN.md)
 
-**Gap closure mode (`--gaps` flag):**
-When invoked with `--gaps`, plans address gaps identified by the verifier. Load VERIFICATION.md, create plans to close specific gaps.
 </objective>
 
 <execution_context>
@@ -32,7 +30,6 @@ When invoked with `--gaps`, plans address gaps identified by the verifier. Load
 
 <context>
 Phase number: $ARGUMENTS (optional - auto-detects next unplanned phase if not provided)
-Gap closure mode: `--gaps` flag triggers gap closure workflow
 
 **Resolve phase if provided:**
 ```bash
@@ -76,17 +73,14 @@ Check for and read `.planning/TECH-DEBT.md` — prioritized issues for scope sel
 **Load codebase context if exists:**
 Check for `.planning/codebase/` and load relevant documents based on phase type.
 
-**If --gaps flag present, also load:**
-@.planning/phases/XX-name/{phase}-VERIFICATION.md — contains structured gaps in YAML frontmatter
 </context>
 
 <process>
 1. Check .planning/ directory exists (error if not - user should run /ms:new-project)
-2. Parse arguments: extract phase number and check for `--gaps` flag
+2. Parse arguments: extract phase number
 3. If phase number provided, validate it exists in roadmap
 4. If no phase number, detect next unplanned phase from roadmap
 
-**Standard mode (no --gaps flag):**
 5. Follow plan-phase.md workflow:
    - Load project state and accumulated decisions
    - Perform mandatory discovery (Level 0-3 as appropriate)
@@ -97,17 +91,9 @@ Check for `.planning/codebase/` and load relevant documents based on phase type.
    - Hand off tasks + proposed grouping + confirmed skills to plan-writer subagent
    - Create PLAN.md file(s) with executable structure
 
-**Gap closure mode (--gaps flag):**
-5. Follow plan-phase.md workflow with gap_closure_mode:
-   - Load VERIFICATION.md and parse `gaps:` YAML from frontmatter
-   - Read existing SUMMARYs to understand what's already built
-   - Create tasks from gaps (each gap.missing item → task candidates)
-   - Number plans sequentially after existing (if 01-03 exist, create 04, 05...)
-   - Create PLAN.md file(s) focused on closing specific gaps
-
 6. **Update last command:** `ms-tools set-last-command "ms:plan-phase $ARGUMENTS"`
 
-7. **Risk assessment** (skip if `--gaps` flag present)
+7. **Risk assessment**
    - Calculate risk score from context already loaded (task count, plan count, external services, CONTEXT.md, cross-cutting concerns, new deps, complex domains)
    - Present score + top factors via AskUserQuestion
    - Tier-based recommendation: Skip (0-39), Optional (40-69), Verify (70+)

package/commands/ms/progress.md

@@ -155,23 +155,27 @@ ms-tools list-artifacts [current-phase-number]
 
 State: "This phase has {X} plans, {Y} summaries."
 
-**Step 1.5: Check for unaddressed UAT gaps**
+**Step 1.5: Check for unaddressed gaps**
 
-Check for UAT.md files with status "diagnosed" (has gaps needing fixes).
+Check for VERIFICATION.md with gaps or UAT.md with diagnosed gaps.
 
 ```bash
+# Check for verification gaps
+grep -l "status: gaps_found" .planning/phases/[current-phase-dir]/*-VERIFICATION.md 2>/dev/null
+
 # Check for diagnosed UAT with gaps
 grep -l "status: diagnosed" .planning/phases/[current-phase-dir]/*-UAT.md 2>/dev/null
 ```
 
 Track:
+- `verification_gaps`: VERIFICATION.md files with status "gaps_found"
 - `uat_with_gaps`: UAT.md files with status "diagnosed" (gaps need fixing)
 
 **Step 2: Route based on counts**
 
 | Condition | Meaning | Action |
 |-----------|---------|--------|
-| uat_with_gaps > 0 | UAT gaps need fix plans | Go to **Route E** |
+| verification_gaps > 0 OR uat_with_gaps > 0 | Gaps need resolution | Go to **Route E** |
 | summaries < plans | Unexecuted plans exist | Go to **Route A** |
 | summaries = plans AND plans > 0 | Phase complete | Go to Step 3 |
 | plans = 0 | Phase not yet planned | Go to **Route B** |
@@ -246,9 +250,9 @@ Check if `{phase}-CONTEXT.md` exists in phase directory.
 
 ---
 
-**Route E: UAT gaps need fix plans**
+**Route E: Verification or UAT gaps need resolution**
 
-UAT.md exists with gaps (diagnosed issues). Read `~/.claude/mindsystem/references/routing/gap-closure-routing.md` and follow its instructions to present the gap closure section.
+VERIFICATION.md or UAT.md exists with gaps. Read `~/.claude/mindsystem/references/routing/gap-closure-routing.md` and follow its triage instructions to present gap summary and route to the appropriate primitive.
 
 ---
 

package/commands/ms/research-phase.md

@@ -69,7 +69,7 @@ cat .planning/phases/${PHASE}-*/${PHASE}-DESIGN.md 2>/dev/null
 grep -A30 "### Decisions Made" .planning/STATE.md 2>/dev/null
 
 # Prior knowledge — match subsystem(s) by comparing phase description against config.json names
-jq -r '.subsystems[]' .planning/config.json 2>/dev/null
+ms-tools config-get subsystems
 cat .planning/knowledge/{matched_subsystem}.md 2>/dev/null
 ```
 

package/mindsystem/references/continuation-format.md

@@ -33,7 +33,7 @@ When there's meaningful additional context (like a phase identifier), add it as
 ## Format Rules
 
 1. **Command is the anchor** — backtick command + description on one line, no separate bold label restating the command name
-2. **Phase identifiers are additive context** — `**Phase 2: Auth**` carries info the command doesn't; bold labels like `**Plan gap closure**` just restate `/ms:plan-phase --gaps` and should be omitted
+2. **Phase identifiers are additive context** — `**Phase 2: Auth**` carries info the command doesn't; bold labels that just restate the command name should be omitted
 3. **Pull context from source** — ROADMAP.md for phases, PLAN.md `<objective>` for plans
 4. **Command in inline code** — backticks, easy to copy-paste, renders as clickable link
 5. **`/clear` explanation** — always include, keeps it concise but explains why

package/mindsystem/references/plan-format.md

@@ -195,7 +195,7 @@ Execution order lives in a single `EXECUTION-ORDER.md` file alongside the plans.
 |----------|--------|
 | How does the verifier find must-haves? | Reads `## Must-Haves` section |
 | How does the executor know the subsystem? | Reads inline metadata (`**Subsystem:**`) |
-| How does the plan-checker validate plans? | Reads EXECUTION-ORDER.md + plan structure |
+| How is plan verification done? | Reads EXECUTION-ORDER.md + plan structure |
 | What triggers TDD lazy-loading? | `**Type:** tdd` in inline metadata |
 | How does the executor know why an approach was chosen? | Reads `## Context` section |
 | How does the executor find existing utilities? | Reads `**Files:**` lines and inline references in `## Changes` |

package/mindsystem/references/plan-risk-assessment.md

@@ -2,14 +2,13 @@
 Optional verification step for plan-phase workflow. Calculates risk score from already-loaded context and prompts user to verify or skip.
 
 <purpose>
-Provide lightweight risk assessment after plan creation to help users decide whether to run the ms-plan-checker before execution.
+Provide lightweight risk assessment after plan creation to help users decide whether to run plan verification before execution.
 
 **Key principle:** All information is already in context from earlier workflow steps. No additional file reads or subagent spawns needed for scoring.
 </purpose>
 
 <skip_conditions>
 Skip risk assessment entirely when:
-- `--gaps` flag present (gap closure plans don't need risk assessment)
 - Zero plans created (error state)
 </skip_conditions>
 

package/mindsystem/references/routing/gap-closure-routing.md

@@ -1,10 +1,10 @@
 # Gap Closure Routing
 
-Reference for presenting "Next Up" guidance when phase verification found gaps. Used by execute-phase and progress commands.
+Reference for triaging verification and UAT gaps by scope and routing to the appropriate primitive. Used by execute-phase and progress commands.
 
 ## Purpose
 
-Guide user toward planning gap closure when VERIFICATION.md reports gaps.
+Analyze VERIFICATION.md or UAT.md gaps and recommend the best primitive based on scope and urgency.
 
 ## Variables
 
@@ -14,22 +14,42 @@ From calling context:
 - `{N}/{M}` — must-haves score from VERIFICATION.md
 - `{phase_dir}` — phase directory path
 - `{phase}` — phase identifier (e.g., "04")
-- `{gap_summaries}` — extracted gap summaries from VERIFICATION.md
 
 ## Information to Extract
 
-Read VERIFICATION.md for the phase:
+Read the gap source for the phase (one or both may exist):
 
 ```bash
-cat .planning/phases/${phase_dir}/${phase}-VERIFICATION.md
+# Code verification gaps
+cat .planning/phases/${phase_dir}/${phase}-VERIFICATION.md 2>/dev/null
+
+# User testing gaps (status: diagnosed means root causes identified)
+cat .planning/phases/${phase_dir}/${phase}-UAT.md 2>/dev/null
 ```
 
-Extract:
-- Score (must-haves verified count)
+Extract from whichever exists (combine if both present):
+- Score (must-haves verified count, from VERIFICATION.md)
+- Gap count and severity (critical vs non-critical)
 - Gap summaries from gaps section
 
+## Triage Table
+
+| Scope | Criteria | Route | Rationale |
+|-------|----------|-------|-----------|
+| Small | 1-2 gaps, localized files, quick fixes | `/ms:adhoc` | Single context window, no multi-plan overhead |
+| Larger (blocking) | 3+ gaps OR cross-cutting, blocks next phase | `/ms:insert-phase` | Needs full plan-execute cycle, preserves phase numbering |
+| Larger (non-blocking) | 3+ gaps OR cross-cutting, next phase can proceed | `/ms:add-phase` | Defers to end of milestone, no urgency |
+| Minor | Cosmetic, non-functional, polish items | `/ms:add-todo` | Capture for later, not worth planning now |
+
+**Judgment calls:**
+- If all gaps share the same root cause, treat as small regardless of count
+- If gaps span multiple subsystems, prefer insert-phase even if count is low
+- Mix routes when gaps vary: adhoc for quick wins + insert-phase for larger items
+
 ## Output Format
 
+Present gap summary, then route recommendation using standard "Next Up" format:
+
 ```markdown
 ---
 
@@ -46,7 +66,21 @@ Extract:
 
 ## ▶ Next Up
 
-`/ms:plan-phase {Z} --gaps` — create additional plans to complete the phase
+{Primary recommendation based on triage:}
+
+{If adhoc:}
+`/ms:adhoc "Close phase {Z} gaps: {brief description}"` — fix {N} localized gaps in a single context
+
+<sub>Reference: `.planning/phases/{phase_dir}/{phase}-VERIFICATION.md`</sub>
+
+{If insert-phase:}
+`/ms:insert-phase {Z} "Close verification gaps"` — plan and execute gap closure as phase {Z}.1
+
+{If add-phase:}
+`/ms:add-phase "Close phase {Z} verification gaps"` — defer gap closure to end of milestone
+
+{If add-todo:}
+`/ms:add-todo "Phase {Z} polish: {brief description}"` — capture for later
 
 <sub>`/clear` first → fresh context window</sub>
 
@@ -54,16 +88,8 @@ Extract:
 
 **Also available:**
 - `cat .planning/phases/{phase_dir}/{phase}-VERIFICATION.md` — see full report
-- `/ms:verify-work {Z}` — manual testing before planning
+- `/ms:verify-work {Z}` — manual testing before fixing
+{Include other routes not chosen as alternatives}
 
 ---
 ```
-
-## Gap Closure Flow
-
-After user runs `/ms:plan-phase {Z} --gaps`:
-1. Planner reads VERIFICATION.md gaps
-2. Creates plans 04, 05, etc. to close gaps
-3. User runs `/ms:execute-phase {Z}` again
-4. Execute-phase runs incomplete plans (04, 05...)
-5. Verifier runs again — loop until passed

package/mindsystem/templates/debug-subagent-prompt.md

@@ -60,11 +60,6 @@ Task(
 )
 ```
 
-**From diagnose-issues (UAT):**
-```python
-Task(prompt=template, subagent_type="ms-debugger", description="Debug UAT-001")
-```
-
 ---
 
 ## Continuation

package/mindsystem/workflows/adhoc.md

@@ -38,8 +38,8 @@ Read STATE.md for project context (current phase, accumulated decisions, blocker
 **Ticket detection:** Check `task_tracker` in config.json. If configured and `$ARGUMENTS` matches the ticket ID pattern, lazy-load `~/.claude/mindsystem/references/{type}-cli.md` and follow its **Ticket Detection** process. If no tracker configured or no match, proceed with `$ARGUMENTS` as free-text.
 
 ```bash
-TRACKER_TYPE=$(jq -r '.task_tracker.type // empty' .planning/config.json 2>/dev/null)
-TRACKER_CLI=$(jq -r '.task_tracker.cli // empty' .planning/config.json 2>/dev/null)
+TRACKER_TYPE=$(ms-tools config-get task_tracker.type)
+TRACKER_CLI=$(ms-tools config-get task_tracker.cli)
 ```
 
 **Todo detection:** If `$ARGUMENTS` matches a `.planning/todos/*.md` file path and the file exists, lazy-load `~/.claude/mindsystem/references/todo-file.md` and follow its **Todo Detection** process. Todo detection is independent of ticket detection — both can be inactive.
@@ -50,7 +50,7 @@ Read subsystems and match knowledge files to work description:
 
 ```bash
 # Read subsystems from config
-jq -r '.subsystems[]' .planning/config.json 2>/dev/null
+ms-tools config-get subsystems
 ```
 
 Match keywords from work description against subsystem names. Read matching `.planning/knowledge/*.md` files (1-3 most relevant).
@@ -152,7 +152,8 @@ The executor reads the plan, executes tasks with atomic commits, creates SUMMARY
 Read code review agent from config:
 
 ```bash
-CODE_REVIEW=$(cat .planning/config.json 2>/dev/null | jq -r '.code_review.adhoc // .code_review.phase // empty')
+CODE_REVIEW=$(ms-tools config-get code_review.adhoc)
+[ -z "$CODE_REVIEW" ] && CODE_REVIEW=$(ms-tools config-get code_review.phase)
 ```
 
 **If CODE_REVIEW = "skip":** Skip to generate_patch.

package/mindsystem/workflows/compound.md

@@ -55,7 +55,7 @@ Thoroughness: "medium".
 Read config.json subsystems and match changes:
 
 ```bash
-jq -r '.subsystems[]' .planning/config.json 2>/dev/null
+ms-tools config-get subsystems
 ```
 
 **Git/file mode:** Match file paths from diff stats against subsystem names via keyword matching.
@@ -94,7 +94,7 @@ Agent reads changes, reads affected knowledge files, writes updates, returns rep
 **Update config.json** (if new subsystems were confirmed in step 4):
 ```bash
 # Add new subsystem to config.json
-jq '.subsystems += ["new-subsystem"]' .planning/config.json > tmp.$$.json && mv tmp.$$.json .planning/config.json
+ms-tools config-set subsystems --append "new-subsystem"
 ```
 
 **Commit changes:**

package/mindsystem/workflows/discuss-phase.md

@@ -57,7 +57,7 @@ Load milestone artifacts and prior knowledge. Handle gracefully when any file is
 cat .planning/PROJECT.md 2>/dev/null
 cat .planning/MILESTONE-CONTEXT.md 2>/dev/null
 cat .planning/REQUIREMENTS.md 2>/dev/null
-jq -r '.subsystems[]' .planning/config.json 2>/dev/null
+ms-tools config-get subsystems
 grep -A20 "Phase ${PHASE}:" .planning/ROADMAP.md
 ```