@hanzlaa/rcode 2.2.0 → 2.3.1

package/rihal/skills/actions/2-plan/rihal-create-prd/SKILL.md

@@ -21,6 +21,19 @@ Follow the instructions in ./workflow.md.
 - Every section has explicit owner and deadline
 - Do NOT include: vague verbs ("optimize"), unquantified metrics, or requirements without owners
 
+## Fast-path detection
+
+If `$ARGUMENTS` or the opening message contains ALL FOUR of these fields, skip the discovery interview and go straight to drafting:
+
+| Field | Signal words |
+|-------|-------------|
+| Product / feature name | explicit name or noun |
+| Problem statement | "problem is", "users can't", "currently X fails" |
+| Target user | "for X users", "persona is", "audience is" |
+| Scope signal | "must have", "v1 only", "just need", "MVP" |
+
+When fast-pathing: confirm detected fields in one line ("Got it — building {name} for {user} to solve {problem}. Starting PRD draft."), then generate without asking further questions. If any of the four are absent, run the normal interview.
+
 ## Examples
 
 ### Happy Path

package/rihal/skills/actions/2-plan/rihal-create-story/SKILL.md

@@ -15,10 +15,12 @@ Follow the instructions in ./workflow.md.
 ## Output Format
 
 - Story file at .rihal/phases/{phase}/stories/story-{id}.md
-- Fixed sections: Goal | Context | Tasks (checklist) | Acceptance Criteria | Dependencies | File List (empty) | Dev Agent Record (empty)
+- Fixed sections: Goal | Assumptions | Context | Tasks (checklist) | Acceptance Criteria | Dependencies | File List (empty) | Dev Agent Record (empty)
 - Each task is ≤4 hours, in execution order
-- Acceptance criteria in Given/When/Then
+- Acceptance criteria in Given/When/Then — no criterion is valid unless a test can be written against it
+- `## Assumptions` block is mandatory: list every assumption that, if wrong, would change the story scope
 - Do NOT include implementation details in the story — those emerge during dev
+- If AC cannot be stated in Given/When/Then, stop and ask the user to clarify before generating the story
 
 ## Examples
 

package/rihal/skills/actions/4-implementation/rihal-checkpoint-preview/SKILL.md

@@ -3,6 +3,16 @@ name: rihal-checkpoint-preview
 description: 'LLM-assisted human-in-the-loop review. Make sense of a change, focus attention where it matters, test. Use when the user says "checkpoint", "human review", or "walk me through this change".'
 ---
 
+## Do NOT use this skill for
+
+- **Automated code review without a human** — use `/rihal:karpathy-audit` or a code-reviewer agent directly.
+- **Approving a deploy or merge** — this skill explains a change; it does not authorize git push, deploys, or PR merges.
+- **Bug investigation** from scratch — use `/rihal:debug` or the diagnose-issues workflow.
+- **Architecture review of an undelivered design** — this skill reviews delivered code/diffs, not specs.
+- **Sprint retros or milestone closure** — use `rihal-retrospective` or `rihal-complete-milestone`.
+
+If the user has not produced a diff or change to review, ask them to do so first instead of invoking this skill.
+
 ## Workflow
 
 

package/rihal/skills/actions/4-implementation/rihal-sprint-planning/SKILL.md

@@ -15,10 +15,12 @@ Follow the instructions in ./workflow.md.
 ## Output Format
 
 - Output: .rihal/phases/{phase}/sprint-{N}.md
-- Fixed structure: Sprint Goal (one sentence) | Duration | Stories (with owners) | Capacity Used/Available | Risks | Definition of Done
+- Fixed structure: Sprint Goal (one sentence) | Assumptions | Duration | Stories (with owners) | Capacity Used/Available | Risks | Definition of Done
 - Stories ranked by priority from epics.md
 - Leave 20% capacity buffer
 - Do NOT commit to stories without explicit owners
+- Sprint Goal must be one verifiable sentence — if it cannot be verified at sprint end without interpretation, rewrite it
+- `Assumptions` block required: list capacity assumptions, any known blockers assumed absent, any dependencies assumed resolved
 
 ## Examples
 

package/rihal/skills/agents/hussain-pm/SKILL.md

@@ -16,6 +16,14 @@ description: >
 
 # Hussain (PM) — Product Manager
 
+## Planning Quality Rules (Karpathy-adapted)
+
+Apply these as hard constraints when writing any PRD, story, epic, or scope definition:
+
+- **P1 — Think first:** Every PRD section must declare load-bearing assumptions explicitly before stating requirements. If scope is ambiguous, ask — do not guess silently.
+- **P2 — Simplicity:** Scope only what was asked. No speculative features, no "nice to have" requirements that weren't requested by the user or stakeholder.
+- **P4 — Goal-driven:** Every requirement must have a testable acceptance criterion. "System should handle X" is not a criterion — "Given Y, when Z, then the system returns W" is.
+
 ## Overview
 
 This skill embodies Hussain (حسين) in his Product Manager hat. It drives PRD creation through user interviews and requirements discovery, cuts scope ruthlessly, and ships the smallest thing that validates the assumption. Hussain does not fill templates — he interrogates until the problem is crystal clear.

package/rihal/skills/agents/hussain-sm/SKILL.md

@@ -15,6 +15,14 @@ description: >
 
 # Hussain (SM) — Scrum Master
 
+## Sprint Quality Rules (Karpathy-adapted)
+
+Apply these as hard constraints when preparing stories and planning sprints:
+
+- **P1 — Think first:** Before committing stories to a sprint, surface capacity assumptions explicitly. Never assume velocity or team availability — ask.
+- **P2 — Simplicity:** Each story must be independently deliverable. No story that bundles 2+ concerns. If a story needs a sub-story to make sense, split it.
+- **P4 — Goal-driven:** Every story must have a Definition of Done that can be verified without talking to anyone. "Works correctly" is not a DoD — "all AC pass + no regression in test suite" is.
+
 ## Overview
 
 This skill embodies Hussain (حسين) in his Scrum Master hat. It prepares stories with full context for the dev agent, plans sprints, runs retros, reports status, and course-corrects when things go sideways. Every story that reaches Hanzla is dev-ready — no ambiguity allowed.

package/rihal/templates/UAT.md

@@ -0,0 +1,29 @@
+# UAT — {{phase_name}}
+
+**Phase:** {{phase_id}}
+**Generated:** {{date}}
+
+## How to use
+
+For each scenario below, mark status: ✅ pass | ❌ fail | ⏸ skipped |
+🔍 needs-human. Add notes inline.
+
+## Scenarios
+
+### Scenario 1: {{golden path title}}
+
+**Steps:**
+1. {{action}}
+2. {{action}}
+
+**Expected:** {{outcome}}
+**Status:** ⏸
+**Notes:**
+
+### Scenario 2: {{edge case title}}
+
+(Repeat as needed.)
+
+## Outstanding items
+
+Items left as ⏸ or 🔍 carry forward to the next milestone audit.

package/rihal/templates/milestone.md

@@ -1,5 +1,7 @@
 # Milestone Template
 
+<!-- P2: Omit any section with nothing substantive. Empty sections are noise. Omit STATE.md blockers/workstreams if none active. Omit REQUIREMENTS.md out-of-scope if it doesn't constrain execution. -->
+
 Use this template when starting a new milestone with `/rihal:new-milestone`.
 
 ## ROADMAP.md

package/rihal/templates/sprint.md

@@ -1,70 +1,53 @@
 # Sprint {sprint_id} — {sprint_goal}
 
+<!-- P2: Omit Dependencies and Risks sections if empty. Omit Retrospective until sprint is complete. -->
+
 **Phase:** {phase_number} — {phase_name}
 **Status:** {status}
 **Velocity target:** {velocity_target} points
 **Started:** {started_at}
 
----
-
 ## Sprint Goal
 
 {sprint_goal}
 
----
-
 ## Stories
 
-| ID | Title | Points | Status | Acceptance |
-|----|-------|--------|--------|------------|
-| {story_id} | {title} | {points} | {status} | {acceptance} |
-
----
+| ID | Title | Points | Status | Done when |
+|----|-------|--------|--------|-----------|
+| {story_id} | {title} | {points} | {status} | {verifiable_ac} |
 
 ## Capacity
 
 - **Velocity target:** {velocity_target} points
-- **Average velocity (last 3):** {avg_velocity} points
 - **Total committed:** {total_points} points
 - **Buffer:** {buffer_points} points ({buffer_pct}%)
 
----
-
+<!-- Omit if no cross-story dependencies exist -->
 ## Dependencies
 
 | Story | Depends on | Status |
 |-------|-----------|--------|
-| | | |
-
----
 
+<!-- Omit if no risks identified -->
 ## Risks
 
 | Risk | Impact | Mitigation |
 |------|--------|------------|
-| | | |
 
----
-
-## Sprint Review Notes
-
-_Filled at sprint completion._
+## Sprint Review
 
+<!-- Fill at sprint completion only — omit this section until then -->
 - Stories completed: {done_count}/{total_count}
 - Velocity actual: {velocity_actual} points
-- Carryover stories: {carryover}
-
----
+- Carryover: {carryover}
 
 ## Retrospective
 
-_Filled at sprint completion._
-
+<!-- Fill at sprint completion only — omit this section until then -->
 ### What went well
 -
-
 ### What didn't
 -
-
 ### Action items
 -

package/rihal/templates/summary.md

@@ -0,0 +1,30 @@
+# Phase Summary — {{phase_name}}
+
+<!-- P2: Omit any section that has nothing substantive to say. An empty section is worse than no section. -->
+
+**Phase ID:** {{phase_id}}
+**Closed:** {{closed_at}}
+**Plan:** PLAN.md
+
+## Outcomes
+
+- {{what was built, in user-visible terms}}
+
+## Decisions Made
+
+<!-- Omit if no decisions were made that aren't already in PLAN.md -->
+- {{key choices and their rationale}}
+
+## Deviations from Plan
+
+<!-- Omit if execution matched the plan exactly -->
+- {{anything that diverged from PLAN.md and why}}
+
+## Issues Encountered
+
+<!-- Omit if no tasks were pruned, escalated, or skipped -->
+- {{tasks pruned, escalated, or skipped}}
+
+## Hand-off
+
+Next phase: {{next phase id and goal}}

package/rihal/templates/verification-report.md

@@ -0,0 +1,28 @@
+# Verification Report — {{phase_name}}
+
+**Phase:** {{phase_id}}
+**Verified:** {{date}}
+**Verifier:** rihal-verifier
+
+## Goal-backward check
+
+**Original goal:** {{phase goal from PLAN.md}}
+
+**Met?** ✅ / ◐ partial / ❌ not met
+
+**Evidence:**
+- {{file:line or test name proving the goal is met}}
+
+## Per-task verification
+
+| # | Task | Status | Evidence |
+|---|------|--------|----------|
+| 1 | {{task}} | ✅ | {{evidence}} |
+
+## Gaps
+
+- {{what wasn't delivered + why}}
+
+## Recommendation
+
+- proceed / revise / block

package/rihal/workflows/audit-milestone.md

@@ -140,13 +140,45 @@ If `--report` flag set, also print the report to stdout. Otherwise, just save to
 
 ## On Error
 
-If no SUMMARY.md files found:
+If no SUMMARY.md files found, **do not dead-halt** (closes #234). Probe
+for executed-phase signals and offer recovery options:
 
+```bash
+PLANS=$(find "$MILESTONE_DIR" -name PLAN.md 2>/dev/null | wc -l)
+GIT_FEAT=$(git log --oneline --grep='^feat' 2>/dev/null | wc -l)
+APPS=$(ls -d apps packages src 2>/dev/null | wc -l)
 ```
-⚠ No phase summaries found. Have phases been executed?
+
+If `PLANS > 0` AND (`GIT_FEAT > 0` OR `APPS > 0`):
+
+```
+⚠ {PLANS} phases planned, 0 SUMMARY.md, {GIT_FEAT} feat commits, code present.
+  Phases were executed but never formally closed.
+
+  Options:
+    1. Synthesize SUMMARY.md per phase from PLAN.md + git log [recommended]
+       (groups commits by phase tag like "feat(03-1):", writes a
+        first-pass SUMMARY.md the user can edit)
+    2. Run /rihal:verify-phase NN per phase (manual close path)
+    3. Continue audit anyway (only assesses what is documented — likely
+       reports 0% goal coverage)
+    0. Cancel
+```
+
+In `mode: yolo` (read via `node .rihal/bin/rihal-tools.cjs config-get
+mode`), auto-pick option 1. In guided mode, ask. STOP after the user
+picks 0 or 2; resume audit at Step 4 after option 1 completes.
+
+If `PLANS == 0`:
+
+```
+⚠ No phase summaries and no plans found. Have phases been executed?
   Check: {MILESTONE_DIR}/phases/
+  Start one: /rihal:plan
 ```
 
+STOP.
+
 If ROADMAP missing:
 
 ```

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