@hanzlaa/rcode 3.4.3 → 3.4.5

package/rihal/workflows/plant-seed.md

@@ -146,7 +146,7 @@ node ".rihal/bin/rihal-tools.cjs" commit "docs: plant seed — {$IDEA}" --files
 
 <step name="confirm">
 ```
-✅ Seed planted: SEED-{PADDED}
+✓ Seed planted: SEED-{PADDED}
 
 "{$IDEA}"
 Trigger: {$TRIGGER}

package/rihal/workflows/pr-branch.md

@@ -104,7 +104,7 @@ PR_COMMITS=$(git rev-list --count "$TARGET".."$PR_BRANCH")
 
 Display results:
 ```
-✅ PR branch created: {PR_BRANCH}
+✓ PR branch created: {PR_BRANCH}
 
 Original: {AHEAD} commits, {ORIGINAL_FILES} files
 PR branch: {PR_COMMITS} commits, {TOTAL_FILES} files

package/rihal/workflows/profile-user.md

@@ -137,7 +137,7 @@ node .rihal/bin/rihal-tools.cjs state set-user-profile --json '{json-string}'
 
 Print:
 ```
-✅ Profile saved: {profile_path}
+✓ Profile saved: {profile_path}
 
 Dimensions:
   • Communication: {communication}

package/rihal/workflows/quick.md

@@ -142,7 +142,7 @@ Common blocker types:
 At the end of the loop, summarise:
 
 ```
-✅ Loop complete: {N} done · {M} skipped · {K} blocked
+✓ Loop complete: {N} done · {M} skipped · {K} blocked
    Done:    {bullet list with commit hashes}
    Skipped: {bullet list with reasons}
    Blocked: {bullet list with what info is needed}
@@ -165,7 +165,7 @@ If `.planning/STATE.md` exists with a "Quick Tasks Completed" table, append:
 
 ```bash
 if grep -q "Quick Tasks Completed" .planning/STATE.md 2>/dev/null; then
-  echo "| $(date +%Y-%m-%d) | quick | $TASK | ✅ |" >> .planning/STATE.md
+  echo "| $(date +%Y-%m-%d) | quick | $TASK | ✓ |" >> .planning/STATE.md
 fi
 ```
 
@@ -176,7 +176,7 @@ Skip silently if the table doesn't exist.
 Report completion:
 
 ```
-✅ Done: {what was changed}
+✓ Done: {what was changed}
    Commit: {short hash}
    Files:  {list of changed files}
 ```

package/rihal/workflows/remove-phase.md

@@ -29,10 +29,15 @@ Exit.
 Load phase operation context:
 
 ```bash
-INIT=$(node ".rihal/bin/rihal-tools.cjs" init phase-op "${target}")
+INIT=$(node ".rihal/bin/rihal-tools.cjs" init phase-op "${target}" 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: `phase_found`, `phase_dir`, `phase_number`, `commit_docs`, `roadmap_exists`.
 
 Also read STATE.md and ROADMAP.md content for parsing current position.

package/rihal/workflows/remove-workspace.md

@@ -94,6 +94,12 @@ echo "✓ Workspace archived: $ARCHIVE_PATH"
 ## Step 5 — Delete workspace directory
 
 ```bash
+PROJECT_ROOT="$(pwd)"
+REAL_WS="$(realpath "$WORKSPACE_PATH" 2>/dev/null || echo "")"
+if [[ -z "$REAL_WS" || "$REAL_WS" != "$PROJECT_ROOT"/* ]]; then
+  echo "⚠ SECURITY: workspace path '$WORKSPACE_PATH' escapes project root — aborting"
+  exit 1
+fi
 rm -rf "$WORKSPACE_PATH"
 ```
 

package/rihal/workflows/rerun.md

@@ -55,7 +55,7 @@ Write updated state.json back
 
 ## Step 3: Invoke Execute
 
-Route to `/rihal-execute-phase {target.id}`
+Route to `/rihal-execute {target.id}`
 
 The executor will:
 - See status=pending in state.json

package/rihal/workflows/research-phase.md

@@ -39,9 +39,11 @@ If exists: Offer update/view/skip options.
 ## Step 3: Gather Phase Context
 
 ```bash
-INIT=$(node ".rihal/bin/rihal-tools.cjs" init phase-op "${PHASE}")
+INIT=$(node ".rihal/bin/rihal-tools.cjs" init phase-op "${PHASE}" 2>/dev/null)
 if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
-# Extract: phase_dir, padded_phase, phase_number, state_path, requirements_path, context_path
+# If INIT is empty or INIT.ok is false: print "Error: rihal-tools init failed." and exit.
+# Extract: phase_dir, padded_phase, phase_number, state_path, requirements_path, context_path, response_language
+# If response_language is set, include "Respond in {value}." in all spawned subagent prompts.
 AGENT_SKILLS_RESEARCHER=$(node ".rihal/bin/rihal-tools.cjs" agent-skills rihal-researcher 2>/dev/null)
 ```
 

package/rihal/workflows/resume-work.md

@@ -20,10 +20,15 @@ Instantly restore full project context so "Where were we?" has an immediate, com
 Load all context in one call:
 
 ```bash
-INIT=$(node ".rihal/bin/rihal-tools.cjs" init resume)
+INIT=$(node ".rihal/bin/rihal-tools.cjs" init resume 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. Is .rihal/ installed? Run: npx @hanzlaa/rcode install
+```
+
 Parse JSON for: `state_exists`, `roadmap_exists`, `project_exists`, `planning_exists`, `has_interrupted_agent`, `interrupted_agent_id`, `commit_docs`.
 
 **If `state_exists` is true:** Proceed to load_state
@@ -200,7 +205,7 @@ What would you like to do?
 [Primary action based on state - e.g.:]
 1. Resume interrupted agent [if interrupted agent found]
    OR
-1. Execute phase (/rihal-execute-phase {phase} ${Rihal_WS})
+1. Execute phase (/rihal-execute {phase} ${Rihal_WS})
    OR
 1. Discuss Phase 3 context (/rihal-discuss-phase 3 ${Rihal_WS}) [if CONTEXT.md missing]
    OR
@@ -237,7 +242,7 @@ Based on user selection, route to appropriate workflow:
 
   `/clear` then:
 
-  `/rihal-execute-phase {phase} ${Rihal_WS}`
+  `/rihal-execute {phase} ${Rihal_WS}`
 
   ---
   ```

package/rihal/workflows/retrospective.md

@@ -0,0 +1,31 @@
+# Workflow: rihal-retrospective
+
+<purpose>
+Run an epic retrospective and produce owned action items. Delegates to the rihal-retrospective skill.
+</purpose>
+
+## Execution
+
+Locate and follow the installed skill:
+
+```bash
+find .rihal/skills/actions -path "*rihal-retrospective/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-correct-course — act on retrospective findings
+/rihal-plan {next} — plan the next phase with retro learnings applied
+/rihal-note — capture retro summary in project memory
+
+## ▶ Next Up
+
+- **Retrospective complete:** `/rihal-new-milestone` — start the next milestone
+- **Review project state:** `/rihal-progress` — see current roadmap position
+- **Archive milestone:** `/rihal-complete-milestone` — if not already done

package/rihal/workflows/review-adversarial.md

@@ -178,3 +178,15 @@ Critical findings filed as blocking AC. High findings as optional tasks.
 - If subagent fails: provide template adversarial review structure
 - If files too large: split review across multiple components
 - If no findings: report "No vulnerabilities found" (document assumptions)
+
+## On Completion
+
+/rihal-plan {phase} --reviews — incorporate findings into next plan
+/rihal-code-review-fix — apply suggested fixes
+/rihal-council — escalate contested findings to the full council
+
+## ▶ Next Up
+
+- **Vulnerabilities found:** Address security findings, re-run `/rihal-review-adversarial`
+- **Clean report:** `/rihal-verify-phase {phase}` — full verification
+- **Ship:** `/rihal-ship {phase}` — package the phase

package/rihal/workflows/review.md

@@ -279,3 +279,9 @@ Clean up temp files.
 - [ ] Temp files cleaned up
 - [ ] User knows how to use feedback (/rihal-plan --reviews)
 </success_criteria>
+
+## ▶ Next Up
+
+- **Issues found:** Fix identified problems, then re-run `/rihal-review`
+- **Review passed:** `/rihal-ship {phase}` — package phase for shipping
+- **Security concern:** `/rihal-secure-phase {phase}` — targeted security review

package/rihal/workflows/scaffold-project.md

@@ -0,0 +1,31 @@
+# Workflow: rihal-scaffold-project
+
+<purpose>
+Scaffold a new project from the official Rihal template repo. Delegates to the rihal-scaffold-project skill.
+</purpose>
+
+## Execution
+
+Locate and follow the installed skill:
+
+```bash
+find .rihal/skills/actions -path "*rihal-scaffold-project/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-init — configure Rihal for the scaffolded project
+/rihal-new-project {name} — design the project with full facilitation
+/rihal-create-prd — write the product requirements document
+
+## ▶ Next Up
+
+- **Project scaffolded:** `/rihal-create-prd` — define what you're building
+- **Already have requirements:** `/rihal-create-milestone` — jump straight to roadmap
+- **Quick start:** `/rihal-do` — interactive router shows your next best step

package/rihal/workflows/scan.md

@@ -77,6 +77,8 @@ INIT=$(node "$PROJECT_ROOT/.rihal/bin/rihal-tools.cjs" init scan 2>/dev/null ||
 if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 ```
 
+Extract `response_language` from INIT JSON. If set, include `Respond in {response_language}.` in all spawned subagent prompts.
+
 Look up which documents would be produced for the selected focus (from the mapping table above).
 
 For each target document, check if it already exists in `.planning/codebase/`:
@@ -225,6 +227,7 @@ Task(
 
   This scope section is non-negotiable — the orchestrator will reject documents missing it.",
   subagent_type="rihal-codebase-mapper",
+  model="sonnet",
   model="{resolved_model}"
 )
 ```
@@ -370,3 +373,10 @@ If arguments are invalid, missing files, or subagent fails:
 - Check that required files exist
 - Retry with clearer arguments or report the specific error to the user
 
+
+## On Completion
+
+/rihal-council {your question} — strategic question about what was found
+/rihal-plan {N} — plan fixes for discovered issues
+/rihal-explore — go deeper with socratic analysis
+/rihal-next — get suggested next action

package/rihal/workflows/secure-phase.md

@@ -33,12 +33,19 @@ If `$ARGUMENTS` is empty or contains only `--help` or `-h`:
 ## 0. Initialize
 
 ```bash
-INIT=$(node ".rihal/bin/rihal-tools.cjs" init phase-op "${PHASE_ARG}")
+INIT=$(node ".rihal/bin/rihal-tools.cjs" init phase-op "${PHASE_ARG}" 2>/dev/null)
 if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 AGENT_SKILLS_AUDITOR=$(node ".rihal/bin/rihal-tools.cjs" agent-skills rihal-security-auditor 2>/dev/null)
 ```
 
-Parse: `phase_dir`, `phase_number`, `phase_name`, `phase_slug`, `padded_phase`.
+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.
+```
+
+Parse: `phase_dir`, `phase_number`, `phase_name`, `phase_slug`, `padded_phase`, `response_language`.
+
+**If `response_language` is set:** include `Respond in {response_language}.` in all spawned subagent prompts.
 
 ```bash
 AUDITOR_MODEL=$(node ".rihal/bin/rihal-tools.cjs" resolve-model rihal-security-auditor --raw)
@@ -194,3 +201,9 @@ If arguments are invalid, missing files, or subagent fails:
 - Check that required files exist
 - Retry with clearer arguments or report the specific error to the user
 
+
+## ▶ Next Up
+
+- **Issues found:** Address security findings, then re-run `/rihal-secure-phase {phase}`
+- **Clean report:** `/rihal-verify-phase {phase}` — run full verification
+- **Continue execution:** `/rihal-execute {next-phase}` — proceed to next phase

package/rihal/workflows/session-report.md

@@ -77,21 +77,40 @@ Extract counts:
 
 ## Step 5 — Estimate token usage
 
-Calculate estimated tokens (note: this is an estimate, not actual measurement):
+Calculate estimated tokens (note: these are rough approximations, not actual measurements).
 
-- **Council sessions:** count × 50,000 tokens (5 agents × 2 rounds × ~5K avg per agent)
-- **Chains:** count × 30,000 tokens (3-5 stages × ~8K avg per stage)
-- **Discusses:** count × 10,000 tokens (single agent, focused conversation)
-- **Execute:** (executions count) × 20,000 tokens (estimation only)
+Read context_window from config to calibrate multipliers:
 
-**Total estimate:** sum of above (with disclaimer)
+```bash
+CW=$(node .rihal/bin/rihal-tools.cjs config-get context_window 2>/dev/null || echo "200000")
+```
+
+Scale multipliers: if `CW >= 500000`, multiply by 2× (larger context windows → more content read per agent turn).
+
+| Artifact type | Base tokens | Rationale |
+|---------------|-------------|-----------|
+| Council session | 50,000 | 5 agents × 2 rounds × ~5K avg |
+| Chain | 30,000 | 3–5 stages × ~8K avg |
+| Discuss | 10,000 | single agent, focused |
+| Execute | 20,000 | executor + verifier per plan |
+
+Apply context window scale: `estimate = base × max(1, CW / 200000)`
+
+**Total estimate:** sum of above, rounded to nearest 1K (with clear disclaimer: "Rough estimate — actual usage depends on codebase size, plan length, and model")
+
+**Note for accuracy:** actual token counts require the `/usage` endpoint or Claude Code session logs. These multipliers are 2024 baselines updated for 1M-context models.
 
 ## Step 6 — List commits
 
 Get commits touching rihal paths since state creation:
 
 ```bash
-git log --since="$(date -d '$(cat .rihal/state.json | jq -r .created)' '+%Y-%m-%dT%H:%M:%S')" --oneline -- .rihal rihal/ .planning 2>/dev/null || git log --all --oneline -- .rihal rihal/ .planning 2>/dev/null | head -20
+SINCE_DATE=$(node -e "try{const s=require('fs').readFileSync('.rihal/state.json','utf8');console.log(JSON.parse(s).created||'')}catch(e){}" 2>/dev/null)
+if [[ -n "$SINCE_DATE" ]]; then
+  git log --since="$SINCE_DATE" --oneline -- .rihal rihal/ .planning 2>/dev/null | head -20
+else
+  git log --all --oneline -- .rihal rihal/ .planning 2>/dev/null | head -20
+fi
 ```
 
 Extract commit hashes and subjects. If git errors, report gracefully (project may not be git-based).
@@ -185,3 +204,9 @@ Then print summary:
 - **Git not available:** report gracefully ("Git not available, skipping commit history.").
 - **Write permission denied to .planning/:** print error and stop.
 - **Insufficient readable history:** report gracefully and skip that section.
+
+## On Completion
+
+/rihal-progress — see full roadmap status
+/rihal-next — get suggested next action
+/rihal-resume-work — pick up where you left off

package/rihal/workflows/ship.md

@@ -44,10 +44,15 @@ Read all files referenced by the invoking prompt's execution_context before star
 Parse arguments and load project state:
 
 ```bash
-INIT=$(node ".rihal/bin/rihal-tools.cjs" init phase-op "${PHASE_ARG}")
+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.
+```
+
 Parse from init JSON: `phase_found`, `phase_dir`, `phase_number`, `phase_name`, `padded_phase`, `commit_docs`.
 
 Also load config for branching strategy:
@@ -257,7 +262,7 @@ After shipping:
 
 - /rihal-complete-milestone — if all phases in milestone are done
 - /rihal-progress — see overall project state
-- /rihal-execute-phase {next} — continue to next phase
+- /rihal-execute {next} — continue to next phase
 </offer_next>
 
 <success_criteria>

package/rihal/workflows/show.md

@@ -61,3 +61,9 @@ Separate multiple plans with `---\n`
 - ID unresolvable → Show resolve-id error message
 - SPRINT.md missing → "File not found: {path}"
 - state.json corrupt → Omit execution status, continue
+
+## On Completion
+
+/rihal-execute {phase} — execute this phase
+/rihal-plan {phase} — revise the plan
+/rihal-progress — see full roadmap

package/rihal/workflows/sprint-status.md

@@ -41,12 +41,12 @@ STOP — do not proceed.
 ## Step 1 — Load sprint data
 
 ```bash
-SPRINT_STATUS=$(node .rihal/bin/rihal-tools.cjs state sprint status)
-VELOCITY=$(node .rihal/bin/rihal-tools.cjs state sprint velocity)
-STORIES=$(node .rihal/bin/rihal-tools.cjs state story list)
+SPRINT_STATUS=$(node .rihal/bin/rihal-tools.cjs state sprint status 2>/dev/null || echo "")
+VELOCITY=$(node .rihal/bin/rihal-tools.cjs state sprint velocity 2>/dev/null || echo "0")
+STORIES=$(node .rihal/bin/rihal-tools.cjs state story list 2>/dev/null || echo "")
 ```
 
-If no current sprint:
+If `SPRINT_STATUS` is empty:
 ```
 No active sprint. Run /rihal-sprint-planning to create one.
 ```

package/rihal/workflows/status.md

@@ -57,7 +57,7 @@ the weighted bar as the primary progress indicator to avoid a misleading `0/N (0
 For each entry in `SNAPSHOT.phases[]`:
 
 - `▶` if `phase.number === SNAPSHOT.current_phase`
-- `✓` if `phase.disk.summary_count > 0` AND matches `phase.disk.plan_count` (complete)
+- `✓` if `phase.disk.summary_count > 0` AND matches `phase.disk.plan_count` AND `phase.disk.has_verification` (complete + verified; if VERIFICATION.md absent, use `◎` and label "complete-unverified")
 - `◆` if `phase.disk.plan_count > phase.disk.summary_count` (executing — has plans, not all summarized)
 - `◇` if `phase.disk.has_context && !phase.disk.plan_count` (discussing — CONTEXT.md exists but no plan yet)
 - `◈` if `phase.disk.has_research && !phase.disk.plan_count` (researched — RESEARCH.md but no plan)
@@ -89,7 +89,7 @@ Do NOT hide insights. They exist because the CLI noticed something the workflow
 ## Step 5 — Recent decisions + blockers
 
 - If `SNAPSHOT.decisions.length > 0`, print the last 3 (most recent first).
-- If `SNAPSHOT.blockers.length > 0`, render each with ⚠ and the blocker description.
+- If `SNAPSHOT.blockers.length > 0`, render each with ⚠, the blocker description, and its age. Compute age from `blocker.date` to now: if > 7 days, append `(⚡ {N} days old)` in amber; if > 30 days, append `(🔥 {N} days — stale)`. If no `date` field, render `(age unknown)`.
 
 Omit a section entirely when its array is empty.
 

package/rihal/workflows/ui-phase.md

@@ -81,7 +81,7 @@ node .rihal/bin/rihal-tools.cjs state set --ui-spec-path ".rihal/UI-SPEC.md"
 
 Print:
 ```
-✅ UI-SPEC.md generated: {ui_spec_path}
+✓ UI-SPEC.md generated: {ui_spec_path}
 
 Contains:
   • Color Tokens

package/rihal/workflows/undo.md

@@ -20,8 +20,6 @@ If `$ARGUMENTS` is empty or contains only `--help` or `-h`:
 STOP — do not proceed.
 
 <required_reading>
-@.rihal/references/ui-brand.md
-@.rihal/references/gate-prompts.md
 </required_reading>
 
 <process>
@@ -149,7 +147,8 @@ EOF
   exit 0
 fi
 
-mapfile -t COMMITS < <(git log --pretty=format:%H --no-merges "${SNAPSHOT_TAG}..HEAD")
+COMMITS=()
+while IFS= read -r line; do [[ -n "$line" ]] && COMMITS+=("$line"); done < <(git log --pretty=format:%H --no-merges "${SNAPSHOT_TAG}..HEAD")
 ```
 
 If the range is empty (HEAD is already at the snapshot):

package/rihal/workflows/update.md

@@ -94,7 +94,7 @@ Count each category. Store results in `$ADDED`, `$CHANGED`, `$REMOVED` (arrays o
 
 If all three lists are empty:
 ```
-✅ rihal-code is up to date (no changes detected)
+✓ rihal-code is up to date (no changes detected)
 ```
 Exit.
 
@@ -213,7 +213,7 @@ If the user passed a version argument (`/rihal-update v1.3.0`), pass it through
 Print:
 
 ```
-✅ rihal-code updated successfully
+✓ rihal-code updated successfully
 
 Updated files: N
   - file-path-1

package/rihal/workflows/validate-phase.md

@@ -42,7 +42,7 @@ 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-phase {N} ${Rihal_WS} first."
+- **State C** (`SUMMARY_FILES` empty): Exit — "Phase {N} not executed. Run /rihal-execute {N} ${Rihal_WS} first."
 
 ## 2. Discovery
 

package/rihal/workflows/validate-prd.md

@@ -0,0 +1,31 @@
+# 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-create-milestone — build the roadmap from the validated PRD
+/rihal-edit-prd — fix validation findings
+/rihal-council — escalate ambiguous requirements to the council
+
+## ▶ Next Up
+
+- **PRD valid:** `/rihal-create-milestone` — design M1..Mn roadmap
+- **Gaps found:** `/rihal-edit-prd` — fill in missing sections
+- **Need council review:** `/rihal-council {prd-question}` — debate key decisions

package/rihal/workflows/verify-phase.md

@@ -30,10 +30,15 @@ Then verify each level against the actual codebase.
 Load phase operation context:
 
 ```bash
-INIT=$(node ".rihal/bin/rihal-tools.cjs" init phase-op "${PHASE_ARG}")
+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:
@@ -178,14 +183,14 @@ Record status and evidence for each key link.
 <step name="verify_requirements">
 If REQUIREMENTS.md exists:
 ```bash
-grep -E "Phase ${PHASE_NUM}" .planning/REQUIREMENTS.md 2>/dev/null || true
+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, scan each:
+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 |
 |---------|--------|----------|
@@ -284,6 +289,27 @@ If a requirement specifies a quantity of test cases (e.g., "30 calculations"), c
 **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.
 
@@ -295,7 +321,7 @@ Format each as: Test Name → What to do → Expected result → Why can't verif
 <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, **or test quality audit found blockers (disabled requirement tests, circular tests)**:
+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:
@@ -340,7 +366,7 @@ If gaps_found:
 
 <step name="create_report">
 ```bash
-REPORT_PATH="$PHASE_DIR/${PHASE_NUM}-VERIFICATION.md"
+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.
@@ -367,6 +393,7 @@ Orchestrator routes: `passed` → update_roadmap | `gaps_found` → create/execu
 - [ ] 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)
@@ -374,3 +401,9 @@ Orchestrator routes: `passed` → update_roadmap | `gaps_found` → create/execu
 - [ ] VERIFICATION.md created with complete report
 - [ ] Results returned to orchestrator
 </success_criteria>
+
+## ▶ Next Up
+
+- **Verification passed:** `/rihal-complete-milestone` (if all phases done) or `/rihal-execute` for next phase
+- **Gaps found:** `/rihal-plan --gaps {phase}` — plan gap-closure tasks
+- **Re-verify after fixes:** `/rihal-verify-phase {phase}`