@massu/core 0.5.0 → 0.6.0

package/commands/massu-infra-audit.md

@@ -0,0 +1,187 @@
+---
+name: massu-infra-audit
+description: "When user asks about .claude/ infrastructure health, says 'audit infra', 'check claude setup', or needs to verify references, staleness, and format compliance"
+allowed-tools: Bash(*), Read(*), Grep(*), Glob(*)
+---
+name: massu-infra-audit
+
+# Massu Infrastructure Audit: .claude/ Directory Health Check
+
+## Objective
+
+Verify the health of the `.claude/` directory infrastructure: dead references, staleness, conflicts, format consistency, and memory health. Designed for periodic execution to catch drift before it causes problems.
+
+---
+
+## AUDIT PHASES (8 Checks)
+
+| Phase | Check | Pass Criteria |
+|-------|-------|---------------|
+| 1 | **Dead References in CLAUDE.md** | All file paths referenced in CLAUDE.md exist |
+| 2 | **Script References** | All scripts referenced by commands/patterns exist |
+| 3 | **Command Format Consistency** | All commands have valid YAML frontmatter (name, description, allowed-tools) |
+| 4 | **Cross-Reference Integrity** | Commands reference patterns that exist; patterns reference files that exist |
+| 5 | **Line Count Accuracy** | Line counts in CLAUDE.md Load Instructions match actual file line counts |
+| 6 | **Memory Health** | MEMORY.md under 200-line limit; topic files organized |
+| 7 | **Archive Bloat** | Session state archive size and count assessment |
+| 8 | **Orphan Detection** | Files in .claude/ not referenced from CLAUDE.md or any command |
+
+---
+
+## EXECUTION PROTOCOL
+
+### Phase 1: Dead References in CLAUDE.md
+
+```bash
+# Extract all relative file paths from CLAUDE.md and verify each exists
+grep -oE '\[.*?\]\((protocols|patterns|commands|incidents|reference|session-state)/[^)]+\)' .claude/CLAUDE.md \
+  | grep -oE '(protocols|patterns|commands|incidents|reference|session-state)/[^)]+' \
+  | sort -u \
+  | while read path; do
+      [ -f ".claude/$path" ] && echo "OK: $path" || echo "MISSING: $path"
+    done
+```
+
+**FAIL** if any path is MISSING.
+
+### Phase 2: Script References
+
+```bash
+# Find all script references across .claude/ files
+grep -roh 'scripts/[a-zA-Z0-9_-]*\.\(sh\|ts\)' .claude/ | sort -u | while read script; do
+  [ -f "$script" ] && echo "OK: $script" || echo "MISSING: $script"
+done
+```
+
+**FAIL** if any script is MISSING.
+
+### Phase 3: Command Format Consistency
+
+```bash
+# For each command file, verify YAML frontmatter has required fields
+for f in .claude/commands/massu-*.md; do
+  name=$(basename "$f" .md)
+  has_name=$(head -10 "$f" | grep -c "^name:")
+  has_desc=$(head -10 "$f" | grep -c "^description:")
+  has_tools=$(head -10 "$f" | grep -c "^allowed-tools:")
+  if [ "$has_name" -eq 0 ] || [ "$has_desc" -eq 0 ] || [ "$has_tools" -eq 0 ]; then
+    echo "INVALID: $name (name:$has_name desc:$has_desc tools:$has_tools)"
+  else
+    echo "OK: $name"
+  fi
+done
+```
+
+**FAIL** if any command has missing required fields.
+
+### Phase 4: Cross-Reference Integrity
+
+```bash
+# Find pattern/protocol references in commands and verify they exist
+grep -roh 'patterns/[a-zA-Z0-9_-]*\.md\|protocols/[a-zA-Z0-9_-]*\.md' .claude/commands/ \
+  | sort -u \
+  | while read ref; do
+      [ -f ".claude/$ref" ] && echo "OK: $ref" || echo "BROKEN: $ref"
+    done
+```
+
+**FAIL** if any cross-reference is BROKEN.
+
+### Phase 5: Line Count Accuracy
+
+Read CLAUDE.md Load Instructions table. For each entry with a line count:
+
+```bash
+# Compare claimed vs actual line counts
+# Flag if delta > 20 lines (significant drift)
+wc -l .claude/patterns/*.md .claude/protocols/*.md .claude/reference/*.md 2>/dev/null
+```
+
+Compare to claimed counts in CLAUDE.md. **WARN** if any delta > 20 lines.
+
+### Phase 6: Memory Health
+
+```bash
+# Check memory directory
+MEMORY_DIR="$HOME/.claude/projects/$(pwd | tr '/' '-')/memory"
+echo "=== Memory Files ==="
+ls -la "$MEMORY_DIR/"
+echo "=== MEMORY.md line count ==="
+wc -l "$MEMORY_DIR/MEMORY.md"
+echo "=== Total memory size ==="
+du -sh "$MEMORY_DIR/"
+```
+
+**WARN** if MEMORY.md exceeds 180 lines (approaching 200 limit).
+
+### Phase 7: Archive Bloat Assessment
+
+```bash
+echo "=== Archive Stats ==="
+echo "File count: $(ls .claude/session-state/archive/ | wc -l)"
+echo "Total size: $(du -sh .claude/session-state/archive/)"
+echo "=== Age distribution ==="
+echo "Last 7 days: $(find .claude/session-state/archive/ -mtime -7 | wc -l)"
+echo "7-30 days: $(find .claude/session-state/archive/ -mtime +7 -mtime -30 | wc -l)"
+echo "30+ days: $(find .claude/session-state/archive/ -mtime +30 | wc -l)"
+```
+
+**INFO** only — no pass/fail, but flag if > 500 files or > 5MB.
+
+### Phase 8: Orphan Detection
+
+```bash
+# List all non-archive .claude/ files
+# For each, check if referenced from CLAUDE.md or any command
+find .claude/ -name "*.md" -not -path "*/archive/*" -not -path "*/session-state/*" | while read f; do
+  basename=$(basename "$f")
+  refs=$(grep -rl "$basename" .claude/CLAUDE.md .claude/commands/ .claude/patterns/ .claude/protocols/ 2>/dev/null | wc -l)
+  if [ "$refs" -eq 0 ]; then
+    echo "ORPHAN?: $f (0 incoming references)"
+  fi
+done
+```
+
+**INFO** only — orphans may be intentional (specialized tools).
+
+---
+
+## OUTPUT FORMAT
+
+```markdown
+## Massu Infrastructure Audit Report
+Date: YYYY-MM-DD
+
+### Results Summary
+| Phase | Check | Status | Details |
+|-------|-------|--------|---------|
+| 1 | Dead References | PASS/FAIL | [count] issues |
+| 2 | Script References | PASS/FAIL | [count] issues |
+| 3 | Command Format | PASS/FAIL | [count] issues |
+| 4 | Cross-References | PASS/FAIL | [count] issues |
+| 5 | Line Counts | PASS/WARN | [count] stale |
+| 6 | Memory Health | PASS/WARN | [lines] / 200 limit |
+| 7 | Archive Bloat | INFO | [count] files, [size] |
+| 8 | Orphan Detection | INFO | [count] potential orphans |
+
+### Overall: PASS / WARN / FAIL
+[Summary of action items if any]
+```
+
+---
+
+## PASS CRITERIA
+
+- **PASS**: Phases 1-4 all pass, Phase 6 under limits
+- **WARN**: Phases 5, 7, 8 have non-critical findings
+- **FAIL**: Any of Phases 1-4 have failures (broken references, missing files, invalid format)
+
+---
+
+## WHEN TO RUN
+
+- After editing CLAUDE.md or any command file
+- After adding/removing pattern or protocol files
+- After memory cleanup or reorganization
+- Weekly as part of `/massu-codebase-audit`
+- After any `.claude/` directory restructuring

package/commands/massu-learning-audit.md

@@ -0,0 +1,211 @@
+---
+name: massu-learning-audit
+description: "When user says 'learning audit', 'check auto-learning', 'memory coverage', or needs to validate that incidents are being learned from and patterns are being captured"
+allowed-tools: Bash(*), Read(*), Grep(*), Glob(*), ToolSearch(mcp__massu-codegraph__*)
+disable-model-invocation: true
+---
+name: massu-learning-audit
+
+# Massu Learning Audit: Auto-Learning Effectiveness Validation
+
+## Objective
+
+Validate that the CR-34 auto-learning protocol is working effectively by checking:
+1. Memory coverage for each canonical rule (CR)
+2. Pattern scanner coverage for each documented incident
+3. Failure recurrence rates
+4. Session quality statistics
+
+**CR-34**: ALL fixes MUST be auto-learned: ingest to memory, record pattern, update scanner.
+
+**Philosophy**: Every incident that recurs is evidence that auto-learning failed. This audit proves the learning system is working.
+
+---
+
+## NON-NEGOTIABLE RULES
+
+- **Proof > Claims** - Show MCP tool output, not summaries
+- **Every CR must have memory** - CRs without entries = learning gaps
+- **Every incident must have scanner rule** - Incidents without grep checks recur
+- **Zero tolerance for recurrence** - Any recurrence_count > 1 is a learning failure
+- **FIX ALL ISSUES ENCOUNTERED (CR-9)** - If any learning gap is discovered, fix it immediately by ingesting the missing memory and adding the missing scanner rule.
+
+---
+
+## Section 1: Memory Coverage Check
+
+**For each canonical rule (CR-1 through CR-12), verify memory entries exist.**
+
+### 1.1 Query Memory by CR
+
+Use `mcp__massu-codegraph__massu_memory_search` for each major CR category:
+
+```
+massu_memory_search query="CR-9 fix all issues"
+massu_memory_search query="CR-29 config map fallback"
+massu_memory_search query="CR-30 feature parity rebuild"
+massu_memory_search query="CR-33 RLS audit"
+massu_memory_search query="CR-34 auto-learning"
+massu_memory_search query="CR-12 compaction authorized command"
+massu_memory_search query="include: ignored"
+massu_memory_search query="ctx.prisma wrong"
+massu_memory_search query="user_profiles not users"
+```
+
+### 1.2 Memory Coverage Report
+
+| CR | Rule Summary | Memory Entries Found | Status |
+|----|-------------|---------------------|--------|
+| CR-1 | Verify don't claim | Query required | - |
+| CR-2 | Never assume schema | Query required | - |
+| CR-9 | Fix all issues | Query required | - |
+| CR-29 | Config map fallback | Query required | - |
+| CR-30 | Feature parity | Query required | - |
+| CR-33 | RLS audit | Query required | - |
+| CR-12 | No compaction escalation | Query required | - |
+
+**Expected**: Every critical CR has >= 1 memory entry.
+
+---
+
+## Section 2: Pattern Scanner Coverage
+
+**For each documented incident, verify the pattern scanner catches the bad pattern.**
+
+### 2.1 Scan for Incident Patterns
+
+```bash
+# Verify pattern-scanner.sh exists and is executable
+ls -la scripts/pattern-scanner.sh
+
+# Run pattern scanner
+scripts/pattern-scanner.sh
+```
+
+### 2.2 Verify Key Patterns Are Checked
+
+```bash
+# Incident #1: ctx.prisma usage
+grep -c "ctx\.prisma" scripts/pattern-scanner.sh
+
+# Incident #2: include: statements
+grep -c "include:" scripts/pattern-scanner.sh
+
+# Incident #5: wrong column names
+grep -c "bad-columns\|check-bad-columns" scripts/pattern-scanner.sh
+
+# Incident #10: import type from heavy deps
+grep -c "import-chains\|check-import" scripts/pattern-scanner.sh
+```
+
+### 2.3 Scanner Coverage Report
+
+| Incident | Pattern | Scanner Check Exists | Rule |
+|----------|---------|---------------------|------|
+| #1 Dec 18 | Unverified "complete" claims | N/A (behavioral) | - |
+| #2 Dec 21 | ctx.prisma | grep check | - |
+| #5 Jan 20 | Wrong column names | check-bad-columns.sh | - |
+| #10 Jan 25 | import type from heavy deps | check-import-chains.sh | - |
+| #20 Feb 8 | CONFIG_MAP no fallback | grep check | - |
+
+**Expected**: All grep-able patterns have scanner checks.
+
+---
+
+## Section 3: Failure Recurrence Analysis
+
+**Check if any known failures have recurred.**
+
+### 3.1 Query Memory for Recurrences
+
+Use `mcp__massu-codegraph__massu_memory_failures`:
+```
+massu_memory_failures
+```
+
+Look for entries with `recurrence_count > 1`.
+
+### 3.2 Timeline Analysis
+
+Use `mcp__massu-codegraph__massu_memory_timeline`:
+```
+massu_memory_timeline days=30
+```
+
+Check for patterns appearing more than once in the timeline.
+
+### 3.3 Recurrence Report
+
+| Pattern | First Occurrence | Recurrence Count | Status |
+|---------|-----------------|------------------|--------|
+| Query required | - | - | - |
+
+**Expected**: recurrence_count == 1 for all patterns (no recurrences).
+
+---
+
+## Section 4: Session Quality Statistics
+
+### 4.1 Query Session Stats
+
+Use `mcp__massu-codegraph__massu_session_stats`:
+```
+massu_session_stats
+```
+
+### 4.2 Prompt Effectiveness
+
+Use `mcp__massu-codegraph__massu_prompt_effectiveness`:
+```
+massu_prompt_effectiveness
+```
+
+### 4.3 Session Quality Report
+
+| Metric | Value | Target | Status |
+|--------|-------|--------|--------|
+| Average gaps per session | Query required | < 5 | - |
+| Recurrence rate | Query required | 0% | - |
+| Auto-learning compliance | Query required | 100% | - |
+
+---
+
+## Section 5: Gap Report
+
+**Identify and remediate learning gaps.**
+
+### 5.1 CRs Without Memory Entries
+
+List all CRs from Section 1 with 0 memory entries.
+
+### 5.2 Incidents Without Scanner Rules
+
+List all incidents from Section 2 with no scanner check.
+
+### 5.3 Remediation Steps
+
+For each gap found:
+
+**Missing Memory Entry**: Use `mcp__massu-codegraph__massu_memory_ingest`:
+```
+massu_memory_ingest type="pattern" description="[CR summary]" importance=3
+```
+
+**Missing Scanner Rule**: Add to `scripts/pattern-scanner.sh`:
+```bash
+# Add grep check for the bad pattern
+grep -rn "[bad_pattern]" src/ && echo "VIOLATION: [description]" && exit 1
+```
+
+---
+
+## Completion Criteria
+
+- [ ] All CRs have >= 1 memory entry
+- [ ] All grep-able incident patterns have scanner checks
+- [ ] recurrence_count == 1 for all patterns (no recurrences found)
+- [ ] Session stats reviewed, quality >= target
+- [ ] All gaps remediated
+- [ ] pattern-scanner.sh exits 0
+
+**Remember: Auto-learning is not optional. Every incident that recurs proves CR-34 failed.**

package/commands/massu-loop/references/auto-learning.md

@@ -0,0 +1,49 @@
+# Auto-Learning Protocol
+
+> Reference doc for `/massu-loop`. Return to main file for overview.
+
+## POST-BUILD REFLECTION + MANDATORY MEMORY PERSIST (CR-38)
+
+After verification passes with zero gaps, capture accumulated implementation knowledge before it's lost to context compression. Answer these questions:
+
+1. **"Now that I've built this, what would I have done differently?"**
+   - Architectural choices that caused friction
+   - Patterns that were harder to work with than expected
+   - Code that works but feels fragile or overly complex
+
+2. **"What should be refactored before moving on?"**
+   - Concrete suggestions with file paths and line numbers
+   - Technical debt introduced during this implementation
+   - Opportunities to simplify or consolidate
+
+3. **"Did we over-build? Is there a simpler way?"**
+   - Identify any added complexity that wasn't strictly needed
+   - Flag scope expansion beyond the original plan
+   - Check if any "fix everything encountered" items could have been simpler
+
+4. **"Would a staff engineer approve this?" (Principle #19)**
+
+**MANDATORY Actions** (reflection + memory write = ONE atomic action):
+1. Apply any low-risk refactors immediately (re-run build/type check after)
+2. **IMMEDIATELY write ALL learnings to memory/ files** -- failed approaches, new patterns, tool gotchas, architectural insights. DO NOT just output reflections as text. Every insight MUST be persisted to `memory/MEMORY.md` or a topic file using the Write/Edit tool.
+3. Log remaining suggestions in the plan document under `## Post-Build Reflection`
+
+**WARNING**: Outputting reflections without writing them to memory files is a CR-38 violation. The reflection and the memory write are inseparable.
+
+---
+
+## AUTO-LEARNING PROTOCOL (MANDATORY after every loop completion)
+
+After Loop Completes (Zero Gaps):
+
+- **Persist Phase 2.1 reflections**: EVERY insight from Post-Build Reflection MUST be written to `memory/MEMORY.md` or a topic file -- failed approaches, tool gotchas, unexpected behavior, "what I'd do differently". This is NOT optional. If Phase 2.1 produced reflections that aren't in memory files, this protocol is INCOMPLETE.
+- **Ingest fixes into massu memory**: `massu_memory_ingest` with type "bugfix"/"pattern", description "[Wrong] -> [Fixed]", files, importance (5=security, 3=build, 2=cosmetic)
+- **Record failed approaches**: `massu_memory_ingest` with type "failed_attempt", importance 5
+- **Update MEMORY.md**: Add wrong vs correct patterns, tool behaviors, config gotchas
+- **Update pattern scanner**: Add new grep-able bad patterns to `scripts/pattern-scanner.sh`
+- **Codebase-wide search**: Verify no other instances of same bad pattern (CR-9)
+- **Consider new CR rule**: If a class of bug was found (not one-off), propose for CLAUDE.md
+- **Record user corrections**: If the user corrected any behavior during this loop, add structured entry to `memory/corrections.md` with date, wrong behavior, correction, and prevention rule
+
+**A loop that fixes 5 bugs but records 0 learnings is 80% wasted. The fixes are temporary; the learnings are permanent.**
+**A reflection that isn't persisted to memory is a learning that will be lost. Text output is not persistence.**

package/commands/massu-loop/references/checkpoint-audit.md

@@ -0,0 +1,40 @@
+# Checkpoint Audit Protocol
+
+> Reference doc for `/massu-loop`. Return to main file for overview.
+
+## CHECKPOINT AUDIT (Phase Boundaries)
+
+```
+CHECKPOINT AUDIT FLOW:
+[1] READ plan section for this checkpoint
+[2] QUERY database to verify tables/columns/policies/grants (all envs)
+[3] GREP router files to verify procedures exist
+[4] LS component files to verify they exist
+[5] VR-RENDER: Verify UI components are RENDERED in pages (not just created)
+[6] VR-COUPLING: Run ./scripts/check-coupling.sh (backend features exposed in UI)
+[7] GREP for pattern violations (P-001 through P-008)
+[8] RUN build verification (npm run build)
+[9] RUN type verification (npx tsc --noEmit)
+[10] RUN lint verification (npm run lint)
+[11] RUN prisma validate (npx prisma validate)
+[12] RUN tests (npm test) - MANDATORY, NOT optional
+[13] RUN UI/UX verification (if UI changes)
+[14] RUN API/router verification (if API changes)
+[15] RUN security check (secrets staged)
+[16] COUNT gaps found
+[17] IF gaps > 0: FIX each gap, return to Step 1
+[18] IF gaps = 0: UPDATE session state
+[19] IF gaps = 0: Create checkpoint sign-off
+```
+
+---
+
+## PROGRESS DOCUMENTATION
+
+At the end of each phase, create archive: `session-state/archive/[plan-name]/phase-[X]-complete.md` with documentation, commit hash, files touched. Maintain `INDEX.md` for overall progress.
+
+---
+
+## PATTERN LIBRARY UPDATES
+
+After implementation, document genuinely NEW patterns in `patterns/*.md`. Only add if the pattern is new (not reuse of existing). Include Problem, Solution, File reference, Code example, When to Use.

package/commands/massu-loop/references/guardrails.md

@@ -0,0 +1,17 @@
+# The 10 Accountability Safeguards
+
+> Reference doc for `/massu-loop`. Return to main file for overview.
+
+## THE 10 ACCOUNTABILITY SAFEGUARDS
+
+1. **Audit Proof Requirement** - Every claim MUST include proof output. Claims without proof are INVALID.
+2. **Explicit Gap Count Per Loop** - State gaps found, gap details, status (PASS/FAIL). "Looks good" is BANNED.
+3. **Checkpoint Sign-Off Format** - Use exact format from COMPLETION OUTPUT section (see [vr-plan-spec.md](vr-plan-spec.md)).
+4. **Session State Mandatory Updates** - Update `session-state/CURRENT.md` after EVERY change with proof.
+5. **User Verification Rights** - User can request proof re-runs at any time. Comply with actual output.
+6. **Post-Compaction Recovery** - Read session state FIRST, re-read plan, resume from exact point.
+7. **No Claims Without Evidence** - "I verified...", "Build passed..." require accompanying proof output.
+8. **Failure Acknowledgment** - Acknowledge failures, re-execute audit from Step 1, log in session state.
+9. **User Flow Audit Required** - ALL buttons, links, callbacks, flows verified AFTER technical audits pass.
+10. **Component Reuse Verification** - Check existing components before creating new ones.
+11. **No Workarounds Allowed** - ctx.prisma, TODOs, ts-ignore are BLOCKING violations. Pattern scanner is a HARD GATE.

package/commands/massu-loop/references/iteration-structure.md

@@ -0,0 +1,115 @@
+# Iteration Structure
+
+> Reference doc for `/massu-loop`. Return to main file for overview.
+
+## ITERATION STRUCTURE
+
+```
+ITERATION N:
+  1. [EXECUTE] Perform task segment
+  2. [GUARDRAIL] Run pattern-scanner.sh (ABORT if fails)
+  3. [GUARDRAIL] Check for security violations
+  4. [VERIFY] Run applicable VR-* checks
+  5. [AUDIT] Count gaps
+  6. [DECIDE] If gaps > 0: fix and re-verify
+  7. [PERSIST] Update session-state/CURRENT.md
+  8. [CHECKPOINT] At phase boundary: run full audit
+```
+
+---
+
+## GUARDRAIL CHECKS (Every Iteration)
+
+### MEMORY CHECK (Start of Each Iteration)
+
+Query `massu_memory_failures` and `massu_memory_search` for failures related to this plan's domain and files being modified. Surface relevant past failures as additional audit checkpoints.
+
+### Enhanced Context Loading
+
+For each file being modified:
+- `massu_context` - Load CR rules, schema alerts, patterns relevant to the file
+- `massu_coupling_check` - Verify frontend-backend coupling (CR-12/CR-23)
+- `massu_knowledge_rule` - Load applicable CR rules for the file's domain
+- `massu_knowledge_verification` - Load required VR-* checks for the file type
+
+For VR-COUPLING checks, also call `massu_trpc_map` to get automated procedure-to-UI mapping and compare against check-coupling.sh results for comprehensive coverage.
+
+When verifying CR-32 feature registration, use `massu_sentinel_detail` to get full feature details and verify all linked components/procedures/pages exist.
+
+When CR-30 applies (rebuilds), call `massu_sentinel_parity` to compare old vs new implementation for feature parity.
+
+### Mandatory Checks
+
+```bash
+# Pattern scanner (covers P-001 through P-008)
+./scripts/pattern-scanner.sh
+# Exit 0 = PASS, non-zero = ABORT iteration
+
+# Security check
+git diff --cached --name-only | grep -E '\.(env|pem|key|secret)' && echo "SECURITY VIOLATION" && exit 1
+```
+
+---
+
+## UI/UX VERIFICATION (When UI Work Done)
+
+Trace ALL: buttons (onClick -> handler -> API), navigation (href/router.push), props chains (source -> consumer), callbacks (defined -> called), state (init -> update -> render), end-to-end flows. Verify loading/error/empty/success states exist. Run `./scripts/check-ux-quality.sh`.
+
+---
+
+## API/ROUTER VERIFICATION (When API Work Done)
+
+Verify procedures exist with `protectedProcedure` for mutations, input schemas defined, client calls match server definitions, and procedures exported in root router.
+
+---
+
+## ENVIRONMENT & CONFIG VERIFICATION
+
+Verify env vars documented, no hardcoded secrets (`grep -rn "sk-\|password.*=" src/` = 0), config files exist.
+
+---
+
+## CONSOLE & ERROR PREVENTION
+
+Check for `console.log` (remove for production), error boundaries exist, null safety with optional chaining.
+
+---
+
+## ITERATION OUTPUT FORMAT
+
+```markdown
+## [MASSU LOOP - Iteration N]
+
+### Task
+Phase: X | Task: [description]
+
+### Guardrails
+- Pattern scanner: PASS/FAIL
+- Security check: PASS/FAIL
+
+### Verifications
+| Check | Type | Result | Proof |
+|-------|------|--------|-------|
+| [item] | VR-FILE | PASS | `ls -la output` |
+
+### Gap Count
+Gaps found: N
+
+### Status
+CONTINUE | FIX_REQUIRED | CHECKPOINT | COMPLETE
+
+### Next Action
+[Specific next step]
+```
+
+---
+
+## SESSION STATE UPDATE (After Every Iteration)
+
+Update `session-state/CURRENT.md` with: loop status (task, iteration, phase, checkpoint), iteration log table, verified work with proof, failed attempts (do not retry), next iteration plan.
+
+---
+
+## CONTEXT MANAGEMENT
+
+Use Task tool with subagents for exploration to keep main context clean. Update session state before compaction. After compaction, read recovery.md and resume from correct step. Never mix unrelated tasks during a protocol.