@massu/core 0.6.1 → 0.6.2

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

@@ -7,24 +7,20 @@
 ```
 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
+[2] GREP source files to verify modules/tools exist
+[3] LS files to verify they exist
+[4] VR-TOOL-REG: Verify tools are WIRED in tools.ts (not just created)
+[5] GREP for pattern violations
+[6] RUN build verification (npm run build)
+[7] RUN type verification (cd packages/core && npx tsc --noEmit)
+[8] RUN tests (npm test) - MANDATORY, NOT optional
+[9] RUN hook build (cd packages/core && npm run build:hooks)
+[10] RUN pattern scanner (bash scripts/massu-pattern-scanner.sh)
+[11] RUN security check (secrets staged)
+[12] COUNT gaps found
+[13] IF gaps > 0: FIX each gap, return to Step 1
+[14] IF gaps = 0: UPDATE session state
+[15] IF gaps = 0: Create checkpoint sign-off
 ```
 
 ---

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

@@ -12,6 +12,6 @@
 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.
+9. **User Flow Audit Required** - ALL tools, hooks, handlers, flows verified AFTER technical audits pass.
+10. **Component Reuse Verification** - Check existing modules before creating new ones.
+11. **No Workarounds Allowed** - TODOs, ts-ignore are BLOCKING violations. Pattern scanner is a HARD GATE.

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

@@ -7,7 +7,7 @@
 ```
 ITERATION N:
   1. [EXECUTE] Perform task segment
-  2. [GUARDRAIL] Run pattern-scanner.sh (ABORT if fails)
+  2. [GUARDRAIL] Run massu-pattern-scanner.sh (ABORT if fails)
   3. [GUARDRAIL] Check for security violations
   4. [VERIFY] Run applicable VR-* checks
   5. [AUDIT] Count gaps
@@ -22,27 +22,27 @@ ITERATION N:
 
 ### 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.
+Search memory files and session state 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_coupling_check` - Verify tool registration coupling (CR-11)
 - `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.
+For VR-TOOL-REG checks, also call `massu_trpc_map` to get automated tool-to-handler mapping 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 verifying CR-11 tool registration, use `massu_sentinel_detail` to get full feature details and verify all linked components/tools/handlers 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
+# Pattern scanner (covers all pattern checks)
+bash scripts/massu-pattern-scanner.sh
 # Exit 0 = PASS, non-zero = ABORT iteration
 
 # Security check
@@ -51,21 +51,53 @@ git diff --cached --name-only | grep -E '\.(env|pem|key|secret)' && echo "SECURI
 
 ---
 
-## UI/UX VERIFICATION (When UI Work Done)
+## IMPLEMENTATION PROTOCOL
 
-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`.
+### For EACH Plan Item
+
+1. **Read the plan item** from the extracted list
+2. **Read any referenced files** before modifying
+3. **Implement** following CLAUDE.md patterns
+4. **Verify** with the item's verification command
+5. **Update coverage** count
+6. **Continue** to next item
+
+### Pattern Compliance During Implementation
+
+For every file you create or modify, verify against:
+
+```bash
+# Run pattern scanner
+bash scripts/massu-pattern-scanner.sh
+
+# Type check
+cd packages/core && npx tsc --noEmit
+
+# Tests still pass
+npm test
+```
+
+### Massu-Specific Implementation Checks
+
+| If Implementing | Must Also |
+|-----------------|-----------|
+| New MCP tool | Wire 3 functions into tools.ts (CR-11) |
+| New hook | Verify esbuild compilation (CR-12) |
+| Config changes | Update interface in config.ts AND example in YAML |
+| New test | Place in `__tests__/` directory |
+| New module | Use ESM imports, getConfig() for config |
 
 ---
 
-## API/ROUTER VERIFICATION (When API Work Done)
+## API/TOOL VERIFICATION (When Tool Work Done)
 
-Verify procedures exist with `protectedProcedure` for mutations, input schemas defined, client calls match server definitions, and procedures exported in root router.
+Verify tools exist with 3-function pattern (getDefs, isTool, handleCall) in tools.ts, input schemas defined, and tool registration is complete.
 
 ---
 
 ## ENVIRONMENT & CONFIG VERIFICATION
 
-Verify env vars documented, no hardcoded secrets (`grep -rn "sk-\|password.*=" src/` = 0), config files exist.
+Verify env vars documented, no hardcoded secrets (`grep -rn "sk-\|password.*=" packages/core/src/` = 0), config files exist.
 
 ---
 
@@ -78,7 +110,7 @@ Check for `console.log` (remove for production), error boundaries exist, null sa
 ## ITERATION OUTPUT FORMAT
 
 ```markdown
-## [MASSU LOOP - Iteration N]
+## [CS LOOP - Iteration N]
 
 ### Task
 Phase: X | Task: [description]
@@ -112,4 +144,4 @@ Update `session-state/CURRENT.md` with: loop status (task, iteration, phase, che
 
 ## 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.
+Use Task tool with subagents for exploration to keep main context clean. Update session state before compaction. After compaction, read session state and resume from correct step. Never mix unrelated tasks during a protocol.

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

@@ -10,14 +10,14 @@
 
 This command is a **loop controller** for implementation + verification. Your job is to:
 1. Extract plan items and implement them
-2. After implementation, spawn a `massu-plan-auditor` subagent for verification
+2. After implementation, spawn a `general-purpose` subagent for verification
 3. Parse the structured result (`GAPS_DISCOVERED: N`)
 4. If gaps discovered > 0: fix gaps, then spawn ANOTHER FRESH auditor pass
 5. Only when a COMPLETE FRESH PASS discovers ZERO gaps can you declare complete
 
 **The verification audit runs inside Task subagents. This prevents early termination.**
 
-### CRITICAL: GAPS_DISCOVERED Semantics (Incident #19, Feb 7, 2026)
+### CRITICAL: GAPS_DISCOVERED Semantics (Incident #19)
 
 **`GAPS_DISCOVERED` = total gaps FOUND during the pass, REGARDLESS of whether they were also fixed.**
 
@@ -29,6 +29,26 @@ This command is a **loop controller** for implementation + verification. Your jo
 
 **THE RULE**: A clean pass means zero gaps DISCOVERED from the start. Fixing gaps during a pass does NOT make it a clean pass. The fixes themselves could introduce new issues. Only a fresh pass starting clean and finding nothing proves correctness.
 
+### Agent Result Persistence
+
+All Task sub-agents MUST write their results to disk in addition to returning text:
+- Security review: `.massu/agent-results/{timestamp}-security.json`
+- Architecture review: `.massu/agent-results/{timestamp}-architecture.json`
+- Verification audit: `.massu/agent-results/{timestamp}-verify-{iteration}.json`
+
+JSON format: `{ iteration, gaps_discovered, gaps_fixed, gaps_remaining, plan_items_total, plan_items_verified, findings: [] }`
+
+This prevents context overflow from killing verification progress. If the parent session crashes, a new session can read these files via `bash scripts/hooks/read-agent-results.sh` to resume.
+
+### Workflow State Tracking
+
+At the start of this command, write a transition entry to `.massu/workflow-log.md`:
+```
+| [timestamp] | AUDIT/PLAN | IMPLEMENT | /massu-loop | [session-id] |
+```
+
+At completion, write a completion entry.
+
 ### Execution Protocol
 
 ```
@@ -39,88 +59,68 @@ iteration = 0
 # Read plan, extract items, implement each one with VR-* proof
 
 # Phase 1.5: MULTI-PERSPECTIVE REVIEW (after implementation, before verification)
-# Spawn 3 focused review subagents IN PARALLEL for independent analysis
+# Spawn focused review subagents IN PARALLEL for independent analysis
 # Each reviewer has an adversarial mindset and a SINGLE focused concern (Principle #20)
 # Elegance/simplicity assessment happens in Phase 2.1 POST-BUILD REFLECTION (Q4)
 
-security_result = Task(subagent_type="massu-security-reviewer", model="opus", prompt="
+security_result = Task(subagent_type="general-purpose", model="opus", prompt="
   Review implementation for plan: {PLAN_PATH}
   Focus: Security vulnerabilities, auth gaps, input validation, data exposure
   Check all new/modified files. Return structured result with SECURITY_GATE.
 ")
 
-architecture_result = Task(subagent_type="massu-architecture-reviewer", model="opus", prompt="
+architecture_result = Task(subagent_type="general-purpose", model="opus", prompt="
   Review implementation for plan: {PLAN_PATH}
   Focus: Design issues, coupling problems, pattern compliance, scalability
   Check all new/modified files. Return structured result with ARCHITECTURE_GATE.
 ")
 
-ux_result = Task(subagent_type="massu-ux-reviewer", model="sonnet", prompt="
-  Review implementation for plan: {PLAN_PATH}
-  Focus: User experience, accessibility, loading/error/empty states, consistency
-  Check all new/modified UI files. Return structured result with UX_GATE.
-")
-
-# Parse results and fix any CRITICAL/HIGH findings before proceeding to verification
-# FAIL gate = must fix before proceeding
-# WARN findings = document and proceed
-
-# Phase 1.6: TEST-FIRST FOR CRITICAL FINDINGS
-# If ANY Phase 1.5 reviewer flagged a CRITICAL-severity BUG (not pattern violation):
-#   1. Read _shared-references/test-first-protocol.md
-#   2. For EACH critical bug finding:
-#      - Write a failing test that demonstrates the bug (Step 1)
-#      - Verify the test fails for the expected reason (Step 2)
-#      - Apply the fix (Step 3)
-#      - Verify the test passes (Step 4)
-#   3. Report TEST_FIRST_GATE: PASS or SKIPPED (with reason)
-# If NO critical bug findings: skip this phase entirely
+# Parse results and fix ALL findings at ALL severity levels (CR-45)
+# CRITICAL, HIGH, MEDIUM, LOW — all get fixed before proceeding
+# No severity is exempt — "clean pass" means ZERO findings
 
 # Phase 2: VERIFY (audit loop - STRUCTURAL)
 WHILE true:
   iteration += 1
 
-  # Run circuit breaker check (CR-37: detect stagnation)
-  bash scripts/hooks/loop-circuit-breaker.sh --pass {iteration} --plan-trajectory .claude/loop-state/plan-trajectory.json
-  # Parse circuit breaker output - BAIL_AND_REPLAN is a structural halt
-  IF CIRCUIT_BREAKER_STATUS == "DEPTH_EXCEEDED":
-    Output: "CIRCUIT BREAKER: Loop depth exceeded (nested spawn detected)."
-    Output: "Current LOOP_DEPTH exceeds MAX_LOOP_DEPTH. Refusing to continue."
-    STOP loop immediately — cascade prevention.
-
-  IF CIRCUIT_BREAKER_STATUS == "BAIL_AND_REPLAN":
+  # Run circuit breaker check (detect stagnation)
+  # If same gaps appear 3+ times with no progress, consider changing approach
+  IF iteration > 3 AND no_progress_count >= 3:
     Output: "CIRCUIT BREAKER: The current approach is not converging after {iteration} passes."
-    Output: "No progress: {no_progress_count} passes | Same errors: {same_error_count} passes"
     Output: "Options: (a) Re-plan with different approach (b) Continue current approach (c) Stop"
     AskUserQuestion: "The loop has stalled. How should we proceed?"
     IF user chooses re-plan: STOP loop, output current state, recommend /massu-create-plan
-    IF user chooses continue: CONTINUE loop (reset circuit breaker: bash scripts/hooks/loop-circuit-breaker.sh --reset)
-    IF user chooses stop: STOP loop, output current state as incomplete
-
-  IF CIRCUIT_BREAKER_STATUS == "PLAN_FUNDAMENTALLY_WRONG":
-    Output: "CIRCUIT BREAKER: Plan is fundamentally wrong — {distinct_failures} different items have failed."
-    Output: "This indicates a systemic plan issue, not isolated implementation problems."
-    Output: "Options:"
-    Output: "  (a) DISPOSE plan and regenerate from scratch (preserves learnings)"
-    Output: "  (b) Continue with current plan (override)"
-    Output: "  (c) Stop and review manually"
-    AskUserQuestion: "The plan appears fundamentally flawed. How should we proceed?"
-    IF user chooses dispose:
-      - Save failed items + error context to plan trajectory file
-      - STOP loop, output current state
-      - Recommend: /massu-create-plan with failed items as constraints
-      - The NEW plan goes through the same zero-gaps audit loop before implementation
-    IF user chooses continue: CONTINUE loop (reset: bash scripts/hooks/loop-circuit-breaker.sh --reset)
+    IF user chooses continue: CONTINUE loop (reset circuit breaker)
     IF user chooses stop: STOP loop, output current state as incomplete
 
   # Spawn auditor subagent for ONE complete verification pass
-  result = Task(subagent_type="massu-plan-auditor", model="opus", prompt="
-    Audit iteration {iteration} for plan: {PLAN_PATH}
+  result = Task(subagent_type="general-purpose", model="opus", prompt="
+    Verification audit iteration {iteration} for plan: {PLAN_PATH}
+    This is a Massu implementation (library/MCP server, NOT a web app).
     Execute ONE complete audit pass. Verify ALL deliverables.
-    Check code quality (patterns, build, types, tests).
+    Check code quality (patterns, types, tests).
     Check plan coverage (every item verified with proof).
     Fix any gaps you find (code or plan document).
 
+    CONTEXT: Massu is a TypeScript monorepo with:
+    - packages/core/src/ (MCP server source)
+    - packages/core/src/__tests__/ (vitest tests)
+    - packages/core/src/hooks/ (esbuild-compiled hooks)
+    - website/ (Next.js + Supabase website)
+    - massu.config.yaml (project config)
+    - Tool registration: 3-function pattern (getDefs, isTool, handleCall) in tools.ts
+
+    VERIFICATION COMMANDS:
+    - Pattern scanner: bash scripts/massu-pattern-scanner.sh
+    - Type check: cd packages/core && npx tsc --noEmit
+    - Tests: npm test
+    - Hook build: cd packages/core && npm run build:hooks
+
+    VR-* CHECKS (use ONLY these, per CLAUDE.md):
+    - VR-FILE, VR-GREP, VR-NEGATIVE, VR-COUNT (generic)
+    - VR-BUILD: npm run build (tsc + hooks)
+    - VR-TYPE, VR-TEST, VR-TOOL-REG, VR-HOOK-BUILD, VR-CONFIG, VR-PATTERN
+
     CRITICAL INSTRUCTION FOR GAPS_DISCOVERED:
     Report GAPS_DISCOVERED as the total number of gaps you FOUND during this pass,
     EVEN IF you also fixed them. Finding 5 gaps and fixing all 5 = GAPS_DISCOVERED: 5.
@@ -128,7 +128,17 @@ WHILE true:
     Do NOT report 0 just because you fixed everything. The loop controller needs to know
     whether this was a clean pass (found nothing) or a dirty pass (found and fixed things).
 
-    Return the structured result block with GAPS_DISCOVERED (not GAPS_FOUND).
+    Return the structured result block:
+    ---STRUCTURED-RESULT---
+    ITERATION: {iteration}
+    GAPS_DISCOVERED: [number]
+    GAPS_FIXED: [number]
+    GAPS_REMAINING: [number]
+    PLAN_ITEMS_TOTAL: [number]
+    PLAN_ITEMS_VERIFIED: [number]
+    CODE_QUALITY_GATE: PASS/FAIL
+    PLAN_COVERAGE_GATE: PASS/FAIL
+    ---END-RESULT---
   ")
 
   # Parse structured result
@@ -162,16 +172,15 @@ END WHILE
 | **ALWAYS use Task tool for verification passes** | Subagents keep context clean |
 | **ALWAYS parse GAPS_DISCOVERED from result** | This is the loop control variable (DISCOVERED, not REMAINING) |
 | **Maximum 10 iterations** | If still failing after 10, report to user with remaining gaps |
-| **ALWAYS run multi-perspective review after implementation** | 3 reviewers catch different issues than 1 auditor |
-| **Run review subagents IN PARALLEL** | Security, architecture, UX reviews are independent |
+| **ALWAYS run multi-perspective review after implementation** | Multiple reviewers catch different issues than 1 auditor |
+| **Run review subagents IN PARALLEL** | Security and architecture reviews are independent |
 | **Fix CRITICAL/HIGH findings before verification** | Don't waste auditor passes on known issues |
-| **VR-PIPELINE for data features (CR-43)** | After implementing any data pipeline (AI, cron, generation, ETL), trigger it manually and verify non-empty output before marking complete |
 
 ### Why This Architecture Exists
 
-**Incident #14 (Jan 30, 2026)**: Audit loop terminated after 1 pass with 6 open gaps. User had to manually intervene. Root cause: instructional "MUST loop" text competed with default "report and stop" behavior. By making the loop STRUCTURAL (spawn subagent, check result, loop), early termination becomes structurally impossible.
+**Incident #14**: Audit loop terminated after 1 pass with open gaps. Root cause: instructional "MUST loop" text competed with default "report and stop" behavior. By making the loop STRUCTURAL (spawn subagent, check result, loop), early termination becomes structurally impossible.
 
-**Incident #19 (Feb 7, 2026)**: Auditor found 16 gaps and fixed all 16 in the same pass, reported GAPS_FOUND: 0. Loop exited after 1 iteration without verifying the fixes. GAPS_DISCOVERED (not GAPS_REMAINING) is the correct metric.
+**Incident #19**: Auditor found 16 gaps and fixed all 16 in the same pass, reported GAPS_FOUND: 0. Loop exited after 1 iteration without verifying the fixes. GAPS_DISCOVERED (not GAPS_REMAINING) is the correct metric.
 
 ---
 
@@ -183,6 +192,6 @@ The loop controller (main agent) coordinates; subagents execute scoped work. Fol
 |-----------|---------|
 | **One task per subagent** | Each Task call has a single, scoped objective (Principle #20) |
 | **Main agent fixes, subagent verifies** | Controller fixes code-level gaps; auditor subagent re-verifies |
-| **No nested spawns** | Subagents NEVER spawn their own subagents (circuit breaker enforces via LOOP_DEPTH) |
-| **Parallel only when independent** | Review agents (security, architecture, UX) run in parallel; sequential passes run sequentially |
+| **No nested spawns** | Subagents NEVER spawn their own subagents |
+| **Parallel only when independent** | Review agents (security, architecture) run in parallel; sequential passes run sequentially |
 | **Budget awareness** | Each subagent pass costs ~20-40K tokens. 10 iterations = significant cost. Fix root causes, not symptoms |

package/commands/massu-loop/references/plan-extraction.md

@@ -23,16 +23,24 @@ For EACH section of the plan, extract concrete items into a table:
 
 ### Source Document
 - **Plan File**: [path]
+- **Plan Title**: [title]
 - **Total Sections**: [N]
 
 ### Extracted Items
 | Item # | Type | Description | Location | Verification Command | Status |
 |--------|------|-------------|----------|---------------------|--------|
-| P1-001 | FILE_CREATE | Component.tsx | src/components/ | ls -la [path] | PENDING |
-| P1-002 | PROCEDURE | router.method | src/server/api/ | grep "method" [router] | PENDING |
+| P1-001 | MODULE_CREATE | foo-tools.ts | packages/core/src/ | ls -la [path] | PENDING |
+| P1-002 | TOOL_WIRE | Wire into tools.ts | packages/core/src/tools.ts | grep [module] tools.ts | PENDING |
+| P2-001 | TEST | foo.test.ts | packages/core/src/__tests__/ | npm test | PENDING |
 
 ### Item Types
-FILE_CREATE, FILE_MODIFY, COMPONENT, PROCEDURE, MIGRATION, FEATURE, REMOVAL (VR-NEGATIVE), REFACTOR
+- MODULE_CREATE: New TypeScript module
+- MODULE_MODIFY: Existing module to change
+- TOOL_WIRE: Wire tool into tools.ts
+- TEST: Test file
+- CONFIG: Config changes (config.ts + YAML)
+- HOOK: New or modified hook
+- REMOVAL: Code/file to remove (use VR-NEGATIVE)
 
 ### Coverage Summary
 - **Total Items**: [N] | **Verified Complete**: 0 | **Coverage**: 0%
@@ -42,13 +50,13 @@ FILE_CREATE, FILE_MODIFY, COMPONENT, PROCEDURE, MIGRATION, FEATURE, REMOVAL (VR-
 
 | Item Type | Verification Method | Expected Result |
 |-----------|---------------------|-----------------|
-| FILE_CREATE | `ls -la [path]` | File exists, size > 0 |
-| FILE_MODIFY | `grep "[change]" [file]` | Pattern found |
-| COMPONENT | `grep "export.*ComponentName" [index]` | Export exists |
-| PROCEDURE | `grep "[procedure]:" [router]` | Procedure defined |
-| MIGRATION | `SELECT column_name FROM information_schema` | Column exists |
-| FEATURE | Feature-specific grep | Functionality present |
-| REMOVAL | `grep -rn "[old]" src/ \| wc -l` | 0 matches |
+| MODULE_CREATE | `ls -la [path]` | File exists, size > 0 |
+| MODULE_MODIFY | `grep "[change]" [file]` | Pattern found |
+| TOOL_WIRE | `grep "getXDefs\|isXTool\|handleXCall" tools.ts` | All 3 present |
+| TEST | `npm test` | All pass |
+| CONFIG | Parse YAML, grep interface | Valid |
+| HOOK | `cd packages/core && npm run build:hooks` | Exit 0 |
+| REMOVAL | `grep -rn "[old]" packages/core/src/ | wc -l` | 0 matches |
 
 ### Step 0.4: Track Coverage Throughout
 
@@ -67,7 +75,7 @@ Add completion table to TOP of plan document with status for each task:
 
 | # | Task/Phase | Status | Verification | Date |
 |---|------------|--------|--------------|------|
-| 1 | [description] | 100% COMPLETE | VR-GREP: 0 refs | 2026-01-20 |
+| 1 | [description] | 100% COMPLETE | VR-GREP: 0 refs | [date] |
 ```
 
 ### VR-PLAN-STATUS Verification

package/commands/massu-loop/references/vr-plan-spec.md

@@ -10,16 +10,16 @@
 ### VR-PLAN: Verification Strategy
 
 **Work being verified**: [description]
-**Domains touched**: [database / UI / API / auth / build / config]
+**Domains touched**: [tools / hooks / config / tests / website]
 
 | # | VR-* Check | Target File/Component | Why Applicable | Status |
 |---|------------|----------------------|----------------|--------|
 | 1 | VR-BUILD | Full project | Always required | PENDING |
-| 2 | VR-TYPE | Full project | Always required | PENDING |
-| 3 | VR-TEST | Full project | Always required (CR-21) | PENDING |
+| 2 | VR-TYPE | packages/core | Always required | PENDING |
+| 3 | VR-TEST | All tests | Always required | PENDING |
 | ... | ... | ... | ... | ... |
 
-**Execution order**: VR-SCHEMA first -> VR-BUILD/VR-TYPE -> VR-TEST -> VR-RENDER/VR-COUPLING -> VR-RUNTIME
+**Execution order**: VR-FILE first -> VR-BUILD/VR-TYPE -> VR-TEST -> VR-TOOL-REG -> VR-HOOK-BUILD -> VR-PATTERN
 ```
 
 ### Mandatory Checks (ALWAYS include)
@@ -28,20 +28,16 @@
 |-------|----------------|
 | VR-BUILD | ALWAYS |
 | VR-TYPE | ALWAYS |
-| VR-TEST | ALWAYS (CR-21) |
+| VR-TEST | ALWAYS |
 | VR-FILE | When files created |
 | VR-GREP | When code added |
 | VR-NEGATIVE | When code removed |
-| VR-SCHEMA | When DB changed |
-| VR-DATA | When config-driven features touched |
-| VR-RENDER | When UI components created |
-| VR-COUPLING | When backend features added |
-| VR-HANDLER | When buttons/actions added |
-| VR-API-CONTRACT | When frontend calls backend |
+| VR-TOOL-REG | When new tools added (3-function pattern in tools.ts) |
+| VR-HOOK-BUILD | When hooks added or modified |
+| VR-CONFIG | When config.ts or massu.config.yaml changed |
+| VR-PATTERN | Always (pattern scanner) |
 | VR-PLAN-COVERAGE | When implementing a plan |
-| VR-SPEC-MATCH | When UI items specify CSS classes/structure (CR-42) |
-| VR-PIPELINE | When data pipeline features implemented (CR-43) |
-| VR-RUNTIME | After all other checks pass |
+| VR-COUNT | When verifying numeric expectations |
 
 Do NOT start verification until VR-PLAN is complete with all domains, checks, targets, and execution order.
 
@@ -49,18 +45,16 @@ Do NOT start verification until VR-PLAN is complete with all domains, checks, ta
 
 ## COMPLETION CRITERIA
 
-Massu Loop is COMPLETE **only when BOTH gates pass: Code Quality AND Plan Coverage**.
+CS Loop is COMPLETE **only when BOTH gates pass: Code Quality AND Plan Coverage**.
 
 ### GATE 1: Code Quality Verification (All Must Pass in SAME Audit Run)
 - [ ] All phases executed, all checkpoints passed with zero gaps
 - [ ] Pattern scanner: Exit 0
 - [ ] Type check: 0 errors
 - [ ] Build: Exit 0
-- [ ] Lint: Exit 0
-- [ ] Prisma validate: Exit 0
 - [ ] Tests: ALL PASS (MANDATORY)
+- [ ] Hook build: Exit 0
 - [ ] Security: No secrets staged
-- [ ] VR-RENDER: All UI components rendered in pages
 
 ### GATE 2: Plan Coverage Verification
 - [ ] Plan file read (actual file, not memory)
@@ -77,7 +71,7 @@ Massu Loop is COMPLETE **only when BOTH gates pass: Code Quality AND Plan Covera
 ## DUAL VERIFICATION RESULT
 | Gate | Status | Details |
 |------|--------|---------|
-| Code Quality | PASS/FAIL | Pattern scanner, build, types |
+| Code Quality | PASS/FAIL | Pattern scanner, build, types, tests |
 | Plan Coverage | PASS/FAIL | X/Y items (Z%) |
 
 **RESULT: COMPLETE** (only if both PASS)
@@ -86,12 +80,10 @@ Massu Loop is COMPLETE **only when BOTH gates pass: Code Quality AND Plan Covera
 **Code Quality: PASS + Plan Coverage: FAIL = NOT COMPLETE**
 
 ### Additional Verification
-- [ ] User Flow: ALL buttons, navigation, props, callbacks, state, e2e flows verified
-- [ ] Component Reuse: Checked existing before creating new
-- [ ] DB verified: all environments
+- [ ] Tool Registration: ALL new tools wired in tools.ts (3-function pattern)
+- [ ] Hook Build: esbuild compilation succeeds
 - [ ] Session state shows COMPLETED
 - [ ] Phase archives created
-- [ ] Help site updated for user-facing changes (or N/A)
 - [ ] Plan document completion table added at TOP
 
 ---
@@ -99,7 +91,7 @@ Massu Loop is COMPLETE **only when BOTH gates pass: Code Quality AND Plan Covera
 ## COMPLETION OUTPUT
 
 ```markdown
-## [MASSU LOOP - COMPLETE]
+## [CS LOOP - COMPLETE]
 
 ### Dual Verification Certification
 - **Audit loops required**: N (loop #N achieved 0 gaps + 100% coverage)
@@ -115,11 +107,11 @@ Massu Loop is COMPLETE **only when BOTH gates pass: Code Quality AND Plan Covera
 ### GATE 1: Code Quality Evidence
 | Gate | Command | Result |
 |------|---------|--------|
-| Pattern scanner | `./scripts/pattern-scanner.sh` | Exit 0 |
-| Type check | `npx tsc --noEmit` | 0 errors |
+| Pattern scanner | `bash scripts/massu-pattern-scanner.sh` | Exit 0 |
+| Type check | `cd packages/core && npx tsc --noEmit` | 0 errors |
 | Build | `npm run build` | Exit 0 |
-| DB (DEV) | VR-SCHEMA | VERIFIED |
-| DB (PROD) | VR-SCHEMA | VERIFIED |
+| Tests | `npm test` | All pass |
+| Hook build | `cd packages/core && npm run build:hooks` | Exit 0 |
 
 ### GATE 2: Plan Coverage Evidence
 | Item # | Description | Verification | Status |