@hanzlaa/rcode 2.2.0 → 2.3.1

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

@@ -1,185 +1,183 @@
 # Workflow: rihal:settings
 
 <purpose>
-Interactive configuration wizard for Rihal project settings. Collects user preferences for model profile, research strategy, execution gates, and branching strategy, then writes them back to .rihal/config.yaml.
+View and edit Rihal project settings stored in `.rihal/config.yaml`. Closes
+#233 — replaces the previous broken implementation that wrote flat keys
+nothing read and corrupted the nested `workflow:` / `git:` sections on every
+save.
+
+The single source of truth for config keys is the table in Step 1.5. All keys
+documented there are consumed somewhere in the codebase — settings that the
+wizard writes are settings that workflows actually honour.
 </purpose>
 
-
 ## Step 0 — Usage check
 
-If `$ARGUMENTS` is empty or contains only `--help` or `-h`:
+If `$ARGUMENTS` contains `--help` or `-h`:
 
 ```
-/rihal:settings <argument-here>
+/rihal:settings              # show current + interactive edit
+/rihal:settings show         # show current only
+/rihal:settings get <key>    # read a single dotted key (e.g. workflow.discuss_mode)
+/rihal:settings set <key> <value>   # write a single dotted key
 ```
 
 **Examples:**
 ```
-/rihal:settings example 1
-/rihal:settings example 2
+/rihal:settings show
+/rihal:settings get workflow.research_by_default
+/rihal:settings set workflow.research_by_default true
+/rihal:settings set git.branching_strategy feature-branch
 ```
 
-STOP — do not proceed.
+## Step 1 — Resolve mode
 
-<available_tools>
-- AskUserQuestion — collect user input
-- Read — read current config.yaml
-- Write — write updated config.yaml
-- Bash — validate git state if needed
-</available_tools>
+Parse `$ARGUMENTS`:
+- `show` (or empty) → run Step 1.5 then Step 2 (interactive)
+- `get <key>` → Step 1.7 then STOP
+- `set <key> <value>` → Step 1.8 then STOP
+- anything else → print usage from Step 0 and STOP
 
-## Step 1 — Initialize
+## Step 1.5 — Show current settings
 
-Load current settings from `.rihal/config.yaml`:
+Read each known key via `rihal-tools.cjs config-get <dotted.key>` (the
+nested-safe reader in `rihal/bin/lib/config.cjs`). **Do not** call the legacy
+`config set` — it uses a flat YAML parser and corrupts nested sections.
 
 ```bash
-[ -f .rihal/config.yaml ] && cat .rihal/config.yaml || echo "# No config yet"
+TOOL="node .rihal/bin/rihal-tools.cjs"
+$TOOL config-get user_name                            || echo "(unset)"
+$TOOL config-get communication_language               || echo "(unset)"
+$TOOL config-get mode                                 || echo "(unset)"
+$TOOL config-get model_profile                        || echo "(unset)"
+$TOOL config-get workflow.research_by_default         || echo "(unset)"
+$TOOL config-get workflow.plan_checker                || echo "(unset)"
+$TOOL config-get workflow.post_execute_gates          || echo "(unset)"
+$TOOL config-get workflow.ui_safety_gate              || echo "(unset)"
+$TOOL config-get workflow.discuss_mode                || echo "(unset)"
+$TOOL config-get git.branching_strategy               || echo "(unset)"
+$TOOL config-get git.commit_docs                      || echo "(unset)"
+$TOOL config-get output.verbose                       || echo "(unset)"
 ```
 
-Parse the config to extract current values:
-- `model_profile` (default: "balanced")
-- `enable_research_pre_step` (default: "false")
-- `enable_plan_checker_loop` (default: "true")
-- `enable_post_execute_verifier` (default: "false")
-- `branching_strategy` (default: "none")
-
-Store these as `current_*` variables for pre-fill use.
-
-## Step 2 — Collect Settings
-
-Use AskUserQuestion to prompt the user for each setting. Pre-fill current values where applicable.
-
-### Setting 1: Model Profile
+Render as a table:
 
 ```
-Question:
-Which model profile would you like to use?
+Current Rihal Settings (.rihal/config.yaml)
 
-Options:
-  1. quality (Opus for reasoning agents, Sonnet for executor, Haiku for utilities)
-  2. balanced (Sonnet across the board) [CURRENT]
-  3. budget (Haiku across the board)
-  4. inherit (Use parent session model, no override)
+  Identity
+    user_name                       : {value}
+    communication_language          : {value}
 
-Your choice: [pre-filled with current_model_profile]
-```
+  Execution
+    mode                            : {value}    # guided | yolo
+    model_profile                   : {value}    # quality | balanced | budget | inherit
 
-Valid responses: 1, 2, 3, 4, or exact names (quality, balanced, budget, inherit).
-Map numeric choices to profile names. Store as `new_model_profile`.
+  Workflow gates
+    workflow.research_by_default    : {value}    # true | false
+    workflow.plan_checker           : {value}    # true | false
+    workflow.post_execute_gates     : {value}    # true | false
+    workflow.ui_safety_gate         : {value}    # true | false
+    workflow.discuss_mode           : {value}    # adaptive | discuss | skip
 
-### Setting 2: Enable Research Pre-step
+  Output
+    output.verbose                  : {value}    # false (slim, default) | true (full detail)
 
+  Git
+    git.branching_strategy          : {value}    # none | feature-branch | worktree-isolation
+    git.commit_docs                 : {value}    # true | false
 ```
-Question:
-Enable research pre-step in /rihal:plan by default?
 
-This runs a research phase before planning if enabled, providing additional context.
+If invoked as `/rihal:settings show`, STOP here.
 
-Options:
-  1. Yes
-  2. No [CURRENT]
+## Step 1.7 — `get <key>`
 
-Your choice:
+```bash
+node .rihal/bin/rihal-tools.cjs config-get "$KEY"
 ```
 
-Valid responses: 1/yes/y or 2/no/n. Store as `new_enable_research_pre_step` (true/false string).
+Print the result (empty output means unset). STOP.
 
-### Setting 3: Enable Plan-Checker Loop
-
-```
-Question:
-Enable sprint-checker loop during /rihal:plan?
+## Step 1.8 — `set <key> <value>`
 
-This verifies and repairs plans before execution if enabled.
+Validate the key against the table in Step 1.5 — reject unknown keys with
+the table printed.
 
-Options:
-  1. Yes [CURRENT]
-  2. No
+Validate the value:
+- `mode` ∈ {guided, yolo}
+- `model_profile` ∈ {quality, balanced, budget, inherit}
+- `workflow.discuss_mode` ∈ {adaptive, discuss, skip}
+- `git.branching_strategy` ∈ {none, feature-branch, worktree-isolation}
+- `workflow.*` booleans ∈ {true, false}
+- `output.verbose` ∈ {true, false}
 
-Your choice:
+```bash
+node .rihal/bin/rihal-tools.cjs config-set "$KEY" "$VALUE"
 ```
 
-Valid responses: 1/yes/y or 2/no/n. Store as `new_enable_plan_checker_loop` (true/false string).
-
-### Setting 4: Enable Post-Execute Verifier Gates
-
+Print:
 ```
-Question:
-Enable post-execute verifier gates?
-
-This runs verification after each task execution to catch regressions and issues.
-
-Options:
-  1. Yes
-  2. No [CURRENT]
-
-Your choice:
+✓ {key} = {value}
 ```
 
-Valid responses: 1/yes/y or 2/no/n. Store as `new_enable_post_execute_verifier` (true/false string).
+STOP.
 
-### Setting 5: Branching Strategy
+## Step 2 — Interactive edit
+
+After Step 1.5 prints the table, ask:
 
 ```
 Question:
-What branching strategy should workflows use?
+Which setting would you like to change?
 
 Options:
-  1. none (No branching, work on current branch)
-  2. feature-branch (Create feature branches, leave checkout to user)
-  3. worktree-isolation (Use git worktrees for isolated work)
-
-Your choice: [pre-filled with current_branching_strategy]
-```
-
-Valid responses: 1, 2, 3, or exact names (none, feature-branch, worktree-isolation).
-Map numeric choices to strategy names. Store as `new_branching_strategy`.
-
-## Step 3 — Write Config
-
-After collecting all settings, write them back to `.rihal/config.yaml` using `rihal-tools.cjs config set`:
+  1. mode (guided / yolo)
+  2. model_profile
+  3. workflow.research_by_default
+  4. workflow.plan_checker
+  5. workflow.post_execute_gates
+  6. workflow.ui_safety_gate
+  7. workflow.discuss_mode
+  8. git.branching_strategy
+  9. git.commit_docs
+  10. communication_language
+  11. output.verbose (slim output / full detail)
+  0. Done — exit
+```
+
+For each pick, present the constrained option set from Step 1.8, accept the
+choice, then call:
 
 ```bash
-node .rihal/bin/rihal-tools.cjs config set --key model_profile --value "$new_model_profile"
-node .rihal/bin/rihal-tools.cjs config set --key enable_research_pre_step --value "$new_enable_research_pre_step"
-node .rihal/bin/rihal-tools.cjs config set --key enable_plan_checker_loop --value "$new_enable_plan_checker_loop"
-node .rihal/bin/rihal-tools.cjs config set --key enable_post_execute_verifier --value "$new_enable_post_execute_verifier"
-node .rihal/bin/rihal-tools.cjs config set --key branching_strategy --value "$new_branching_strategy"
+node .rihal/bin/rihal-tools.cjs config-set "{dotted.key}" "{value}"
 ```
 
-## Step 4 — Confirm and Print
+After each successful write, re-display the affected row from Step 1.5 so the
+user sees the change took effect.
 
-Print a summary of the new settings:
+Loop until the user picks `0. Done`.
 
-```
-✓ Settings updated successfully!
+## Step 3 — Closing summary
 
-Model Profile: $new_model_profile
-Research pre-step: $new_enable_research_pre_step
-Plan-checker loop: $new_enable_plan_checker_loop
-Post-execute verifier: $new_enable_post_execute_verifier
-Branching strategy: $new_branching_strategy
+Print:
 
-Settings saved to: .rihal/config.yaml
 ```
+✓ Settings saved to .rihal/config.yaml
 
-Print a tip:
-
-```
-Tip: Use /rihal:resume-work to reload config and continue work.
+Tip: settings take effect on the next workflow run. Use /rihal:settings show
+to verify, or /rihal:resume-work to reload context.
 ```
 
 ## Success Criteria
 
-- [ ] Task completed as requested
-- [ ] Output saved or reported
-- [ ] State updated if necessary
-- [ ] No errors encountered
+- [ ] `/rihal:settings show` prints all 11 keys (no `(unset)` for keys with defaults)
+- [ ] `/rihal:settings set workflow.discuss_mode discuss` round-trips: `config-get` returns `discuss`
+- [ ] After any save, sibling keys in `workflow:` and `git:` blocks are preserved (no nesting corruption)
+- [ ] Unknown keys are rejected with the allowed-keys table
 
 ## 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
-
+- **`.rihal/config.yaml` missing:** print "No config found. Run /rihal:init first." and STOP.
+- **Invalid key:** print the allowed keys from Step 1.5 and STOP.
+- **Invalid value:** print the allowed values for that key and STOP.
+- **`rihal-tools.cjs` missing:** print "Run: npx @hanzlaa/rcode install ." and STOP.

package/rihal/workflows/sprint-planning.md

@@ -1,11 +1,46 @@
 # Workflow: rihal:sprint-planning
 
 <purpose>
-Plan the next sprint: compute capacity from velocity history, prioritize stories from phase scope, create SPRINT.md, register sprint + stories in state.json.
-
-Uses rihal-tools.cjs sprint/story state commands for tracking.
+Plan the next sprint. Authoritative implementation lives in the
+`rihal-sprint-planning` skill — this workflow delegates to it so every
+safety rail (capacity gate per #127, halt-at-menu per #124, state-sync
+per #198) fires identically whether the user invokes the slash command
+or the phrase-activated skill.
+
+The skill MUST be loaded before the in-line steps below run. If the skill
+file is missing (broken install), report and stop — do not silently fall
+back to the in-line implementation.
 </purpose>
 
+<delegate_to_skill>
+Required skill: `rihal-sprint-planning`
+Path:           `.claude/skills/rihal-sprint-planning/SKILL.md`
+Workflow ref:   `.claude/skills/rihal-sprint-planning/workflow.md`
+
+Behaviour:
+1. Load the skill's `SKILL.md` and `workflow.md`. Apply every Critical
+   Rule from the workflow's `## CRITICAL RULES (NO EXCEPTIONS)` block,
+   including the capacity gate (step n="0") which MUST halt for
+   numeric capacity inputs before any story is committed.
+2. Run the skill's step files in order. The in-line steps below this
+   block are a fallback summary for legacy installs that lack the skill;
+   they are NOT the authoritative behaviour.
+3. After SPRINT.md is written, ALWAYS run:
+   `node .rihal/bin/rihal-tools.cjs state sync --from-disk`
+   so state.sprints[] reflects the new sprint.
+
+If skill files are missing: print
+"Sprint-planning skill not installed. Run: npx @hanzlaa/rcode install"
+and exit non-zero. Do not proceed with the legacy in-line steps because
+they bypass the capacity gate.
+</delegate_to_skill>
+
+<required_reading>
+@.rihal/references/output-format.md
+@.rihal/skills/_shared/no-autonomous-bypass.md
+@.rihal/skills/_shared/state-sync-rule.md
+</required_reading>
+
 <output_format>
 Open with banner:
 ```
@@ -13,15 +48,11 @@ Open with banner:
  RIHAL ► PLANNING SPRINT
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ```
-TaskCreate: "Load phase scope + velocity", "Curate stories with user", "Register sprint + stories in state", "Write SPRINT.md", "Start sprint".
+TaskCreate: "Load phase scope + velocity", "Capacity gate (halt for numbers)", "Curate stories with user", "Register sprint + stories in state", "Write SPRINT.md", "Sync state", "Start sprint".
 Closure: `RIHAL ► SPRINT {NN.S} READY ✓ ({N} stories, {M} points)`
 Next Up: `/rihal:execute .planning/phases/{phase}/SPRINT.md`
 </output_format>
 
-<required_reading>
-@.rihal/references/output-format.md
-</required_reading>
-
 <process>
 ## Step 0 — Usage check
 

package/rihal/workflows/status.md

@@ -16,10 +16,15 @@ Render a human-readable project status dashboard. All data comes from a single `
 
 ```bash
 SNAPSHOT=$(node .rihal/bin/rihal-tools.cjs progress init)
+VERBOSE=$(node .rihal/bin/rihal-tools.cjs config-get output.verbose 2>/dev/null || echo "false")
 ```
 
 Parse as JSON. If `SNAPSHOT.ok` is not true, print a one-line error and stop.
 
+**Slim mode** (default when `VERBOSE != "true"`): Output Steps 2–3 only (banner + phases list). Skip decisions, blockers detail, and route menu — just print the top route as a single "Next: `/rihal:X`" line. Append `(run /rihal:status --verbose for full detail)`.
+
+**Verbose mode** (`VERBOSE == "true"` or `$ARGUMENTS` contains `--verbose`): Full Steps 2–6 output.
+
 If `SNAPSHOT.project` is empty and `SNAPSHOT.phases` is empty, print:
 
 ```

package/rihal/workflows/ui-phase.md

@@ -22,7 +22,7 @@ If `$ARGUMENTS` is empty or contains only `--help` or `-h`:
 STOP — do not proceed.
 
 <available_agent_types>
-- `rihal-ui-designer` — UI specification generator
+- `rihal-ux-designer` — UI specification generator
 </available_agent_types>
 
 ## Step 0 — Initialize
@@ -51,11 +51,11 @@ Load existing design system, extract:
 
 ## Step 2 — Spawn UI Designer
 
-Spawn `rihal-ui-designer` subagent:
+Spawn `rihal-ux-designer` subagent:
 
 ```
 Task tool call:
-  subagent_type: "rihal-ui-designer"
+  subagent_type: "rihal-ux-designer"
   description: "Generate UI-SPEC.md"
   prompt: |
     Generate a UI-SPEC.md file with the following structure: