@hanzlaa/rcode 3.6.16 → 4.0.0

package/rihal/workflows/validate-phase.md

@@ -1,181 +0,0 @@
-<purpose>
-Audit Nyquist validation gaps for a completed phase. Generate missing tests. Update VALIDATION.md.
-</purpose>
-
-<required_reading>
-@.rihal/references/ui-brand.md
-@.rihal/references/karpathy-guidelines.md
-</required_reading>
-
-<available_agent_types>
-Valid Rihal subagent types (use exact names — do not fall back to 'general-purpose'):
-- rihal-nyquist-auditor — Validates verification coverage
-</available_agent_types>
-
-<process>
-
-## 0. Initialize
-
-```bash
-INIT=$(node ".rihal/bin/rihal-tools.cjs" init phase-op "${PHASE_ARG}")
-if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
-AGENT_SKILLS_AUDITOR=$(node ".rihal/bin/rihal-tools.cjs" agent-skills rihal-nyquist-auditor 2>/dev/null)
-```
-
-Parse: `phase_dir`, `phase_number`, `phase_name`, `phase_slug`, `padded_phase`.
-
-```bash
-AUDITOR_MODEL=$(node ".rihal/bin/rihal-tools.cjs" resolve-model rihal-nyquist-auditor --raw)
-NYQUIST_CFG=$(node ".rihal/bin/rihal-tools.cjs" config-get workflow.nyquist_validation --raw)
-```
-
-If `NYQUIST_CFG` is `false`: exit with "Nyquist validation is disabled. Enable via /rihal-settings."
-
-Display banner: `Rihal > VALIDATE PHASE {N}: {name}`
-
-## 1. Detect Input State
-
-```bash
-VALIDATION_FILE=$(ls "${PHASE_DIR}"/*-VALIDATION.md 2>/dev/null | head -1)
-SUMMARY_FILES=$(ls "${PHASE_DIR}"/*-SUMMARY.md 2>/dev/null)
-```
-
-- **State A** (`VALIDATION_FILE` non-empty): Audit existing
-- **State B** (`VALIDATION_FILE` empty, `SUMMARY_FILES` non-empty): Reconstruct from artifacts
-- **State C** (`SUMMARY_FILES` empty): Exit — "Phase {N} not executed. Run /rihal-execute {N} ${Rihal_WS} first."
-
-## 2. Discovery
-
-### 2a. Read Phase Artifacts
-
-Read all PLAN and SUMMARY files. Extract: task lists, requirement IDs, key-files changed, verify blocks.
-
-### 2b. Build Requirement-to-Task Map
-
-Per task: `{ task_id, plan_id, wave, requirement_ids, has_automated_command }`
-
-### 2c. Detect Test Infrastructure
-
-State A: Parse from existing VALIDATION.md Test Infrastructure table.
-State B: Filesystem scan:
-
-```bash
-find . -name "pytest.ini" -o -name "jest.config.*" -o -name "vitest.config.*" -o -name "pyproject.toml" 2>/dev/null | head -10
-find . \( -name "*.test.*" -o -name "*.spec.*" -o -name "test_*" \) -not -path "*/node_modules/*" 2>/dev/null | head -40
-```
-
-### 2d. Cross-Reference
-
-Match each requirement to existing tests by filename, imports, test descriptions. Record: requirement → test_file → status.
-
-## 3. Gap Analysis
-
-Classify each requirement:
-
-| Status | Criteria |
-|--------|----------|
-| COVERED | Test exists, targets behavior, runs green |
-| PARTIAL | Test exists, failing or incomplete |
-| MISSING | No test found |
-
-Build: `{ task_id, requirement, gap_type, suggested_test_path, suggested_command }`
-
-No gaps → skip to Step 6, set `nyquist_compliant: true`.
-
-## 4. Present Gap Plan
-
-```bash
-CONFIG_MODE=$(node .rihal/bin/rihal-tools.cjs config-get mode 2>/dev/null || echo "guided")
-```
-
-**If `CONFIG_MODE == "yolo"`:** Auto-select option 1 ("Fix all gaps") and proceed to Step 5 without asking. Print: `▶ Auto-fixing all gaps (yolo mode).`
-
-Otherwise call AskUserQuestion with gap table and options:
-1. "Fix all gaps" → Step 5
-2. "Skip — mark manual-only" → add to Manual-Only, Step 6
-3. "Cancel" → exit
-
-## 5. Spawn rihal-nyquist-auditor
-
-```
-Task(
-  prompt="Read $HOME/.claude/agents/rihal-nyquist-auditor.md for instructions.\n\n" +
-    "<files_to_read>{PLAN, SUMMARY, impl files, VALIDATION.md}</files_to_read>" +
-    "<gaps>{gap list}</gaps>" +
-    "<test_infrastructure>{framework, config, commands}</test_infrastructure>" +
-    "<constraints>Never modify impl files. Max 3 debug iterations. Escalate impl bugs.</constraints>" +
-    "${AGENT_SKILLS_AUDITOR}",
-  subagent_type="rihal-nyquist-auditor",
-  model="{AUDITOR_MODEL}",
-  description="Fill validation gaps for Phase {N}"
-)
-```
-
-Handle return:
-- `## GAPS FILLED` → record tests + map updates, Step 6
-- `## PARTIAL` → record resolved, move escalated to manual-only, Step 6
-- `## ESCALATE` → move all to manual-only, Step 6
-
-## 6. Generate/Update VALIDATION.md
-
-**State B (create):**
-1. Read template from `.rihal/templates/VALIDATION.md`
-2. Fill: frontmatter, Test Infrastructure, Per-Task Map, Manual-Only, Sign-Off
-3. Write to `${PHASE_DIR}/${PADDED_PHASE}-VALIDATION.md`
-
-**State A (update):**
-1. Update Per-Task Map statuses, add escalated to Manual-Only, update frontmatter
-2. Append audit trail:
-
-```markdown
-## Validation Audit {date}
-| Metric | Count |
-|--------|-------|
-| Gaps found | {N} |
-| Resolved | {M} |
-| Escalated | {K} |
-```
-
-## 7. Commit
-
-```bash
-git add {test_files}
-git commit -m "test(phase-${PHASE}): add Nyquist validation tests"
-
-node ".rihal/bin/rihal-tools.cjs" commit "docs(phase-${PHASE}): add/update validation strategy"
-```
-
-## 8. Results + Routing
-
-**Compliant:**
-```
-Rihal > PHASE {N} IS NYQUIST-COMPLIANT
-All requirements have automated verification.
-▶ Next: /rihal-audit-milestone ${Rihal_WS}
-```
-
-**Partial:**
-```
-Rihal > PHASE {N} VALIDATED (PARTIAL)
-{M} automated, {K} manual-only.
-▶ Retry: /rihal-validate-phase {N} ${Rihal_WS}
-```
-
-Display `/clear` reminder.
-
-</process>
-
-<success_criteria>
-- [ ] Nyquist config checked (exit if disabled)
-- [ ] Input state detected (A/B/C)
-- [ ] State C exits cleanly
-- [ ] PLAN/SUMMARY files read, requirement map built
-- [ ] Test infrastructure detected
-- [ ] Gaps classified (COVERED/PARTIAL/MISSING)
-- [ ] User gate with gap table
-- [ ] Auditor spawned with complete context
-- [ ] All three return formats handled
-- [ ] VALIDATION.md created or updated
-- [ ] Test files committed separately
-- [ ] Results with routing presented
-</success_criteria>

package/rihal/workflows/validate-prd.md

@@ -1,31 +0,0 @@
-# Workflow: rihal-validate-prd
-
-<purpose>
-Validate an existing PRD for completeness, consistency, and testability. Delegates to the rihal-validate-prd skill.
-</purpose>
-
-## Execution
-
-Locate and follow the installed skill:
-
-```bash
-find .rihal/skills/actions -path "*rihal-validate-prd/workflow.md" 2>/dev/null | head -1
-```
-
-Read and follow the workflow at that path. If the path is empty:
-
-```
-Skill not installed — run: npx @hanzlaa/rcode install
-```
-
-## On Completion
-
-/rihal-new-milestone — build the roadmap from the validated PRD
-/rihal-edit-prd — fix validation findings
-/rihal-council — escalate ambiguous requirements to the council
-
-## ▶ Next Up
-
-- /rihal-new-milestone
-- /rihal-edit-prd
-- /rihal-council {prd-question}

package/rihal/workflows/verify-phase.md

@@ -1,409 +0,0 @@
-<purpose>
-Verify phase goal achievement through goal-backward analysis. Check that the codebase delivers what the phase promised, not just that tasks completed.
-
-Executed by a verification subagent spawned from execute-phase.md.
-</purpose>
-
-<core_principle>
-**Task completion ≠ Goal achievement**
-
-A task "create chat component" can be marked complete when the component is a placeholder. The task was done — but the goal "working chat interface" was not achieved.
-
-Goal-backward verification:
-1. What must be TRUE for the goal to be achieved?
-2. What must EXIST for those truths to hold?
-3. What must be WIRED for those artifacts to function?
-4. What must TESTS PROVE for those truths to be evidenced?
-
-Then verify each level against the actual codebase.
-</core_principle>
-
-<required_reading>
-@.rihal/references/verification-patterns.md
-@.rihal/templates/verification-report.md
-@.rihal/references/karpathy-guidelines.md
-</required_reading>
-
-<process>
-
-<step name="load_context" priority="first">
-Load phase operation context:
-
-```bash
-INIT=$(node ".rihal/bin/rihal-tools.cjs" init phase-op "${PHASE_ARG}" 2>/dev/null)
-if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
-```
-
-If `INIT` is empty or `INIT.ok` is false, print error and exit:
-```
-Error: rihal-tools init failed. Verify .rihal/ is installed and state.json is valid.
-```
-
-Extract from init JSON: `phase_dir`, `phase_number`, `phase_name`, `has_plans`, `plan_count`.
-
-Then load phase details and list plans/summaries:
-```bash
-node ".rihal/bin/rihal-tools.cjs" roadmap get-phase "${phase_number}"
-grep -E "^| ${phase_number}" .planning/REQUIREMENTS.md 2>/dev/null || true
-ls "$phase_dir"/*-SUMMARY.md "$phase_dir"/*-SPRINT.md 2>/dev/null || true
-```
-
-Load full milestone phases for deferred-item filtering (Step 9b):
-```bash
-node ".rihal/bin/rihal-tools.cjs" roadmap analyze
-```
-
-Extract **phase goal** from ROADMAP.md (the outcome to verify, not tasks), **requirements** from REQUIREMENTS.md if it exists, and **all milestone phases** from roadmap analyze (for cross-referencing gaps against later phases).
-</step>
-
-<step name="establish_must_haves">
-**Option A: Must-haves in PLAN frontmatter**
-
-Use rihal-tools to extract must_haves from each PLAN:
-
-```bash
-for plan in "$PHASE_DIR"/*-SPRINT.md; do
-  MUST_HAVES=$(node ".rihal/bin/rihal-tools.cjs" frontmatter get "$plan" --field must_haves)
-  echo "=== $plan ===" && echo "$MUST_HAVES"
-done
-```
-
-Returns JSON: `{ truths: [...], artifacts: [...], key_links: [...] }`
-
-Aggregate all must_haves across plans for phase-level verification.
-
-**Option B: Use Success Criteria from ROADMAP.md**
-
-If no must_haves in frontmatter (MUST_HAVES returns error or empty), check for Success Criteria:
-
-```bash
-PHASE_DATA=$(node ".rihal/bin/rihal-tools.cjs" roadmap get-phase "${phase_number}" --raw)
-```
-
-Parse the `success_criteria` array from the JSON output. If non-empty:
-1. Use each Success Criterion directly as a **truth** (they are already written as observable, testable behaviors)
-2. Derive **artifacts** (concrete file paths for each truth)
-3. Derive **key links** (critical wiring where stubs hide)
-4. Document the must-haves before proceeding
-
-Success Criteria from ROADMAP.md are the contract — they override PLAN-level must_haves when both exist.
-
-**Option C: Derive from phase goal (fallback)**
-
-If no must_haves in frontmatter AND no Success Criteria in ROADMAP:
-1. State the goal from ROADMAP.md
-2. Derive **truths** (3-7 observable behaviors, each testable)
-3. Derive **artifacts** (concrete file paths for each truth)
-4. Derive **key links** (critical wiring where stubs hide)
-5. Document derived must-haves before proceeding
-</step>
-
-<step name="verify_truths">
-For each observable truth, determine if the codebase enables it.
-
-**Status:** ✓ VERIFIED (all supporting artifacts pass) | ✗ FAILED (artifact missing/stub/unwired) | ? UNCERTAIN (needs human)
-
-For each truth: identify supporting artifacts → check artifact status → check wiring → determine truth status.
-
-**Example:** Truth "User can see existing messages" depends on Chat.tsx (renders), /api/chat GET (provides), Message model (schema). If Chat.tsx is a stub or API returns hardcoded [] → FAILED. If all exist, are substantive, and connected → VERIFIED.
-</step>
-
-<step name="verify_artifacts">
-Use rihal-tools for artifact verification against must_haves in each PLAN:
-
-```bash
-for plan in "$PHASE_DIR"/*-SPRINT.md; do
-  ARTIFACT_RESULT=$(node ".rihal/bin/rihal-tools.cjs" verify artifacts "$plan")
-  echo "=== $plan ===" && echo "$ARTIFACT_RESULT"
-done
-```
-
-Parse JSON result: `{ all_passed, passed, total, artifacts: [{path, exists, issues, passed}] }`
-
-**Artifact status from result:**
-- `exists=false` → MISSING
-- `issues` not empty → STUB (check issues for "Only N lines" or "Missing pattern")
-- `passed=true` → VERIFIED (Levels 1-2 pass)
-
-**Level 3 — Wired (manual check for artifacts that pass Levels 1-2):**
-```bash
-grep -r "import.*$artifact_name" src/ --include="*.ts" --include="*.tsx"  # IMPORTED
-grep -r "$artifact_name" src/ --include="*.ts" --include="*.tsx" | grep -v "import"  # USED
-```
-WIRED = imported AND used. ORPHANED = exists but not imported/used.
-
-| Exists | Substantive | Wired | Status |
-|--------|-------------|-------|--------|
-| ✓ | ✓ | ✓ | ✓ VERIFIED |
-| ✓ | ✓ | ✗ | ⚠️ ORPHANED |
-| ✓ | ✗ | - | ✗ STUB |
-| ✗ | - | - | ✗ MISSING |
-
-**Export-level spot check (WARNING severity):**
-
-For artifacts that pass Level 3, spot-check individual exports:
-- Extract key exported symbols (functions, constants, classes — skip types/interfaces)
-- For each, grep for usage outside the defining file
-- Flag exports with zero external call sites as "exported but unused"
-
-This catches dead stores like `setPlan()` that exist in a wired file but are
-never actually called. Report as WARNING — may indicate incomplete cross-plan
-wiring or leftover code from plan revisions.
-</step>
-
-<step name="verify_wiring">
-Use rihal-tools for key link verification against must_haves in each PLAN:
-
-```bash
-for plan in "$PHASE_DIR"/*-SPRINT.md; do
-  LINKS_RESULT=$(node ".rihal/bin/rihal-tools.cjs" verify key-links "$plan")
-  echo "=== $plan ===" && echo "$LINKS_RESULT"
-done
-```
-
-Parse JSON result: `{ all_verified, verified, total, links: [{from, to, via, verified, detail}] }`
-
-**Link status from result:**
-- `verified=true` → WIRED
-- `verified=false` with "not found" → NOT_WIRED
-- `verified=false` with "Pattern not found" → PARTIAL
-
-**Fallback patterns (if key_links not in must_haves):**
-
-| Pattern | Check | Status |
-|---------|-------|--------|
-| Component → API | fetch/axios call to API path, response used (await/.then/setState) | WIRED / PARTIAL (call but unused response) / NOT_WIRED |
-| API → Database | Prisma/DB query on model, result returned via res.json() | WIRED / PARTIAL (query but not returned) / NOT_WIRED |
-| Form → Handler | onSubmit with real implementation (fetch/axios/mutate/dispatch), not console.log/empty | WIRED / STUB (log-only/empty) / NOT_WIRED |
-| State → Render | useState variable appears in JSX (`{stateVar}` or `{stateVar.property}`) | WIRED / NOT_WIRED |
-
-Record status and evidence for each key link.
-</step>
-
-<step name="verify_requirements">
-If REQUIREMENTS.md exists:
-```bash
-grep -E "Phase ${PHASE_NUMBER}" .planning/REQUIREMENTS.md 2>/dev/null || true
-```
-
-For each requirement: parse description → identify supporting truths/artifacts → status: ✓ SATISFIED / ✗ BLOCKED / ? NEEDS HUMAN.
-</step>
-
-<step name="scan_antipatterns">
-Extract files modified in this phase from SUMMARY.md YAML frontmatter fields `key-files.created` and `key-files.modified` (parse the block between the opening and closing `---` delimiters). Scan each listed file:
-
-| Pattern | Search | Severity |
-|---------|--------|----------|
-| TODO/FIXME/XXX/HACK | `grep -n -E "TODO\|FIXME\|XXX\|HACK"` | ⚠️ Warning |
-| Placeholder content | `grep -n -iE "placeholder\|coming soon\|will be here"` | 🛑 Blocker |
-| Empty returns | `grep -n -E "return null\|return \{\}\|return \[\]\|=> \{\}"` | ⚠️ Warning |
-| Log-only functions | Functions containing only console.log | ⚠️ Warning |
-
-Categorize: 🛑 Blocker (prevents goal) | ⚠️ Warning (incomplete) | ℹ️ Info (notable).
-</step>
-
-<step name="audit_test_quality">
-**Verify that tests PROVE what they claim to prove.**
-
-This step catches test-level deceptions that pass all prior checks: files exist, are substantive, are wired, and tests pass — but the tests don't actually validate the requirement.
-
-**1. Identify requirement-linked test files**
-
-From PLAN and SUMMARY files, map each requirement to the test files that are supposed to prove it.
-
-**2. Disabled test scan**
-
-For ALL test files linked to requirements, search for disabled/skipped patterns:
-
-```bash
-grep -rn -E "it\.skip|describe\.skip|test\.skip|xit\(|xdescribe\(|xtest\(|@pytest\.mark\.skip|@unittest\.skip|#\[ignore\]|\.pending|it\.todo|test\.todo" "$TEST_FILE"
-```
-
-**Rule:** A disabled test linked to a requirement = requirement NOT tested.
-- 🛑 BLOCKER if the disabled test is the only test proving that requirement
-- ⚠️ WARNING if other active tests also cover the requirement
-
-**3. Circular test detection**
-
-Search for scripts/utilities that generate expected values by running the system under test:
-
-```bash
-grep -rn -E "writeFileSync|writeFile|fs\.write|open\(.*w\)" "$TEST_DIRS"
-```
-
-For each match, check if it also imports the system/service/module being tested. If a script both imports the system-under-test AND writes expected output values → CIRCULAR.
-
-**Circular test indicators:**
-- Script imports a service AND writes to fixture files
-- Expected values have comments like "computed from engine", "captured from baseline"
-- Script filename contains "capture", "baseline", "generate", "snapshot" in test context
-- Expected values were added in the same commit as the test assertions
-
-**Rule:** A test comparing system output against values generated by the same system is circular. It proves consistency, not correctness.
-
-**4. Expected value provenance** (for comparison/parity/migration requirements)
-
-When a requirement demands comparison with an external source ("identical to X", "matches Y", "same output as Z"):
-
-- Is the external source actually invoked or referenced in the test pipeline?
-- Do fixture files contain data sourced from the external system?
-- Or do all expected values come from the new system itself or from mathematical formulas?
-
-**Provenance classification:**
-- VALID: Expected value from external/legacy system output, manual capture, or independent oracle
-- PARTIAL: Expected value from mathematical derivation (proves formula, not system match)
-- CIRCULAR: Expected value from the system being tested
-- UNKNOWN: No provenance information — treat as SUSPECT
-
-**5. Assertion strength**
-
-For each test linked to a requirement, classify the strongest assertion:
-
-| Level | Examples | Proves |
-|-------|---------|--------|
-| Existence | `toBeDefined()`, `!= null` | Something returned |
-| Type | `typeof x === 'number'` | Correct shape |
-| Status | `code === 200` | No error |
-| Value | `toEqual(expected)`, `toBeCloseTo(x)` | Specific value |
-| Behavioral | Multi-step workflow assertions | End-to-end correctness |
-
-If a requirement demands value-level or behavioral-level proof and the test only has existence/type/status assertions → INSUFFICIENT.
-
-**6. Coverage quantity**
-
-If a requirement specifies a quantity of test cases (e.g., "30 calculations"), check if the actual number of active (non-skipped) test cases meets the requirement.
-
-**Reporting — add to VERIFICATION.md:**
-
-```markdown
-### Test Quality Audit
-
-| Test File | Linked Req | Active | Skipped | Circular | Assertion Level | Verdict |
-|-----------|-----------|--------|---------|----------|----------------|---------|
-
-**Disabled tests on requirements:** {N} → {BLOCKER if any req has ONLY disabled tests}
-**Circular patterns detected:** {N} → {BLOCKER if any}
-**Insufficient assertions:** {N} → {WARNING}
-```
-
-**Impact on status:** Any BLOCKER from test quality audit ��� overall status = `gaps_found`, regardless of other checks passing.
-</step>
-
-<step name="check_code_review_findings">
-Check if a REVIEW.md exists for this phase. If it does, parse critical and high severity counts before writing the verdict:
-
-```bash
-REVIEW_FILE=$(ls "$PHASE_DIR"/*-REVIEW.md 2>/dev/null | head -1)
-if [[ -n "$REVIEW_FILE" ]]; then
-  CRITICAL_COUNT=$(grep -c "severity.*critical\|🔴.*critical\|critical.*🔴" "$REVIEW_FILE" 2>/dev/null || echo 0)
-  HIGH_COUNT=$(grep -c "severity.*high\|🟠.*high\|high.*🟠" "$REVIEW_FILE" 2>/dev/null || echo 0)
-  echo "Code review: ${CRITICAL_COUNT} critical, ${HIGH_COUNT} high findings"
-fi
-```
-
-**If CRITICAL_COUNT > 0:** Add a blocker gap — "Code review found ${CRITICAL_COUNT} critical finding(s) in REVIEW.md — must be resolved before phase passes."
-
-**If HIGH_COUNT > 0:** Add a warning — "Code review found ${HIGH_COUNT} high-severity finding(s) in REVIEW.md — review before shipping."
-
-**If REVIEW.md does not exist:** Skip silently — code review is optional (agent may not have been run).
-
-Record findings in VERIFICATION.md under `## Code Review Integration` section.
-</step>
-
-<step name="identify_human_verification">
-**Always needs human:** Visual appearance, user flow completion, real-time behavior (WebSocket/SSE), external service integration, performance feel, error message clarity.
-
-**Needs human if uncertain:** Complex wiring grep can't trace, dynamic state-dependent behavior, edge cases.
-
-Format each as: Test Name → What to do → Expected result → Why can't verify programmatically.
-</step>
-
-<step name="determine_status">
-Classify status using this decision tree IN ORDER (most restrictive first):
-
-1. IF any truth FAILED, artifact MISSING/STUB, key link NOT_WIRED, blocker found, **test quality audit found blockers (disabled requirement tests, circular tests)**, **or code review found critical findings**:
-   → **gaps_found**
-
-2. IF the previous step produced ANY human verification items:
-   → **human_needed** (even if all truths VERIFIED and score is N/N)
-
-3. IF all checks pass AND no human verification items:
-   → **passed**
-
-**passed is ONLY valid when no human verification items exist.**
-
-**Score:** `verified_truths / total_truths`
-</step>
-
-<step name="filter_deferred_items">
-Before reporting gaps, cross-reference each gap against later phases in the milestone using the full roadmap data loaded in load_context (from `roadmap analyze`).
-
-For each potential gap identified in determine_status:
-1. Check if the gap's failed truth or missing item is covered by a later phase's goal or success criteria
-2. **Match criteria:** The gap's concern appears in a later phase's goal text, success criteria text, or the later phase's name clearly suggests it covers this area
-3. If a clear match is found → move the gap to a `deferred` list with the matching phase reference and evidence text
-4. If no match in any later phase → keep as a real `gap`
-
-**Important:** Be conservative. Only defer a gap when there is clear, specific evidence in a later phase. Vague or tangential matches should NOT cause deferral — when in doubt, keep it as a real gap.
-
-**Deferred items do NOT affect the status determination.** Recalculate after filtering:
-- If gaps list is now empty and no human items exist → `passed`
-- If gaps list is now empty but human items exist → `human_needed`
-- If gaps list still has items → `gaps_found`
-
-Include deferred items in VERIFICATION.md frontmatter (`deferred:` section) and body (Deferred Items table) for transparency. If no deferred items exist, omit these sections.
-</step>
-
-<step name="generate_fix_plans">
-If gaps_found:
-
-1. **Cluster related gaps:** API stub + component unwired → "Wire frontend to backend". Multiple missing → "Complete core implementation". Wiring only → "Connect existing components".
-
-2. **Generate plan per cluster:** Objective, 2-3 tasks (files/action/verify each), re-verify step. Keep focused: single concern per plan.
-
-3. **Order by dependency:** Fix missing → fix stubs → fix wiring → **fix test evidence** → verify.
-</step>
-
-<step name="create_report">
-```bash
-REPORT_PATH="$PHASE_DIR/${PHASE_NUMBER}-VERIFICATION.md"
-```
-
-Fill template sections: frontmatter (phase/timestamp/status/score), goal achievement, artifact table, wiring table, requirements coverage, anti-patterns, human verification, gaps summary, fix plans (if gaps_found), metadata.
-
-See .rihal/templates/verification-report.md for complete template.
-</step>
-
-<step name="return_to_orchestrator">
-Return status (`passed` | `gaps_found` | `human_needed`), score (N/M must-haves), report path.
-
-If gaps_found: list gaps + recommended fix plan names.
-If human_needed: list items requiring human testing.
-
-Orchestrator routes: `passed` → update_roadmap | `gaps_found` → create/execute fixes, re-verify | `human_needed` → present to user.
-</step>
-
-</process>
-
-<success_criteria>
-- [ ] Must-haves established (from frontmatter or derived)
-- [ ] All truths verified with status and evidence
-- [ ] All artifacts checked at all three levels
-- [ ] All key links verified
-- [ ] Requirements coverage assessed (if applicable)
-- [ ] Anti-patterns scanned and categorized
-- [ ] Test quality audited (disabled tests, circular patterns, assertion strength, provenance)
-- [ ] Code review findings checked (REVIEW.md critical/high counts surfaced if file exists)
-- [ ] Human verification items identified
-- [ ] Overall status determined
-- [ ] Deferred items filtered against later milestone phases (if gaps found)
-- [ ] Fix plans generated (if gaps_found after filtering)
-- [ ] VERIFICATION.md created with complete report
-- [ ] Results returned to orchestrator
-</success_criteria>
-
-## ▶ Next Up
-
-- /rihal-complete-milestone
-- /rihal-plan --gaps {phase}
-- /rihal-verify-phase {phase}