@hanzlaa/rcode 3.4.3 → 3.4.5

package/rihal/workflows/capture.md

@@ -0,0 +1,60 @@
+<purpose>
+Unified capture command. Routes a single user gesture to the right Memory Bank surface based on flags: todo (default — actionable item), note (passive observation), seed (forward-looking idea with trigger conditions), or list (show pending todos). Replaces the muscle-memory pattern of remembering which of /rihal-add-todo, /rihal-note, /rihal-plant-seed, /rihal-check-todos to invoke.
+</purpose>
+
+## Step 0 — Usage check
+
+If `$ARGUMENTS` is empty AND no flag is set:
+
+```
+/rihal-capture <text>                        # save as todo (default)
+/rihal-capture --note <text>                 # passive observation
+/rihal-capture --seed <text>                 # forward-looking with trigger
+/rihal-capture --list [--area <area>]        # show pending todos
+```
+
+STOP — do not proceed.
+
+## Step 1 — Parse mode flags
+
+Inspect `$ARGUMENTS` for mode flags. Exactly one mode applies:
+
+- `--note` → note mode (delegates to add-note workflow)
+- `--seed` → seed mode (delegates to plant-seed workflow)
+- `--list` → list mode (delegates to check-todos workflow)
+- (none) → todo mode (default, delegates to add-todo workflow)
+
+After determining mode, strip the mode flag from `$ARGUMENTS` and pass the remaining text to the underlying workflow.
+
+## Step 2 — Dispatch to underlying workflow
+
+Each mode is implemented by an existing workflow. Load and execute end-to-end:
+
+- **todo (default):** read and execute `@.rihal/workflows/add-todo.md` with the cleaned `$ARGUMENTS`. Output identical to `/rihal-add-todo`.
+- **note (`--note`):** read and execute `@.rihal/workflows/note.md`. Output identical to `/rihal-note`.
+- **seed (`--seed`):** read and execute `@.rihal/workflows/plant-seed.md`. Output identical to `/rihal-plant-seed`.
+- **list (`--list`):** read and execute `@.rihal/workflows/check-todos.md`. Output identical to `/rihal-check-todos`.
+
+The underlying workflows are unchanged — `/rihal-capture` is a thin router. Behaviour, output format, and side effects are byte-identical to invoking the underlying command directly. This means `/rihal-add-todo "X"` and `/rihal-capture "X"` produce the same disk writes and the same console output.
+
+## Step 3 — Footer
+
+After the underlying workflow's normal output, append a single line indicating the mode that was selected:
+
+```
+(rihal-capture: routed to {todo|note|seed|list} mode)
+```
+
+This is invisible polish — confirms to the user that the dispatch was correct.
+
+## Migration note
+
+The four absorbed commands continue to work and are not deprecated yet — they remain canonical aliases. `/rihal-capture` exists as the unified entry for users who want one command to remember instead of four. Future minor versions may consolidate further; until then, both invocation paths are first-class.
+
+## Acceptance
+
+- [ ] `/rihal-capture "fix nav"` produces the same artefacts as `/rihal-add-todo "fix nav"`
+- [ ] `/rihal-capture --note "hex codes everywhere"` produces the same artefacts as `/rihal-note "hex codes everywhere"`
+- [ ] `/rihal-capture --seed "scale to 1k users"` produces the same artefacts as `/rihal-plant-seed "scale to 1k users"`
+- [ ] `/rihal-capture --list` produces the same output as `/rihal-check-todos`
+- [ ] No flag combinations are silently ignored — unknown flags surface as a clear error

package/rihal/workflows/chain.md

@@ -116,7 +116,7 @@ If missing, the stage failed — print which stage, stop the chain, allow user t
 
 ### Print stage summary
 ```
-✅ Stage {N}/{total} — {agent}: {artifact filename}
+✓ Stage {N}/{total} — {agent}: {artifact filename}
 ```
 
 ## Step 3 — Final output

package/rihal/workflows/code-review-fix.md

@@ -207,7 +207,8 @@ echo "Fix scope: ${FIX_SCOPE}"
 Use Task() to spawn agent:
 
 ```
-Task(subagent_type="rihal-code-fixer", prompt="
+Task(subagent_type="rihal-code-fixer",
+  model="sonnet", prompt="
 <files_to_read>
 ${REVIEW_PATH}
 </files_to_read>
@@ -288,7 +289,8 @@ if [ "$AUTO_MODE" = "true" ]; then
     
     # Spawn rihal-code-reviewer agent to re-review
     # (This overwrites REVIEW_PATH with latest review state)
-    Task(subagent_type="rihal-code-reviewer", prompt="
+    Task(subagent_type="rihal-code-reviewer",
+  model="sonnet", prompt="
 <config>
 depth: ${REVIEW_DEPTH}
 phase_dir: ${PHASE_DIR}
@@ -321,7 +323,8 @@ Do NOT commit the output — the orchestrator handles that.
     # Still has issues — spawn fixer again
     echo "Issues remain. Applying fixes for iteration ${ITERATION}..."
     
-    Task(subagent_type="rihal-code-fixer", prompt="
+    Task(subagent_type="rihal-code-fixer",
+  model="sonnet", prompt="
 <files_to_read>
 ${REVIEW_PATH}
 </files_to_read>

package/rihal/workflows/code-review.md

@@ -66,11 +66,18 @@ Parse arguments and load project state:
 
 ```bash
 PHASE_ARG="${1}"
-INIT=$(node "$PROJECT_ROOT/.rihal/bin/rihal-tools.cjs" init phase-op "${PHASE_ARG}")
+INIT=$(node "$PROJECT_ROOT/.rihal/bin/rihal-tools.cjs" init phase-op "${PHASE_ARG}" 2>/dev/null)
 if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 ```
 
-Parse from init JSON: `phase_found`, `phase_dir`, `phase_number`, `phase_name`, `padded_phase`, `commit_docs`.
+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`, `response_language`.
+
+**If `response_language` is set:** include `Respond in {response_language}.` in all spawned subagent prompts.
 
 **Input sanitization (defense-in-depth):**
 ```bash
@@ -381,7 +388,8 @@ done
 Spawn the rihal-code-reviewer agent:
 
 ```
-Task(subagent_type="rihal-code-reviewer", prompt="
+Task(subagent_type="rihal-code-reviewer",
+  model="sonnet", prompt="
 <files_to_read>
 ${FILES_TO_READ}
 </files_to_read>
@@ -397,6 +405,20 @@ ${CONFIG_FILES}
 
 Review the listed source files at ${REVIEW_DEPTH} depth. Write findings to ${REVIEW_PATH}.
 Do NOT commit the output — the orchestrator handles that.
+
+The REVIEW.md file MUST begin with YAML frontmatter in exactly this format:
+---
+status: clean | issues_found | skipped
+phase: <phase_number or HEAD~N..HEAD>
+files_reviewed: <count>
+critical: <count>
+high: <count>
+medium: <count>
+low: <count>
+generated: <ISO timestamp>
+---
+
+Use severity: critical (must fix, security/data-loss/broken), high (should fix, correctness/coverage), medium (consider, poor patterns), low (optional, style/naming).
 ")
 ```
 
@@ -496,10 +518,11 @@ FRONTMATTER=$(sed -n '2,/^---$/p' "${REVIEW_PATH}" 2>/dev/null | head -n -1)
 # Parse fields from frontmatter only (not full file)
 STATUS=$(echo "$FRONTMATTER" | grep "^status:" | cut -d: -f2 | xargs)
 FILES_REVIEWED=$(echo "$FRONTMATTER" | grep "^files_reviewed:" | cut -d: -f2 | xargs)
-CRITICAL=$(echo "$FRONTMATTER" | grep "critical:" | head -1 | cut -d: -f2 | xargs)
-WARNING=$(echo "$FRONTMATTER" | grep "warning:" | head -1 | cut -d: -f2 | xargs)
-INFO=$(echo "$FRONTMATTER" | grep "info:" | head -1 | cut -d: -f2 | xargs)
-TOTAL=$(echo "$FRONTMATTER" | grep "total:" | head -1 | cut -d: -f2 | xargs)
+CRITICAL=$(echo "$FRONTMATTER" | grep "^critical:" | head -1 | cut -d: -f2 | xargs)
+HIGH=$(echo "$FRONTMATTER" | grep "^high:" | head -1 | cut -d: -f2 | xargs)
+MEDIUM=$(echo "$FRONTMATTER" | grep "^medium:" | head -1 | cut -d: -f2 | xargs)
+LOW=$(echo "$FRONTMATTER" | grep "^low:" | head -1 | cut -d: -f2 | xargs)
+TOTAL=$(( ${CRITICAL:-0} + ${HIGH:-0} + ${MEDIUM:-0} + ${LOW:-0} ))
 ```
 
 Display inline summary to user:
@@ -516,8 +539,9 @@ Display inline summary to user:
   
   Findings:
     Critical:  ${CRITICAL}
-    Warning:   ${WARNING}
-    Info:      ${INFO}
+    High:      ${HIGH}
+    Medium:    ${MEDIUM}
+    Low:       ${LOW}
     ──────────
     Total:     ${TOTAL}
 
@@ -542,7 +566,7 @@ Next steps:
   cat ${REVIEW_PATH}                       — View full report
 ```
 
-If critical > 0 or warning > 0, list top 3 issues inline:
+If critical > 0 or high > 0, list top 3 issues inline:
 ```bash
 echo "Top issues:"
 grep -A 3 "^### CR-\|^### WR-" "${REVIEW_PATH}" | head -n 12

package/rihal/workflows/complete-milestone.md

@@ -64,7 +64,7 @@ Read `.planning/ROADMAP.md` directly and parse phase statuses. Use this to verif
 
 ```bash
 ls -1 .planning/phases/*/SUMMARY.md 2>/dev/null | wc -l
-ls -1 .planning/phases/*/PLAN.md .planning/phases/*/*-PLAN.md 2>/dev/null | wc -l
+ls -1 .planning/phases/*/*-SPRINT.md 2>/dev/null | wc -l
 ```
 
 **Requirements completion check (REQUIRED before presenting):**
@@ -150,7 +150,14 @@ Calculate milestone statistics:
 ```bash
 git log --oneline --grep="feat(" | head -20
 git diff --stat FIRST_COMMIT..LAST_COMMIT | tail -1
-find . -name "*.swift" -o -name "*.ts" -o -name "*.py" -o -name "*.tsx" -o -name "*.js" | xargs wc -l 2>/dev/null || true
+find . \
+  -not -path '*/node_modules/*' \
+  -not -path '*/dist/*' \
+  -not -path '*/.next/*' \
+  -not -path '*/.venv/*' \
+  -not -path '*/__pycache__/*' \
+  \( -name "*.swift" -o -name "*.ts" -o -name "*.py" -o -name "*.tsx" -o -name "*.js" \) \
+  | head -500 | xargs wc -l 2>/dev/null | tail -1 || true
 git log --format="%ai" FIRST_COMMIT | tail -1
 git log --format="%ai" LAST_COMMIT | head -1
 ```
@@ -242,10 +249,12 @@ Write with the Write tool (append-preserving — Read MILESTONES.md first if it
 
 Full PROJECT.md evolution review at milestone completion.
 
-Read all phase summaries:
+Read all phase summaries (capped to first 30 lines each, max 20 files):
 
 ```bash
-cat .planning/phases/*/*-SUMMARY.md .planning/phases/*/SUMMARY.md 2>/dev/null
+find .planning/phases/ -maxdepth 3 \( -name '*-SUMMARY.md' -o -name 'SUMMARY.md' \) | head -20 | while IFS= read -r f; do
+  echo "=== $f ===" && head -30 "$f"
+done
 ```
 
 **Full review checklist:**
@@ -407,7 +416,7 @@ status: completed
 
 ```
 
-Verify: `✅ Milestone archived to .planning/milestones/`
+Verify: `✓ Milestone archived to .planning/milestones/`
 
 **Phase archival (optional):** Ask the user via AskUserQuestion:
 
@@ -425,7 +434,7 @@ mkdir -p "$ARCHIVE_DIR"
 find .planning/phases -mindepth 1 -maxdepth 1 -type d -exec mv {} "$ARCHIVE_DIR/" \;
 ```
 
-Verify: `✅ Phase directories archived to .planning/milestones/v[X.Y]-phases/`
+Verify: `✓ Phase directories archived to .planning/milestones/v[X.Y]-phases/`
 
 If "Skip": Phase directories remain in `.planning/phases/` as raw execution history. Use `/rihal-cleanup` later to archive retroactively.
 
@@ -444,14 +453,14 @@ After archival, reorganize ROADMAP.md with milestone groupings, then delete orig
 
 ## Milestones
 
-- ✅ **v1.0 MVP** — Phases 1-4 (shipped YYYY-MM-DD)
+- ✓ **v1.0 MVP** — Phases 1-4 (shipped YYYY-MM-DD)
 - 🚧 **v1.1 Security** — Phases 5-6 (in progress)
 - 📋 **v2.0 Redesign** — Phases 7-10 (planned)
 
 ## Phases
 
 <details>
-<summary>✅ v1.0 MVP (Phases 1-4) — SHIPPED YYYY-MM-DD</summary>
+<summary>✓ v1.0 MVP (Phases 1-4) — SHIPPED YYYY-MM-DD</summary>
 
 - [x] Phase 1: Foundation (2/2 plans) — completed YYYY-MM-DD
 - [x] Phase 2: Authentication (2/2 plans) — completed YYYY-MM-DD

package/rihal/workflows/correct-course.md

@@ -188,3 +188,9 @@ Run remediation with:
 - If PRD missing: skip scope/AC analysis, focus on architecture
 - If architecture missing: skip architecture analysis, focus on features
 - If agents fail: provide template deviation/remediation structure
+
+## ▶ Next Up
+
+- **Course corrected:** `/rihal-execute {phase}` — resume execution with updated direction
+- **Plan needs updating:** `/rihal-plan {phase}` — re-plan affected phase
+- **Check project state:** `/rihal-progress` — verify deviation was contained

package/rihal/workflows/council.md

@@ -12,7 +12,8 @@ Open with banner:
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 Question: {$ARGUMENTS}
-Panel: {N} agents selected by keyword scoring
+Domain:   {domain from scores — fe / be / ml / deploy / strategic / market / general}
+Panel:    {N} agents selected by intent scoring
 ```
 TaskCreate: "Classify question type", "Select panel ({N} agents)", "Spawn agents in parallel", "Collect + synthesize responses", "Write artifact to council-sessions/".
 Per-agent spawn indicator:
@@ -28,6 +29,7 @@ Closure: `RIHAL ► COUNCIL COMPLETE ✓` + Next Up with decision options.
 
 <required_reading>
 @.rihal/references/output-format.md
+@.rihal/references/council-protocol.md
 </required_reading>
 
 <process>
@@ -92,15 +94,8 @@ After Step 0.6 confirmation, proceed to load references by Reading:
 <available_agent_types>
 Read the `installed_agents` array from INIT_JSON. Every entry can be invoked as
 `subagent_type: "rihal-{id}"`. The classifier and panel scorer will surface only
-agents present in this list.
-
-Currently registered council agents (always available if installed):
-- rihal-sadiq, rihal-waleed, rihal-fatima, rihal-mariam, rihal-hussain-pm
-
-Specialist agents that may be installed (add to panel if scorer surfaces them):
-- rihal-ux-designer, rihal-noor
-- rihal-codebase-mapper, rihal-project-researcher, rihal-roadmapper
-- (and any other rihal-* agent in installed_agents)
+agents present in this list — **do not hardcode agent names here**, use the live
+list from INIT_JSON so new agents added to team.yaml are automatically available.
 
 Do not invoke `general-purpose` or any agent type not present in
 `installed_agents`. If the scorer surfaces an unknown agent, drop it
@@ -160,19 +155,23 @@ Parse the JSON for:
 - `paths` — `{ state, planning_root, sessions_dir, references_dir }`
 - `state_exists` — boolean, `.rihal/state.json` present
 - `installed_agents` — the authoritative list of installed agent ids (for validation)
+- `response_language` — output language from config (null = English)
 
 **If the panel contains any id not in `installed_agents`:** stop, print `Unknown agent: {id}. Installed: {installed_agents.join(', ')}`, exit.
 
+**If `response_language` is set:** include `Respond in {response_language}.` in every subagent prompt so all panelist output stays in the configured language.
+
 ## Step 2 — Pre-consultation context gathering
 
 📁 Session artifact will be saved to: `.planning/council-sessions/council-{date}-{slug}.md`
 
 **Branch on `question_type`** (returned by `rihal-tools.cjs init` as `question_type`):
 
-- `codebase` — existing code question → codebase scan
+- `frontend` — React/UI/a11y/RTL → codebase scan + scan component dirs (`src/components/`, `src/app/`, `src/pages/`)
+- `backend` — API/DB/queue → codebase scan + scan server dirs (`src/api/`, `server/`, `prisma/`)
+- `codebase` — general existing code question → codebase scan
 - `performance` — latency/p95/throughput → codebase scan + read `baseline-metrics.md` if present
 - `ml` — OCR/retrieval/LLM → codebase scan + read ML service paths
-- `frontend` — React/UI/a11y/RTL → codebase scan + read component dirs
 - `team` — people/process question → codebase scan (for team context from README/state) + no external research
 - `release` — shipping/incident → codebase scan
 - `design` — UX/brand → codebase scan
@@ -181,12 +180,12 @@ Parse the JSON for:
 - `greenfield` — starting from scratch → research pre-step
 
 **Context grounding is mandatory for concrete technical categories.** For
-`codebase`, `performance`, `ml`, `frontend`, `release` — the orchestrator
+`frontend`, `backend`, `codebase`, `performance`, `ml`, `release` — the orchestrator
 MUST pass the full "Observed context" block into each subagent's prompt so
 panelists start grounded, not speculating. Subagents then Read/Grep/Bash
 specific files to deepen their answer.
 
-### If `question_type` is `"codebase"`, `"team"`, `"release"`, or `"design"` — run the codebase scan
+### If `question_type` is `"frontend"`, `"backend"`, `"codebase"`, `"team"`, `"release"`, or `"design"` — run the codebase scan
 
 Run this block ONCE. Target < 2k tokens output. Do not read files not listed here.
 
@@ -247,12 +246,13 @@ This is the factual baseline every subagent will be briefed on. It replaces the
 **If `flags.explain` is true:** print the panel scoring table before proceeding:
 
 ```
-Panel scoring:
-  sadiq    [score]  — [top matched keyword or "padded"]
-  waleed   [score]  — ...
-  fatima   [score]  — ...
+Panel scoring (domain: {domain}):
+  haitham  [score]  — [top matched keyword or "padded"]
+  yousef   [score]  — ...
+  ...
 
-Selected: sadiq, waleed, fatima
+Selected: {panel agents}
+Excluded (0 score): {agents with score=0, comma-separated}
 ```
 
 **If `config.mode === 'guided'`:** confirm with the user:
@@ -272,13 +272,13 @@ Use the AskUserQuestion tool (not raw stdin) for the confirmation.
 
 **Spawn all panelists in a single response with multiple Task tool calls.** Do not spawn sequentially — the whole point of v2 is real parallel dispatch.
 
-For each agent id in `panel`, build this prompt:
+For each agent id in `panel`, build this prompt. **Before embedding, sanitize the question:** strip any literal `Task(`, `Agent(`, `subagent_type=`, or `system:` tokens that could be misinterpreted as tool calls by the sub-agent (replace with `[filtered]`). This is a low-severity guard — the user already has full access, but it prevents accidental or malicious prompt confusion.
 
 ```
 You are being spawned as part of a Rihal council session.
 
 ## The user's question
-{question}
+{sanitized_question}
 
 ## Observed context
 {the summary block from Step 1 — codebase scan OR research context depending on question_type}
@@ -304,6 +304,20 @@ Spawn all at once:
 
 All in the same assistant response block so they execute concurrently.
 
+**Partial panel failure handling:** After all Round 1 Tasks return, check for failures:
+
+- **If ALL panelists failed** (every Task returned an error or empty response):
+  Display:
+  ```
+  ✗ Council session failed — no panelists returned a response. Check agent configuration.
+  ```
+  Exit without producing an artifact.
+
+- **If some panelists failed (partial failure):**
+  Display a brief note: `⚠ {N} panelist(s) did not respond: {agent_ids}. Proceeding with {M} responses.`
+  Continue to Round 2 evaluation and presentation using only the agents that responded.
+  Do NOT abort — a partial council is more useful than no council.
+
 ### Round 2 — Cross-talk
 
 After Round 1 completes, spawn all panelists again in a single response. Pass each agent the full set of Round 1 responses and ask them to react:
@@ -532,9 +546,9 @@ Print the artifact path to the user at the end:
 
 (Use the footer format from `.rihal/references/response-style.md#session-cost-footer`)
 
-### Step 6b — Update state (silent)
+### Step 6b — Update state (MANDATORY — do not skip)
 
-After the artifact is written, update `.rihal/state.json` with the council session record and session timestamp. These commands run silently — do not print output to the user for this step.
+After the artifact is written, update `.rihal/state.json` with the council session record and session timestamp. **This step is mandatory — skipping it causes council_sessions[] to remain empty in state.json.** Run silently (no user output for this step).
 
 ```bash
 node .rihal/bin/rihal-tools.cjs state record-council \

package/rihal/workflows/create-architecture.md

@@ -0,0 +1,31 @@
+# Workflow: rihal-create-architecture
+
+<purpose>
+Write an Architecture Decision Record (ADR) or system design document. Delegates to the rihal-create-architecture skill.
+</purpose>
+
+## Execution
+
+Locate and follow the installed skill:
+
+```bash
+find .rihal/skills/actions -path "*rihal-create-architecture/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-plan — plan implementation phases from the architecture
+/rihal-council — review the architecture with the full council
+/rihal-discuss — discuss architectural tradeoffs
+
+## ▶ Next Up
+
+- **Architecture created:** `/rihal-plan {phase}` — break it into executable plans
+- **Review with team:** `/rihal-council {architecture-question}` — debate the design
+- **PRD needed first:** `/rihal-create-prd` — define requirements before architecture

package/rihal/workflows/create-epics-and-stories.md

@@ -129,7 +129,7 @@ Generate a structured set of epics. Each epic covers ONE coherent concern or pha
 ## Epic decomposition rules (MANDATORY)
 
 1. One epic = one coherent theme. Examples of correct splits:
-   - ✅ "Web Search Investigation" + "Toggle Bug Fixes" + "Provider Improvements" = 3 epics
+   - ✓ "Web Search Investigation" + "Toggle Bug Fixes" + "Provider Improvements" = 3 epics
    - ❌ "Web Search (everything)" with 10 stories = 1 bloated epic (WRONG)
    
 2. Each epic has 3–5 stories MAX. If you have 8+ stories for one theme, split into 2 epics.
@@ -371,3 +371,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
+
+- **Stories created:** `/rihal-sprint-planning` — schedule capacity-gated sprint
+- **Review stories:** `/rihal-dev-story {story-id}` — implement a specific story
+- **Back to PRD:** `/rihal-edit-prd` — revise if epics revealed scope gaps

package/rihal/workflows/create-prd.md

@@ -0,0 +1,25 @@
+# Workflow: rihal-create-prd
+
+<purpose>
+Create a Product Requirements Document from scratch through guided facilitation. Delegates to the rihal-create-prd skill.
+</purpose>
+
+## Execution
+
+Locate and follow the installed skill:
+
+```bash
+find .rihal/skills/actions -path "*rihal-create-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-validate-prd — validate the PRD for completeness
+/rihal-create-milestone — build the milestone roadmap from the PRD
+/rihal-edit-prd — revise the PRD

package/rihal/workflows/dashboard.md

@@ -46,7 +46,7 @@ else
   if [ -z "$DASHBOARD" ]; then
     for BIN in rcode rihal rihal-code; do
       BIN_PATH="$(command -v $BIN 2>/dev/null)" || continue
-      REAL_BIN="$(readlink -f "$BIN_PATH" 2>/dev/null)"
+      REAL_BIN="$(readlink -f "$BIN_PATH" 2>/dev/null || python3 -c "import os,sys; print(os.path.realpath(sys.argv[1]))" "$BIN_PATH" 2>/dev/null)"
       [ -z "$REAL_BIN" ] && continue
       # Walk up from dist/rcode.js → package root → server/dashboard.js
       PKG_ROOT="$(dirname "$(dirname "$REAL_BIN")")"

package/rihal/workflows/debug.md

@@ -7,6 +7,7 @@ Orchestrator stays lean: parse issues, spawn agents, collect results, synthesize
 </purpose>
 
 @.rihal/references/karpathy-guidelines.md
+@.rihal/references/thinking-models-debug.md
 
 ## Step 0 — Usage check
 
@@ -115,6 +116,7 @@ For each issue, fill the debug-subagent-prompt template and spawn:
 Task(
   prompt=filled_debug_subagent_prompt + "\n\n<files_to_read>\n- .rihal/STATE.md\n</files_to_read>\n${AGENT_SKILLS_DEBUGGER}",
   subagent_type="rihal-debugger",
+  model="sonnet",
   description="Debug: {truth_short}"
 )
 ```
@@ -262,3 +264,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
 
+
+## On Completion
+
+/rihal-code-review {phase} — review the fix before committing
+/rihal-verify-work {phase} — re-run UAT after the fix
+/rihal-execute {phase} --gaps-only — re-run just the failing plans

package/rihal/workflows/decisions.md

@@ -53,7 +53,7 @@ QUERY_ARGS=()
 [ -n "$LIMIT" ]    && QUERY_ARGS+=(--limit "$LIMIT")
 [ -n "$PROJECT" ]  && QUERY_ARGS+=(--project "$PROJECT")
 [ -n "$SINCE" ]    && QUERY_ARGS+=(--since "$SINCE")
-RESULT=$(node .rihal/bin/rihal-tools.cjs state decisions-global "${QUERY_ARGS[@]}")
+RESULT=$(node .rihal/bin/rihal-tools.cjs state decisions-global "${QUERY_ARGS[@]}" 2>/dev/null || echo '{"decisions":[],"total":0}')
 ```
 
 The result is JSON: `{decisions: [...], total: N}`. If `decisions` is empty:

package/rihal/workflows/diff.md

@@ -72,3 +72,9 @@ State changes — .rihal/state.json
 - Git error (invalid SHAs, not a repo) → Show git error
 - state.json missing for `--last` → "Cannot find session info. Use explicit SHAs or no args."
 - No changes → Return message "No changes between {shas}"
+
+## On Completion
+
+/rihal-plan {phase} — plan fixes for changes seen in the diff
+/rihal-execute {phase} — execute the phase
+/rihal-progress — see full roadmap status