@hanzlaa/rcode 2.2.0 → 2.3.2

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/brain/best-practices/no-autonomous-bypass.md
+@rihal/brain/best-practices/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/actions/4-implementation/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/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/document-project.md

@@ -162,7 +162,7 @@ After audit, if resume-work.md exists, prepend to Step 2:
 ```
 If .rihal/DOCS-AUDIT.md exists, check for missing/stale docs:
 
-@.rihal/DOCS-AUDIT.md
+<!-- DOCS-AUDIT.md is generated at runtime by rihal-tools.cjs docs-audit — not a tracked file -->
 ```
 
 ## Success Criteria

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/help.md

@@ -109,7 +109,7 @@ init → new-project → plan → execute → next → status → ship
 | `/rihal:code-review-fix` | Auto-apply fixes from a code-review report. |
 | `/rihal:verify-phase <n>` | Goal-backward audit — does the codebase deliver what the phase promised? |
 | `/rihal:verify-work` | Conversational UAT against acceptance criteria. |
-| `/rihal:ship` | Create PR, run review, prepare for merge after verification passes. |
+| `/rihal:ship [phase] [--draft]` | Push feature branch + open PR with auto-generated body (goal, changes, requirements, verification status). Use AFTER `/rihal:verify-phase` passes. **Not for npm publish or tagging releases.** |
 
 ## Phase & plan management
 

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/actions/1-analysis/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.