mindsystem-cc 3.14.0 → 3.16.1

package/mindsystem/workflows/complete-milestone.md

@@ -22,16 +22,16 @@ This is the ritual that separates "development" from "shipped."
 
 When a milestone completes, this workflow:
 
-1. Consolidates phase decisions into `.planning/milestones/v[X.Y]-DECISIONS.md`
-2. Cleans up phase artifacts (PLAN, CONTEXT, RESEARCH, DESIGN files deleted)
-3. Extracts full milestone details to `.planning/milestones/v[X.Y]-ROADMAP.md`
-4. Archives requirements to `.planning/milestones/v[X.Y]-REQUIREMENTS.md`
-5. Archives milestone context to `.planning/milestones/v[X.Y]-CONTEXT.md`
-6. Updates ROADMAP.md to replace milestone details with one-line summary
-7. Deletes REQUIREMENTS.md (fresh one created for next milestone)
-8. Extracts learnings into `.planning/LEARNINGS.md` (curated one-line patterns with source refs)
-9. Performs full PROJECT.md evolution review
-10. Routes to `/ms:new-milestone` for next milestone
+1. Cleans up raw phase artifacts (CONTEXT, DESIGN, RESEARCH, SUMMARY, UAT, VERIFICATION, EXECUTION-ORDER deleted)
+2. Extracts full milestone details to `.planning/milestones/v[X.Y]-ROADMAP.md`
+3. Archives requirements to `.planning/milestones/v[X.Y]-REQUIREMENTS.md`
+4. Archives milestone context to `.planning/milestones/v[X.Y]-CONTEXT.md`
+5. Updates ROADMAP.md to replace milestone details with one-line summary
+6. Deletes REQUIREMENTS.md (fresh one created for next milestone)
+7. Performs full PROJECT.md evolution review
+8. Routes to `/ms:new-milestone` for next milestone
+
+Knowledge files in `.planning/knowledge/` persist across milestones (maintained by phase-level consolidation in execute-phase).
 
 **Context Efficiency:**
 
@@ -102,136 +102,25 @@ cat .planning/config.json 2>/dev/null
 Proceeding to stats gathering...
 ```
 
-Proceed directly to consolidate_decisions step.
+Proceed directly to cleanup_artifacts step.
 
 </step>
 
-<step name="consolidate_decisions">
-
-Consolidate phase decisions before archiving.
-
-**Spawn ms-consolidator agent:**
-
-```
-Task(
-  prompt="Consolidate decisions from milestone v[X.Y] [Name].
-
-Phase range: [PHASE_START]-[PHASE_END]
-Phase directories:
-- .planning/phases/01-foundation
-- .planning/phases/02-auth
-- [etc. for all phases in milestone]
-
-Extract decisions from PLAN, CONTEXT, RESEARCH, DESIGN files.
-Create v[X.Y]-DECISIONS.md in .planning/milestones/.
-Delete source files (preserve SUMMARY, VERIFICATION, UAT).",
-  subagent_type="ms-consolidator"
-)
-```
-
-**Wait for completion and verify:**
-
-```bash
-ls .planning/milestones/v[X.Y]-DECISIONS.md
-```
-
-**Present consolidation summary:**
-
-```
-✓ Decisions consolidated: [N] decisions in [M] categories
-✓ Source files cleaned: PLAN, CONTEXT, RESEARCH, DESIGN deleted
-✓ Preserved: SUMMARY, VERIFICATION, UAT files
-
-Report: .planning/milestones/v[X.Y]-DECISIONS.md
-```
-
-Continue to extract_learnings step.
-
-</step>
-
-<step name="extract_learnings">
-
-Extract reusable patterns from milestone artifacts into `.planning/LEARNINGS.md`.
-
-**Runs in main context** (not subagent) — curation requires judgment.
-
-**Reference:** `~/.claude/mindsystem/templates/learnings.md`
-
-**1. Scan source artifacts:**
+<step name="cleanup_artifacts">
 
-All sources are PRESERVED by ms-consolidator (only PLAN, CONTEXT, RESEARCH, DESIGN are deleted).
+Delete remaining raw artifacts from phase directories. Knowledge files are already current from phase-level consolidation in execute-phase — no consolidation or learnings extraction needed.
 
 ```bash
-# Debug resolutions — parse frontmatter for root_cause, resolution, subsystem, prevention
-ls .planning/debug/resolved/*.md 2>/dev/null
+~/.claude/mindsystem/scripts/cleanup-phase-artifacts.sh $PHASE_START $PHASE_END
 ```
 
-```bash
-# Adhoc summaries — parse frontmatter for learnings array, subsystem
-ls .planning/adhoc/*-SUMMARY.md 2>/dev/null
-```
+Knowledge files in `.planning/knowledge/` persist (they ARE the milestone's knowledge output).
 
-```bash
-# Phase summaries in milestone range — read Deviations/Issues sections, parse subsystem
-ls .planning/phases/{PHASE_START}*/{PHASE_START}*-SUMMARY.md .planning/phases/{PHASE_END}*/{PHASE_END}*-SUMMARY.md 2>/dev/null
-# (expand to all phases in milestone range)
-```
+**Present cleanup summary:**
 
-```bash
-# Completed todos — scan for reusable patterns (lower priority)
-ls .planning/todos/done/*.md 2>/dev/null
 ```
-
-For each source found, read frontmatter and relevant sections. Extract candidate learnings.
-
-**2. Curate entries:**
-
-- Select 4-8 entries max from candidates
-- Exclude: decisions (belong in DECISIONS.md), trivial fixes, one-time issues
-- Prefer prevention framing: "Always validate X before Y" over "We found a bug in X"
-- Deduplicate: if two sources surface the same pattern, keep the more prescriptive version
-
-**3. Group by subsystem:**
-
-```bash
-jq -r '.subsystems[]' .planning/config.json 2>/dev/null
-```
-
-Group entries under subsystem headings from config.json vocabulary.
-
-**4. Write to LEARNINGS.md:**
-
-Format per entry:
-```
-- **{Brief title}**: {Prescriptive action} → `{source_ref}`
-```
-
-If `.planning/LEARNINGS.md` does not exist (first milestone):
-- Create file with header from template
-- Add milestone section
-
-If `.planning/LEARNINGS.md` exists (subsequent milestone):
-- Prepend new milestone section after header (reverse chronological)
-- Update "Last updated" footer
-
-**5. Handle "no learnings" gracefully:**
-
-If no meaningful patterns found across all sources:
-- Do NOT create or modify LEARNINGS.md
-- Present informational message:
-  ```
-  ℹ No reusable learnings found for v[X.Y]
-    Sources scanned: [N] debug docs, [N] adhoc summaries, [N] phase summaries, [N] completed todos
-    Skipping LEARNINGS.md update
-  ```
-
-**6. Present summary:**
-
-```
-✓ Learnings extracted: [N] entries across [M] subsystems
-  - [subsystem1]: [count] entries
-  - [subsystem2]: [count] entries
-  Written to: .planning/LEARNINGS.md
+Raw artifacts cleaned from phase directories
+Knowledge files persist in .planning/knowledge/
 ```
 
 Continue to gather_stats step.
@@ -757,21 +646,17 @@ Commit milestone completion including archive files and deletions.
 
 ```bash
 # Stage archive files (new)
-git add .planning/milestones/v[X.Y]-DECISIONS.md
 git add .planning/milestones/v[X.Y]-ROADMAP.md
 git add .planning/milestones/v[X.Y]-REQUIREMENTS.md
 git add .planning/milestones/v[X.Y]-MILESTONE-AUDIT.md 2>/dev/null || true
 git add .planning/milestones/v[X.Y]-CONTEXT.md 2>/dev/null || true
 
-# Stage learnings (may not exist if no learnings found)
-git add .planning/LEARNINGS.md 2>/dev/null || true
-
 # Stage updated files
 git add .planning/MILESTONES.md
 git add .planning/PROJECT.md
 git add .planning/STATE.md
 
-# Stage deletions
+# Stage deletions (raw artifacts cleaned from phase directories)
 git add -u .planning/
 
 # Commit with descriptive message
@@ -779,13 +664,13 @@ git commit -m "$(cat <<'EOF'
 chore: complete v[X.Y] milestone
 
 Archived:
-- milestones/v[X.Y]-DECISIONS.md (consolidated decisions)
 - milestones/v[X.Y]-ROADMAP.md
 - milestones/v[X.Y]-REQUIREMENTS.md
 - milestones/v[X.Y]-MILESTONE-AUDIT.md (if audit was run)
 
 Cleaned:
-- Phase PLAN, CONTEXT, RESEARCH, DESIGN files (consolidated into DECISIONS.md)
+- Raw phase artifacts (CONTEXT, DESIGN, RESEARCH, SUMMARY, UAT, VERIFICATION, EXECUTION-ORDER)
+- Knowledge files persist in .planning/knowledge/
 
 Deleted (fresh for next milestone):
 - ROADMAP.md
@@ -795,7 +680,6 @@ Updated:
 - MILESTONES.md (new entry)
 - PROJECT.md (requirements → Validated)
 - STATE.md (reset for next milestone)
-- LEARNINGS.md (curated patterns, if any found)
 
 Tagged: v[X.Y]
 EOF
@@ -886,9 +770,8 @@ If yes → milestone. If no → keep working.
 
 Milestone completion is successful when:
 
-- [ ] Decisions consolidated (milestones/v[X.Y]-DECISIONS.md created)
-- [ ] Phase artifacts cleaned (PLAN, CONTEXT, RESEARCH, DESIGN deleted)
-- [ ] Learnings extracted to .planning/LEARNINGS.md (or gracefully skipped if none found)
+- [ ] Raw artifacts cleaned from phase directories (CONTEXT, DESIGN, RESEARCH, SUMMARY, UAT, VERIFICATION, EXECUTION-ORDER)
+- [ ] Knowledge files persist in .planning/knowledge/
 - [ ] MILESTONES.md entry created with stats and accomplishments
 - [ ] PROJECT.md full evolution review completed
 - [ ] All shipped requirements moved to Validated in PROJECT.md

package/mindsystem/workflows/define-requirements.md

@@ -4,8 +4,6 @@ Define concrete, checkable requirements for v1.
 Two modes:
 1. **With research** — Transform FEATURES.md into scoped requirements
 2. **Without research** — Gather requirements through questioning
-
-This is the bridge between "what's possible/wanted" and "what we're committing to."
 </purpose>
 
 <required_reading>
@@ -318,13 +316,11 @@ Requirements defined:
 </quality_criteria>
 
 <success_criteria>
-- [ ] PROJECT.md core value extracted
-- [ ] Features gathered (from research OR conversation)
-- [ ] All categories presented to user
-- [ ] User scoped each category (v1/v2/out of scope)
-- [ ] User had opportunity to add requirements
 - [ ] Core value alignment validated
+- [ ] User had opportunity to add requirements
+- [ ] User scoped each category (v1/v2/out of scope)
+- [ ] All categories presented to user
 - [ ] REQUIREMENTS.md created with REQ-IDs
 - [ ] v1, v2, and out of scope clearly separated
-- [ ] Requirements committed to git
+- [ ] Features gathered (from research OR conversation)
 </success_criteria>

package/mindsystem/workflows/discuss-phase.md

@@ -30,11 +30,7 @@ Phase number: $ARGUMENTS (required)
 Validate phase exists in roadmap:
 
 ```bash
-if [ -f .planning/ROADMAP.md ]; then
-  cat .planning/ROADMAP.md | grep "Phase ${PHASE}:"
-else
-  cat .planning/ROADMAP.md | grep "Phase ${PHASE}:"
-fi
+grep "Phase ${PHASE}:" .planning/ROADMAP.md
 ```
 
 **If phase not found:**
@@ -55,6 +51,29 @@ Parse phase details from roadmap:
 - Phase description
 - Status (should be "Not started" or "In progress")
 
+Continue to load_prior_knowledge.
+</step>
+
+<step name="load_prior_knowledge">
+Determine which subsystem(s) this phase touches from ROADMAP.md phase description + config.json:
+
+```bash
+jq -r '.subsystems[]' .planning/config.json 2>/dev/null
+grep -A20 "Phase ${PHASE}:" .planning/ROADMAP.md
+```
+
+Load matching `knowledge/{subsystem}.md` files:
+
+```bash
+cat .planning/knowledge/{subsystem}.md 2>/dev/null
+```
+
+Handle gracefully when `.planning/knowledge/` doesn't exist (first milestone, no phases executed yet).
+
+**If knowledge exists:** Present a brief "What we know so far" summary to the user before questioning — prior decisions, architectural patterns, and pitfalls relevant to this phase. This grounds the discussion without interrogating.
+
+**If no knowledge files exist:** Skip silently (normal for first phase).
+
 Continue to check_existing.
 </step>
 
@@ -239,10 +258,8 @@ Confirm: "Committed: docs(${PHASE}): capture phase context"
 
 <success_criteria>
 
-- Phase validated against roadmap
 - Vision gathered through collaborative thinking (not interrogation)
 - User's imagination captured: how it works, what's essential
-- CONTEXT.md created in phase directory
-- CONTEXT.md committed to git
 - User knows next steps (typically: research or plan the phase)
+- CONTEXT.md committed to git
 </success_criteria>

package/mindsystem/workflows/execute-phase.md

@@ -441,6 +441,38 @@ fi
 - Discard: `rm {patch_file}`
 </step>
 
+<step name="consolidate_knowledge">
+Consolidate phase knowledge into per-subsystem knowledge files.
+
+**Spawn ms-consolidator:**
+
+```
+Task(
+  prompt="Consolidate knowledge from phase {phase_number}.
+  Phase directory: {phase_dir}
+  Phase number: {phase_number}
+  Read SUMMARY.md files for affected subsystems, then read phase artifacts
+  and existing knowledge files. Produce updated knowledge files and delete
+  PLAN.md files.",
+  subagent_type="ms-consolidator"
+)
+```
+
+**Verify consolidation:**
+
+```bash
+ls .planning/knowledge/*.md 2>/dev/null
+```
+
+Report the consolidation summary returned by ms-consolidator.
+
+**Handle failure:** If consolidation fails, ask user:
+- "Continue without consolidation" → proceed to update_roadmap
+- "Stop execution" → exit with partial completion report
+
+Knowledge consolidation is not a blocking gate — phase execution succeeded regardless.
+</step>
+
 <step name="update_roadmap">
 Update ROADMAP.md to reflect phase completion:
 
@@ -453,6 +485,8 @@ Update ROADMAP.md to reflect phase completion:
 Commit phase completion (roadmap, state, verification):
 ```bash
 git add .planning/ROADMAP.md .planning/STATE.md .planning/phases/{phase_dir}/*-VERIFICATION.md .planning/phases/{phase_dir}/*-SUMMARY.md
+git add .planning/knowledge/*.md
+git add -u .planning/phases/{phase_dir}/*-PLAN.md
 git add .planning/REQUIREMENTS.md  # if updated
 git commit -m "docs(phase-{X}): complete phase execution"
 ```

package/mindsystem/workflows/execute-plan.md

@@ -43,6 +43,14 @@ Parse plan sections:
 **If `**Type:** tdd`:** Read `~/.claude/mindsystem/references/tdd-execution.md` for RED-GREEN-REFACTOR execution flow.
 </step>
 
+<step name="load_skills">
+Scan the skill list in your system message for skills matching the plan's technology or domain. Invoke each match via the Skill tool before proceeding — skills contain project-specific conventions and patterns that change what you produce during implementation.
+
+- One clear match → invoke it directly
+- Multiple candidates → use AskUserQuestion to let the user choose
+- No match → proceed without
+</step>
+
 <step name="execute">
 Record start time: `PLAN_START_TIME=$(date -u +"%Y-%m-%dT%H:%M:%SZ"); PLAN_START_EPOCH=$(date +%s)`
 

package/mindsystem/workflows/plan-phase.md

@@ -263,135 +263,74 @@ For niche domains (3D, games, audio, shaders, ML), suggest `/ms:research-phase`
 </step>
 
 <step name="read_project_history">
-**Intelligent context assembly from frontmatter dependency graph:**
+**Intelligent context assembly via scanner script + selective reading:**
 
-**1. Scan all summary frontmatter (cheap - first ~25 lines):**
+**1. Determine scanner arguments** from prior steps:
+
+- Phase number from identify_phase step
+- Subsystem from `.planning/config.json` if available
+- Phase name from ROADMAP.md phase description
 
 ```bash
-for f in .planning/phases/*/*-SUMMARY.md; do
-  # Extract frontmatter only (between first two --- markers)
-  sed -n '1,/^---$/p; /^---$/q' "$f" | head -30
-done
+SUBSYSTEM=$(jq -r '.subsystems[0] // empty' .planning/config.json 2>/dev/null)
+PHASE_NAME=$(grep -A2 "Phase ${PHASE}:" .planning/ROADMAP.md 2>/dev/null | head -1 | sed 's/.*Phase [0-9]*: *//')
 ```
 
-Parse YAML to extract: phase, subsystem, requires, provides, affects, tags, key-decisions, key-files
-
-**2. Build dependency graph for current phase:**
-
-- **Check affects field:** Which prior phases have current phase in their `affects` list? → Direct dependencies
-- **Check subsystem:** Which prior phases share same subsystem? → Related work
-- **Check requires chains:** If phase X requires phase Y, and we need X, we also need Y → Transitive dependencies
-- **Check roadmap:** Any phases marked as dependencies in ROADMAP.md phase description?
-
-**3. Select relevant summaries:**
-
-Auto-select phases that match ANY of:
-- Current phase name/number appears in prior phase's `affects` field
-- Same `subsystem` value
-- In `requires` chain (transitive closure)
-- Explicitly mentioned in STATE.md decisions as affecting current phase
+**2. Run context scanner:**
 
-Typical selection: 2-4 prior phases (immediately prior + related subsystem work)
-
-**4. Extract context from frontmatter (WITHOUT opening full summaries yet):**
+```bash
+uv run ~/.claude/mindsystem/scripts/scan-planning-context.py \
+  --phase "${PHASE}" \
+  --phase-name "${PHASE_NAME}" \
+  ${SUBSYSTEM:+--subsystem "${SUBSYSTEM}"}
+```
 
-From selected phases' frontmatter, extract:
-- **Tech available:** Union of all tech-stack.added lists
-- **Patterns established:** Union of all tech-stack.patterns and patterns-established
-- **Key files:** Union of all key-files (for @context references)
-- **Decisions:** Extract key-decisions from frontmatter
+**3. Parse JSON output.** Check `success` field. If the script fails or returns non-JSON, fall back to manual scanning (read SUMMARY frontmatter with sed as before). The scanner handles missing directories gracefully — check `sources.*.skipped` for skip reasons.
 
-**4b. Present established patterns to user:**
+**4. Present established patterns to user:**
 
-If patterns-established entries were collected, display:
+From `aggregated.patterns_established`, display:
 
 ```
 ### Established Patterns to Maintain
 - [Pattern: description] (from phase XX)
 ```
 
-If no patterns collected, skip.
+If empty, skip.
 
-**5. Now read FULL summaries for selected phases:**
+**5. Conditionally read full summaries.**
 
-Only now open and read complete SUMMARY.md files for the selected relevant phases. Extract:
-- Detailed "Accomplishments" section
-- "Next Phase Readiness" warnings/blockers
-- "Issues Encountered" that might affect current phase
-- "Deviations from Plan" for patterns
+Read full SUMMARY.md body ONLY for summaries where:
+- `relevance` is HIGH AND `has_readiness_warnings` is true
+- OR frontmatter alone doesn't provide enough context for task breakdown (use judgment)
 
-**6. Search additional knowledge sources (cross-cutting retrieval):**
+Extract from full reads: "Next Phase Readiness" warnings, "Issues Encountered", detailed accomplishments.
 
-Use keywords already extracted: phase name, subsystem (from config.json), tags/tech terms from selected summaries.
+Summaries scored MEDIUM or HIGH without readiness warnings → frontmatter data in JSON is sufficient (tech stack, patterns, key files, decisions already aggregated).
 
-**6a. Resolved debug docs:**
+**6. Present matched learnings:**
 
-```bash
-for f in .planning/debug/resolved/*.md; do
-  sed -n '1,/^---$/p; /^---$/q' "$f" | head -20
-done 2>/dev/null
-```
-
-Select docs matching: same `subsystem`, overlapping `tags`, or `phase` in dependency chain.
-Extract: `root_cause` + `resolution` one-liners from frontmatter.
-
-**If matched debug docs found, present warning to user:**
+**From `debug_learnings`** — present as warnings:
 
 ```
 ### Previous Debug Sessions in This Area
 - **{slug}** ({subsystem}): {root_cause} — Fix: {resolution}
 ```
 
-Awareness only — learnings still flow to `<learnings>` handoff.
-If no matches, skip.
-
-**6b. Adhoc summaries:**
+**From `adhoc_learnings`** — extract entries with non-empty `learnings` arrays for handoff context.
 
-```bash
-for f in .planning/adhoc/*-SUMMARY.md; do
-  sed -n '1,/^---$/p; /^---$/q' "$f" | head -20
-done 2>/dev/null
-```
+If neither source has matches, skip.
 
-Select matching: same `subsystem`, overlapping `tags`, or `related_phase` in dependency chain.
-Extract: `learnings` array entries (skip if empty).
+**7. Read knowledge files:**
 
-**6c. Completed todos:**
+For each entry in `knowledge_files` where `matched` is true, read the full file. Knowledge files are prose (no frontmatter) so the LLM must read them to extract decisions, architecture, pitfalls.
 
-```bash
-ls .planning/todos/done/*.md 2>/dev/null
-```
+**8. Assess pending todos:**
 
-If exists, grep body content for phase keywords or subsystem. Extract brief description of resolved items.
-
-**6d. Milestone decisions:**
-
-```bash
-ls .planning/milestones/v*-DECISIONS.md 2>/dev/null
-```
-
-If exists, grep for entries matching current subsystem or phase keywords. Extract matched decision rows.
-
-**6e. LEARNINGS.md (cross-milestone index):**
-
-```bash
-cat .planning/LEARNINGS.md 2>/dev/null
-```
-
-If exists, grep for entries matching phase keywords, subsystem, or tech terms. Extract matched one-liner entries with source references.
-
-**Collect matched learnings for handoff** — assemble into flat list for `<learnings>` section.
+From `pending_todos` frontmatter in JSON, assess each todo's relevance. Read full body only for todos matching current phase subsystem/tags.
 
 **From STATE.md:** Decisions → constrain approach. Pending todos → candidates. Blockers → may need to address.
 
-**From pending todos:**
-
-```bash
-ls .planning/todos/pending/*.md 2>/dev/null
-```
-
-Assess each pending todo - relevant to this phase? Natural to address now?
-
 **Answer before proceeding:**
 - Q1: What decisions from previous phases constrain this phase?
 - Q2: Are there pending todos that should become tasks?
@@ -400,13 +339,13 @@ Assess each pending todo - relevant to this phase? Natural to address now?
 
 **Track for handoff to ms-plan-writer:**
 - Which summaries were selected (for @context references)
-- Tech stack available (from frontmatter)
-- Established patterns (from frontmatter)
-- Key files to reference (from frontmatter)
-- Applicable decisions (from frontmatter + full summary)
+- Tech stack available (from `aggregated.tech_stack_added`)
+- Established patterns (from `aggregated.patterns_established`)
+- Key files to reference (from `aggregated.key_files_created` + `key_files_modified`)
+- Applicable decisions (from `aggregated.key_decisions` + full summary reads)
 - Todos being addressed (from pending todos)
-- Concerns being verified (from "Next Phase Readiness")
-- Matched learnings (from debug docs, adhoc summaries, patterns, decisions, LEARNINGS.md)
+- Concerns being verified (from "Next Phase Readiness" in full reads)
+- Matched learnings (from `debug_learnings`, `adhoc_learnings`, patterns, knowledge files)
 </step>
 
 <step name="gather_phase_context">
@@ -563,8 +502,7 @@ Assemble handoff payload:
   <learning type="debug" source=".planning/debug/resolved/{slug}.md">{root_cause} — fix: {resolution}</learning>
   <learning type="adhoc" source=".planning/adhoc/{file}.md">{learnings entry}</learning>
   <learning type="pattern" source=".planning/phases/{path}">{patterns-established entry}</learning>
-  <learning type="decision" source=".planning/milestones/{file}">{decision}: {rationale}</learning>
-  <learning type="curated" source="{source_ref from LEARNINGS.md}">{one-liner pattern}</learning>
+  <learning type="knowledge" source=".planning/knowledge/{subsystem}.md">{decisions, architecture, pitfalls from knowledge files}</learning>
 </learnings>
 ```
 
@@ -573,7 +511,6 @@ Assemble handoff payload:
 ```
 Task(
   subagent_type: "ms-plan-writer"
-  model: "sonnet"
   description: "Write PLAN.md files for phase {PHASE}"
   prompt: "{assembled handoff payload}"
 )
@@ -664,7 +601,6 @@ Spawn ms-plan-checker:
 ```
 Task(
   subagent_type: "ms-plan-checker"
-  model: "sonnet"
   description: "Verify phase ${PHASE} plans"
   prompt: """
 Verify plans for phase ${PHASE}.

package/mindsystem/workflows/verify-work.md

@@ -602,6 +602,26 @@ git add ".planning/phases/XX-name/{phase}-UAT.md"
 git commit -m "test({phase}): complete UAT - {passed} passed, {fixed} fixed, {skipped} assumptions"
 ```
 
+**5.5. Update knowledge pitfalls (lightweight):**
+
+```bash
+# Check for significant findings
+grep -c "severity: blocker\|severity: major" "$PHASE_DIR/${PHASE}-UAT.md" 2>/dev/null
+```
+
+If significant issues (blocker/major) were found AND fixed:
+1. Determine affected subsystem(s) from the UAT.md test descriptions and config.json
+2. Read relevant `knowledge/{subsystem}.md` files
+3. Append new pitfall entries to the Pitfalls section (do not rewrite entire file — just append)
+4. Commit knowledge file updates:
+```bash
+git add .planning/knowledge/*.md && git commit -m "docs: update pitfalls from UAT findings"
+```
+
+If no significant findings or no fixes: skip silently.
+
+This is NOT a full re-consolidation. Read only UAT.md and add specific pitfall entries.
+
 **6. Present summary:**
 ```
 ## UAT Complete: Phase {phase}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindsystem-cc",
-  "version": "3.14.0",
+  "version": "3.16.1",
   "description": "A meta-prompting, context engineering and spec-driven development system for Claude Code by TÂCHES.",
   "bin": {
     "mindsystem-cc": "bin/install.js"