@hanzlaa/rcode 2.1.0 → 2.3.1

package/rihal/workflows/audit.md

@@ -0,0 +1,172 @@
+# Workflow: rihal:audit
+
+<purpose>
+Single entry point for every kind of audit. Asks the user *what* to audit
+and dispatches to the right sub-workflow. Closes #234 — replaces the prior
+state where users had to know about six separate audit/verify commands by
+name (`audit-milestone`, `audit-uat`, `audit-fix`, `karpathy-audit`,
+`verify-phase`, `verify-work`).
+
+Honours `.rihal/config.yaml`: in `mode: yolo`, the router skips the menu
+and auto-picks the most-relevant target based on project state. In
+`mode: guided` (default), it asks.
+</purpose>
+
+## Step 0 — Usage check
+
+If `$ARGUMENTS` contains `--help` or `-h`:
+
+```
+/rihal:audit                       # interactive — asks what to audit
+/rihal:audit phase [<NN>]          # → /rihal:verify-phase
+/rihal:audit milestone [--strict]  # → /rihal:audit-milestone (with synth fallback)
+/rihal:audit uat                   # → /rihal:audit-uat
+/rihal:audit code [--scope=...]    # → /rihal:karpathy-audit
+/rihal:audit fix                   # → /rihal:audit-fix
+/rihal:audit work                  # → /rihal:verify-work
+```
+
+**Examples:**
+```
+/rihal:audit
+/rihal:audit milestone --strict
+/rihal:audit phase 03
+```
+
+## Step 1 — Resolve mode + arguments
+
+```bash
+TOOL="node .rihal/bin/rihal-tools.cjs"
+MODE=$($TOOL config-get mode 2>/dev/null || echo "guided")
+DISCUSS=$($TOOL config-get workflow.discuss_mode 2>/dev/null || echo "adaptive")
+```
+
+Parse `$ARGUMENTS`:
+- First word ∈ {phase, milestone, uat, code, fix, work} → set `$TARGET`, drop it from args, jump to Step 4.
+- Empty or unrecognised → continue to Step 2.
+
+## Step 2 — Detect project state
+
+Probe what's audit-able right now:
+
+```bash
+ROADMAP=$([ -f .planning/ROADMAP.md ] && echo yes || echo no)
+PHASES=$(ls -d .planning/phases/*/ 2>/dev/null | wc -l)
+PLANS=$(find .planning/phases -name PLAN.md 2>/dev/null | wc -l)
+SUMMARIES=$(find .planning/phases -name SUMMARY.md 2>/dev/null | wc -l)
+UAT_FILES=$(find .planning -name 'UAT*.md' 2>/dev/null | wc -l)
+ON_BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null)
+DIRTY=$([ -n "$(git status --porcelain 2>/dev/null)" ] && echo yes || echo no)
+```
+
+Use these to decide which menu options are *relevant* and which to mark
+as `(no data — skip)`.
+
+## Step 3 — Ask user (guided mode only)
+
+If `$MODE` is `yolo`, skip this step and pick the most relevant target
+automatically (priority: `work` if dirty branch, else `phase` if PLANS>0
+and SUMMARIES<PLANS, else `milestone` if SUMMARIES>0, else `code`).
+
+Otherwise call AskUserQuestion:
+
+```
+Question:
+What do you want to audit?
+
+Options:
+  1. phase           — verify a single phase against its PLAN  ({PLANS} plans)
+  2. milestone       — cross-phase milestone goal coverage     ({SUMMARIES} summaries)
+  3. uat             — outstanding UAT / verification items    ({UAT_FILES} files)
+  4. code-quality    — Karpathy 4-principle code review        (current diff)
+  5. auto-fix        — audit then auto-fix findings            (uses #1–4 output)
+  6. work            — verify current branch / WIP             ({ON_BRANCH}, dirty={DIRTY})
+  0. cancel
+```
+
+Set `$TARGET` from the user's choice.
+
+## Step 4 — Pre-flight per target
+
+Each target has a precondition. Fail loudly with the fix step *before*
+dispatching, so the user doesn't get a surprise halt deep inside the
+sub-workflow.
+
+| target | precondition | failure message |
+|---|---|---|
+| phase | at least one `.planning/phases/*/PLAN.md` | `No PLAN.md found. Run /rihal:plan first.` |
+| milestone | ROADMAP.md exists | `No ROADMAP.md. Run /rihal:new-milestone first.` |
+| uat | at least one UAT*.md exists | `No UAT files yet. Run /rihal:execute on a phase first.` |
+| code | git repo with at least one commit | `Empty repo — nothing to audit yet.` |
+| fix | a prior audit report exists OR a prior `--report` artefact | `No audit findings yet. Run /rihal:audit first.` |
+| work | inside a git worktree | `Not in a git repo.` |
+
+For `milestone` specifically, check the **graceful-degrade** condition
+(closes #234 audit-milestone halt):
+
+```bash
+if [ "$TARGET" = "milestone" ] && [ "$SUMMARIES" -eq 0 ] && [ "$PLANS" -gt 0 ]; then
+  # Phases planned but no formal closes — offer to synthesize.
+  GIT_FEAT_COMMITS=$(git log --oneline --grep='^feat' 2>/dev/null | wc -l)
+  echo "⚠ $PLANS phases planned, 0 SUMMARY.md, $GIT_FEAT_COMMITS feat commits."
+  echo "  Phases were executed but never formally closed."
+  # Offer (yolo: auto-pick 1; guided: ask):
+  #   1. Synthesize SUMMARY.md per phase from PLAN.md + git log    [recommended]
+  #   2. Run /rihal:verify-phase per phase (manual close)
+  #   3. Continue audit anyway (will only assess what's documented)
+  #   0. Cancel
+fi
+```
+
+In `mode: yolo`, auto-pick option 1: group `git log --oneline` output by
+phase tag (e.g. commits matching `^feat\(0?(\d+)`) and write a first-pass
+`SUMMARY.md` per phase under `.planning/phases/<phase>/SUMMARY.md`
+containing the goal (from PLAN.md), the commit list, and a `# TODO:
+expand outcomes` marker. The user can then refine before re-running the
+audit.
+
+A native `phase synthesize-summaries` CLI subcommand is tracked separately
+(see #234 follow-ups) — until it lands, the LLM performs the synthesis
+inline using `git log` + `Read PLAN.md` + `Write SUMMARY.md`.
+
+## Step 5 — Dispatch
+
+Run the target's slash command, forwarding remaining args:
+
+| target | dispatch |
+|---|---|
+| phase | `/rihal:verify-phase $REST_ARGS` |
+| milestone | `/rihal:audit-milestone $REST_ARGS` |
+| uat | `/rihal:audit-uat $REST_ARGS` |
+| code | `/rihal:karpathy-audit $REST_ARGS` |
+| fix | `/rihal:audit-fix $REST_ARGS` |
+| work | `/rihal:verify-work $REST_ARGS` |
+
+## Step 6 — Closing summary
+
+After the sub-workflow returns:
+
+```
+RIHAL ► AUDIT ({TARGET}) ✓
+
+Report: {report_path or "(stdout only)"}
+Findings: {count}
+
+Next:
+  /rihal:audit fix         — auto-fix findings classified as auto-fixable
+  /rihal:audit code        — drill into code-quality issues
+  /rihal:settings show     — review which audit gates are enabled
+```
+
+## Success Criteria
+
+- [ ] `/rihal:audit` (no args) presents menu in guided mode, auto-picks in yolo
+- [ ] `/rihal:audit milestone` short-circuits the menu
+- [ ] When SUMMARY.md absent but PLAN.md present, milestone offers synthesize/verify/skip — does not dead-halt
+- [ ] Sub-workflow's closing report is surfaced unchanged
+
+## On Error
+
+- **Sub-workflow not installed** (slash file missing): `Audit subroute '/rihal:{target}' not found. Run: npx @hanzlaa/rcode install .`
+- **Precondition failed**: print the message from Step 4's table, suggest the unblocking command, STOP.
+- **`.rihal/config.yaml` missing**: treat as `mode: guided`, continue.

package/rihal/workflows/autonomous.md

@@ -4,16 +4,83 @@ Drive milestone phases autonomously — all remaining phases, a range via `--fro
 
 </purpose>
 
+<critical_rules priority="absolute">
+
+These rules apply throughout autonomous execution. Violations broke the
+interpos audit (issue #221) — DO NOT regress.
+
+1. **NEVER modify `.rihal/config.yaml`.** Specifically: never write
+   `mode: yolo`, never call `rihal-tools config-set mode`, never `sed`
+   the file. The user's mode preference is sacred. Autonomous behavior
+   is governed by the workflow's own internal flags + the `--auto`
+   invocation flag, NOT by mutating persistent config.
+
+2. **NEVER skip the methodology chain on greenfield projects.** Before
+   the phase loop runs, the prerequisite check (next step) MUST verify:
+   - `.planning/prd.md` exists (else halt → /rihal:create-prd)
+   - ROADMAP.md has milestone structure (else halt → /rihal:create-milestone)
+   - `.planning/epics.md` exists (else halt → /rihal:create-epics-and-stories)
+   See issue #219 + #229.
+
+3. **NEVER write SPRINT.md directly.** Sprint creation MUST go through
+   the `rihal-sprint-planning` skill so the capacity gate (#127) fires.
+   If autonomous needs a sprint, invoke the skill — don't shortcut.
+
+4. **ALWAYS call `state sync --from-disk` after writing any
+   .planning/ artifact.** Otherwise state.json drifts and downstream
+   workflows lie. See `_shared/state-sync-rule.md` (#198).
+
+5. **ALWAYS record decisions via `rihal-tools state add-decision`.**
+   Never write decision prose to STATE.md. See #224.
+
+</critical_rules>
+
 <required_reading>
 
 @.rihal/references/output-format.md
 @.rihal/references/workstream-flag.md
 @.rihal/references/output-realism.md
+@.rihal/skills/_shared/no-autonomous-bypass.md
+@.rihal/skills/_shared/state-sync-rule.md
 
 Read all files referenced by the invoking prompt's execution_context before starting.
 
 </required_reading>
 
+<step name="prerequisite_check" priority="before-everything">
+
+## 0. Prerequisite check (greenfield guard)
+
+Before any phase work, verify the methodology chain has run:
+
+```bash
+HAS_PRD=$([ -f .planning/prd.md ] && echo true || echo false)
+HAS_ROADMAP_MILESTONES=$(grep -qE "^## Milestone\s+M[0-9]+" .planning/ROADMAP.md 2>/dev/null && echo true || echo false)
+HAS_EPICS=$([ -f .planning/epics.md ] && echo true || echo false)
+SKIP_FLAG=$(echo "$ARGUMENTS" | grep -qE "\-\-skip-prerequisites" && echo true || echo false)
+```
+
+If `SKIP_FLAG=false` AND any prerequisite is missing, HALT with a clear message:
+
+```
+⚠ Cannot run autonomous: missing prerequisite — {what}.
+
+The autonomous flow assumes a project that has already gone through:
+  1. /rihal:create-prd               → produces .planning/prd.md
+  2. /rihal:create-milestone         → produces ROADMAP.md with M1..Mn
+  3. /rihal:create-epics-and-stories → produces .planning/epics.md
+  4. THEN /rihal:autonomous           ← you are here
+
+Suggested first step: /rihal:{first-missing-command}
+
+If you genuinely want to skip these (rare — usually inverted methodology),
+re-invoke with: /rihal:autonomous --skip-prerequisites
+```
+
+If `SKIP_FLAG=true`: print a warning that downstream workflows may produce low-quality output without upstream artifacts, then proceed.
+
+</step>
+
 <output_format>
 
 Open with banner:

package/rihal/workflows/checkpoint-preview.md

@@ -0,0 +1,7 @@
+# Workflow: rihal:checkpoint-preview
+
+<purpose>
+Human-in-the-loop change review. Make sense of a diff, focus attention where it matters, and walk through testing. Delegates to the rihal-checkpoint-preview skill for the full review protocol.
+</purpose>
+
+@.rihal/skills/rihal-checkpoint-preview/SKILL.md

package/rihal/workflows/council.md

@@ -404,7 +404,9 @@ Rules for compact mode:
 - Round 2 deltas: ≤ 15 words each. "Held position" is a valid delta.
 - No section headers beyond the four above. No numbered story breakdowns. No tables from panelists verbatim.
 
-### Verbose mode (`--verbose` flag)
+### Verbose mode (`--verbose` flag or `output.verbose: true` in config)
+
+Activated by: `--verbose` in `$ARGUMENTS` OR `$(node .rihal/bin/rihal-tools.cjs config-get output.verbose)` equals `"true"`.
 
 Print Round 1 (and Round 2 if ran) verbatim in panel order. Do NOT summarize.
 

package/rihal/workflows/dashboard.md

@@ -27,14 +27,14 @@ Check for the dashboard server in priority order:
 
 1. `./server/dashboard.js` (when inside the rihal-code source repo)
 2. `./.rihal/lib/server/dashboard.js` (installed package copy)
-3. `$(npm root -g)/@hanzlahabib/rihal-code/server/dashboard.js` (global install)
+3. `$(npm root -g)/@hanzlaa/rcode/server/dashboard.js` (global install)
 
 Store the resolved path as `$DASHBOARD`.
 
 If none found, print:
 ```
 ❌ Dashboard script not found.
-Run `npx rihal-code install` to install the package, or check you're inside a project with .rihal/.
+Run `npx @hanzlaa/rcode install` to install the package, or check you're inside a project with .rihal/.
 ```
 Exit.
 

package/rihal/workflows/debug.md

@@ -118,8 +118,15 @@ Task(
 )
 ```
 
-**Never pass `isolation="worktree"` without explicit user consent.** Worktree isolation creates a git worktree, which is a write operation the user may not want. If you believe isolation is genuinely needed (e.g., the debug agent may edit files), ask first via AskUserQuestion:
+**Never pass `isolation="worktree"` without explicit user consent.** Worktree isolation creates a git worktree, which is a write operation the user may not want. If you believe isolation is genuinely needed (e.g., the debug agent may edit files):
 
+```bash
+CONFIG_MODE=$(node .rihal/bin/rihal-tools.cjs config-get mode 2>/dev/null || echo "guided")
+```
+
+**If `CONFIG_MODE == "yolo"`:** Skip isolation — default to no worktree, proceed immediately.
+
+Otherwise ask via AskUserQuestion:
 ```
 Spawn the debug agent with git worktree isolation?
   - Safer: agent edits stay isolated until you merge

package/rihal/workflows/diagnose-issues.md

@@ -0,0 +1,34 @@
+# Workflow: rihal:diagnose-issues
+
+<purpose>
+Reusable diagnosis subroutine called from /rihal:verify-work when
+verification fails. Walks symptom → hypothesis → evidence → minimal
+repro and returns a structured finding. Not a top-level command.
+</purpose>
+
+## Step 1 — Symptom capture
+
+Record:
+- failing assertion / log line / wrong output
+- file:line where divergence first appears
+- last commit before symptom appeared (`git log -S<token>`)
+
+## Step 2 — Hypotheses
+
+List 2–3 plausible causes. For each:
+- a one-line predicted mechanism
+- the cheapest test that would falsify it
+
+## Step 3 — Evidence
+
+Run the falsifying tests in cheapest-first order. Stop at the first
+hypothesis that matches all evidence.
+
+## Step 4 — Minimal repro
+
+Reduce to the smallest input that still triggers the bug. Save under
+`.planning/diagnostics/<slug>.md`.
+
+## Step 5 — Hand-off
+
+Return JSON: `{ root_cause, repro_path, suggested_fix }` to the caller.

package/rihal/workflows/do.md

@@ -10,7 +10,7 @@ Read all files referenced by the invoking prompt's execution_context before star
 <process>
 
 <step name="parse_args">
-Extract `$ARGUMENTS` and detect `--auto` flag (suppresses confirmation, dispatches immediately):
+Extract `$ARGUMENTS`, detect `--auto` flag, and check config mode:
 
 ```bash
 AUTO_MODE=false
@@ -19,6 +19,11 @@ if [[ "$ARGUMENTS" == *"--auto"* ]]; then
   AUTO_MODE=true
   QUESTION=$(echo "$ARGUMENTS" | sed 's/--auto[[:space:]]*//' | xargs)
 fi
+# Also auto-dispatch in yolo mode
+CONFIG_MODE=$(node .rihal/bin/rihal-tools.cjs config-get mode 2>/dev/null || echo "guided")
+if [[ "$CONFIG_MODE" == "yolo" ]]; then
+  AUTO_MODE=true
+fi
 ```
 </step>
 
@@ -52,18 +57,53 @@ If user picks 1-15, invoke that command. If 16, capture text and continue.
 </step>
 
 <step name="check_project">
-**Check if project exists.**
+**Check if project exists + state survey.**
 
 ```bash
 INIT=$(node ".rihal/bin/rihal-tools.cjs" state load 2>/dev/null)
+HAS_PRD=$([ -f .planning/prd.md ] && echo true || echo false)
+HAS_EPICS=$([ -f .planning/epics.md ] && echo true || echo false)
+PHASE_COUNT=$(node ".rihal/bin/rihal-tools.cjs" progress init 2>/dev/null | python3 -c "import sys,json;print(json.load(sys.stdin).get('phase_count',0))" 2>/dev/null || echo 0)
+HAS_PHASES=$([ "$PHASE_COUNT" -gt 0 ] && echo true || echo false)
 ```
 
-Track whether `.planning/` exists — some routes require it, others don't.
+These flags drive the greenfield guard in the next step. `.planning/` existing alone is not enough — we need to know whether the methodology chain has actually run (PRD → milestone → epics → phases).
+</step>
+
+<step name="greenfield_guard" priority="first-match">
+**Block methodology inversion.**
+
+Some routes ASSUME upstream artifacts exist. If they don't, dispatching to them inverts the chain (the autonomous-bypass pattern that produced the interpos disaster — issue #220 + #219).
+
+Apply this guard BEFORE the routing table below:
+
+| Intent contains... | AND state shows... | Then re-route to... | Why |
+|--------------------|---------------------|----------------------|-----|
+| "draft phases", "all phases", "build all phases", "groom phases", "auto mode" + "phases" | `HAS_PRD=false` | `/rihal:create-prd` first | Phases need a PRD foundation. Without one, the autonomous flow hallucinates requirements. |
+| "execute phase", "build phase N", "run phase N" | `HAS_PHASES=false` OR PLAN.md missing for phase N | `/rihal:plan N` first (or `/rihal:create-prd` if no PRD) | Can't execute what hasn't been planned. |
+| "sprint planning", "plan the sprint" | `HAS_EPICS=false` | `/rihal:create-epics-and-stories` first | Sprints draw stories from epics. No epics = no stories to schedule. |
+| "create stories", "epics" | `HAS_PRD=false` | `/rihal:create-prd` first | Epics decompose a milestone. Milestone needs PRD. |
+| "create milestones", "roadmap" | `HAS_PRD=false` | `/rihal:create-prd` first | Roadmap is derived from PRD success metrics. |
+
+When the guard fires, print a clear message:
+
+```
+⚠ Cannot {requested action}: missing prerequisite — {what's missing}.
+
+Re-routing to: /rihal:{prerequisite-command}
+Once that completes, re-run your original request.
+```
+
+Then dispatch to the prerequisite command instead of the originally-matched route.
+
+The guard never silently rejects intent — it always either dispatches to a sensible alternative OR explicitly tells the user what flag overrides it (e.g. `--skip-prerequisites` for the rare legitimate use case).
 </step>
 
 <step name="route">
 **Match intent to command.**
 
+(Run only after greenfield_guard has cleared.)
+
 Evaluate `$QUESTION` against these routing rules. Apply the **first matching** rule:
 
 | If the text describes... | Route to | Why |
@@ -71,6 +111,10 @@ Evaluate `$QUESTION` against these routing rules. Apply the **first matching** r
 | Starting a new project, "set up", "initialize" | `/rihal:new-project` | Needs full project initialization |
 | Mapping or analyzing an existing codebase | `/rihal:map-codebase` | Codebase discovery |
 | A bug, error, crash, failure, or something broken | `/rihal:debug` | Needs systematic investigation |
+| Validate an idea, "working backwards", "press release", "PRFAQ", "is this worth building" | `/rihal:prfaq` | Stress-test concept before committing sprint capacity |
+| Brainstorm, generate ideas, "explore options", "what could we do" | `/rihal:brainstorm` | Structured ideation before planning |
+| Audit code quality, "review changes", "karpathy", "check my diff", "too complex" | `/rihal:karpathy-audit` | 4-principle code audit against recent diff |
+| Walk through a change, "checkpoint", "explain this diff", "human review" | `/rihal:checkpoint-preview` | Human-in-the-loop diff walkthrough |
 | Exploring, researching, comparing, or "how does X work" | `/rihal:research-phase` | Domain research before planning |
 | Scope unclear, conflicting UIs/options, "which one", "better UX", "still have confusion", "how should X look", brainstorming vision | `/rihal:discuss-phase` | Decisions not yet locked — gather before planning |
 | A complex task: refactoring, migration, multi-file architecture, system redesign | `/rihal:add-phase` | Needs a full phase with plan/build cycle |

package/rihal/workflows/execute-sprint.md

@@ -341,16 +341,23 @@ If verification fails:
 
 **Check if node repair is enabled** (default: on):
 ```bash
-NODE_REPAIR=$(node "./.claude/get-shit-done/bin/rihal-tools.cjs" config-get workflow.node_repair 2>/dev/null || echo "true")
+NODE_REPAIR=$(node ".rihal/bin/rihal-tools.cjs" config-get workflow.node_repair 2>/dev/null || echo "true")
 ```
 
-If `NODE_REPAIR` is `true`: invoke `@./.claude/get-shit-done/workflows/node-repair.md` with:
+If `NODE_REPAIR` is `true`: attempt RETRY → DECOMPOSE → PRUNE in that order
+within a budget of `workflow.node_repair_budget` (default: 2). Track:
+
 - FAILED_TASK: task number, name, done-criteria
 - ERROR: expected vs actual result
 - PLAN_CONTEXT: adjacent task names + phase goal
-- REPAIR_BUDGET: `workflow.node_repair_budget` from config (default: 2)
+- REPAIR_BUDGET: remaining attempts
+
+Repair strategies:
+- **RETRY** — re-run the same task with the failure context as added input.
+- **DECOMPOSE** — split into smaller subtasks (only if the original was L/XL).
+- **PRUNE** — drop the task from the sprint scope and record under "Issues Encountered" in SUMMARY.
 
-Node repair will attempt RETRY, DECOMPOSE, or PRUNE autonomously. Only reaches this gate again if repair budget is exhausted (ESCALATE).
+If the budget is exhausted without success: ESCALATE.
 
 If `NODE_REPAIR` is `false` OR repair returns ESCALATE: STOP. Present: "Verification failed for Task [X]: [name]. Expected: [criteria]. Actual: [result]. Repair attempted: [summary of what was tried]." Options: Retry | Skip (mark incomplete) | Stop (investigate). If skipped → SUMMARY "Issues Encountered".
 </step>

package/rihal/workflows/execute.md

@@ -56,8 +56,14 @@ wall-clock expectation).
 </execution_plan>
 
 <three_options>
-After execution plan, offer three modes via AskUserQuestion. Each option
-names the tradeoff explicitly:
+Check config mode first:
+```bash
+CONFIG_MODE=$(node .rihal/bin/rihal-tools.cjs config-get mode 2>/dev/null || echo "guided")
+```
+
+**If `CONFIG_MODE == "yolo"` or `$ARGUMENTS` contains `--auto`:** Skip the menu. Auto-select **A) Autonomous run** and print one line: `▶ Auto-selecting Autonomous run (yolo mode). /rihal:settings set mode guided to change.`
+
+Otherwise, offer three modes via AskUserQuestion. Each option names the tradeoff explicitly:
 
 **A) Autonomous run** — Spawn subagent per plan in sequence/parallel per
     wave rules. Checkpoints still pause for user. Fastest wall-clock.
@@ -157,7 +163,7 @@ Always use the exact name from this list — do not fall back to 'general-purpos
 - rihal-codebase-mapper — Maps project structure and dependencies
 - rihal-integration-checker — Checks cross-phase integration
 - rihal-nyquist-auditor — Validates verification coverage
-- rihal-ui-designer — Researches UI/UX approaches
+- rihal-ux-designer — Researches UI/UX approaches
 - rihal-ui-auditor — Reviews UI implementation quality
 - rihal-ui-auditor — Audits UI against design requirements
 </available_agent_types>

package/rihal/workflows/install.md

@@ -50,8 +50,8 @@ The installer needs to be called with the `--module` flag. Detect the rihal-code
 # Try local dev first, then global
 if [ -f ./cli/install-v2.js ]; then
   node ./cli/install-v2.js . --module {name} --force --yes
-elif [ -f "$(npm root -g)/@hanzlahabib/rihal-code/cli/install-v2.js" ]; then
-  node "$(npm root -g)/@hanzlahabib/rihal-code/cli/install-v2.js" . --module {name} --force --yes
+elif [ -f "$(npm root -g)/@hanzlaa/rcode/cli/install-v2.js" ]; then
+  node "$(npm root -g)/@hanzlaa/rcode/cli/install-v2.js" . --module {name} --force --yes
 else
   echo "Cannot find rihal-code package. Install it globally or run from the repo."
   exit 1

package/rihal/workflows/karpathy-audit.md

@@ -382,28 +382,21 @@ Auto-fix some issues: /rihal:code-review-fix {phase}
 
 </process>
 
-<success_criteria>
+## Success Criteria
+
 - [ ] Input parsed correctly (phase, git ref, or file override)
 - [ ] Source files filtered from non-code files
 - [ ] All 4 principles audited with specific rules
 - [ ] Findings include file:line references
-- [ ] Severity levels assigned (critical/warning/info)
+- [ ] Severity levels assigned (critical / warning / info)
 - [ ] Report written with summary table and details
 - [ ] User receives actionable recommendations
 - [ ] Report saved to phase dir if phase mode
-</success_criteria>
-
-## Success Criteria
-
-- [ ] Task completed as requested
-- [ ] Output saved or reported
-- [ ] State updated if necessary
-- [ ] No errors encountered
 
 ## On Error
 
-If arguments are invalid, missing files, or subagent fails:
-- Validate inputs match expected format
-- Check that required files exist
-- Retry with clearer arguments or report the specific error to the user
+- **Phase not found:** suggest `/rihal:karpathy-audit HEAD~5..HEAD` as the git-ref fallback.
+- **No source files in diff:** report "no auditable changes in range" and STOP — do not invent findings.
+- **karpathy-guidelines.md missing:** print "Reference doc missing. Run: npx @hanzlaa/rcode install ." and STOP.
+- **Empty diff:** STOP gracefully, do not run principle checks against an empty input.
 

package/rihal/workflows/pause-work.md

@@ -73,7 +73,13 @@ Extract from active SPRINT.md:
 
 ## Step 3 — Collect Blocking Constraints
 
-Ask user via AskUserQuestion for any constraints or notes:
+```bash
+CONFIG_MODE=$(node .rihal/bin/rihal-tools.cjs config-get mode 2>/dev/null || echo "guided")
+```
+
+**If `CONFIG_MODE == "yolo"`:** Set `blocking_constraints = ""` and skip to Step 4.
+
+Otherwise ask user via AskUserQuestion:
 
 ```
 Question:

package/rihal/workflows/prfaq.md

@@ -0,0 +1,7 @@
+# Workflow: rihal:prfaq
+
+<purpose>
+Working Backwards PRFAQ challenge. Stress-test a product concept by writing the press release before building it. Produces a battle-hardened PRFAQ document + PRD distillate. Delegates to the rihal-prfaq skill for the full interview and generation protocol.
+</purpose>
+
+@.rihal/skills/rihal-prfaq/SKILL.md

package/rihal/workflows/profile-user.md

@@ -15,8 +15,8 @@ If `$ARGUMENTS` is empty or contains only `--help` or `-h`:
 
 **Examples:**
 ```
-/rihal:profile-user example 1
-/rihal:profile-user example 2
+/rihal:profile-user
+/rihal:profile-user --json '{"communication":"Direct & dense","autonomy":"Autonomous","domain_depth":"Advanced","iteration_speed":"Fast"}'
 ```
 
 STOP — do not proceed.

package/rihal/workflows/progress.md

@@ -179,6 +179,6 @@ If `SNAPSHOT.routes[]` is empty or only has fallback entries, print:
 
 ## On Error
 
-- **CLI missing:** "Rihal Code install missing or stale. Run: npx @hanzlahabib/rihal-code install"
+- **CLI missing:** "Rihal Code install missing or stale. Run: npx @hanzlaa/rcode install"
 - **CLI returns `ok: false`:** surface the CLI's error verbatim. Do not attempt to compensate — the CLI's failures are the source of truth on what's wrong.
 - **Network-dependent insights:** there should be none. Insights are computed from local state + disk only.