@hanzlaa/rcode 3.4.32 → 3.5.0

package/rihal/workflows/list-workspaces.md

@@ -93,7 +93,7 @@ Otherwise:
 ```
 ✓ {count} active workspaces
   Use --detail for full status
-  Switch: /rihal-workspace <name>
+  Switch: /rihal-workstream switch --name <name>
   Remove: /rihal-remove-workspace <name>
 ```
 

package/rihal/workflows/map-codebase.md

@@ -169,7 +169,7 @@ Use Task tool with `subagent_type="rihal-codebase-mapper"`, `model="{mapper_mode
 ```
 Task(
   subagent_type="rihal-codebase-mapper",
-  model="sonnet",
+  model="{model}",
   model="{mapper_model}",
   run_in_background=true,
   description="Map codebase tech stack",
@@ -191,7 +191,7 @@ ${AGENT_SKILLS_MAPPER}"
 ```
 Task(
   subagent_type="rihal-codebase-mapper",
-  model="sonnet",
+  model="{model}",
   model="{mapper_model}",
   run_in_background=true,
   description="Map codebase architecture",
@@ -213,7 +213,7 @@ ${AGENT_SKILLS_MAPPER}"
 ```
 Task(
   subagent_type="rihal-codebase-mapper",
-  model="sonnet",
+  model="{model}",
   model="{mapper_model}",
   run_in_background=true,
   description="Map codebase conventions",
@@ -235,7 +235,7 @@ ${AGENT_SKILLS_MAPPER}"
 ```
 Task(
   subagent_type="rihal-codebase-mapper",
-  model="sonnet",
+  model="{model}",
   model="{mapper_model}",
   run_in_background=true,
   description="Map codebase concerns",

package/rihal/workflows/new-milestone.md

@@ -22,15 +22,32 @@ Valid rihal subagent types (use exact names — do not fall back to 'general-pur
 Parse `$ARGUMENTS` before anything else:
 - `--reset-phase-numbers` flag → restart roadmap phase numbering at `1`
 - `--dry-run` flag → show what would be written, do not commit
+- `--from-draft <path>` flag → use an existing MILESTONE-CONTEXT.md or ROADMAP draft as the milestone definition (closes #740). When present, set `DRAFT_FILE=<path>` and `FROM_DRAFT_MODE=true`.
 - Remaining text → milestone name (optional)
 
-If the flag is absent, continue phase numbering from the previous milestone.
+If `--from-draft` is absent, continue phase numbering from the previous milestone.
+
+**From-draft mode (closes #740):**
+
+When `FROM_DRAFT_MODE=true`:
+1. Read the draft file at `DRAFT_FILE`. Accept any markdown file — MILESTONE-CONTEXT.md, a scratch doc, or a ROADMAP partial.
+2. Extract milestone name (first `# Heading` or the filename stem), goals list, and any explicit phase list.
+3. Skip the interactive goal-gathering interview (steps 2–4). Jump directly to step 5 (Requirements scoping) using the draft as the source of truth.
+4. Surface a one-line banner:
+   ```
+   ◆ From-draft mode: using {DRAFT_FILE} as milestone definition (skipping goal interview)
+   ```
+5. If `DRAFT_FILE` does not exist, abort:
+   ```
+   Error: --from-draft file not found: {DRAFT_FILE}
+   ```
 
 Read these files in parallel:
 - `.planning/PROJECT.md` — existing project, validated requirements, decisions
 - `.planning/MILESTONES.md` — what shipped previously (may not exist on first milestone)
 - `.planning/STATE.md` — pending todos, blockers
 - `.planning/MILESTONE-CONTEXT.md` — if it exists (from a prior `/rihal-discuss` about the next milestone)
+- `{DRAFT_FILE}` (if `FROM_DRAFT_MODE=true`)
 
 If `.planning/PROJECT.md` does not exist, STOP and redirect:
 

package/rihal/workflows/new-project-research.md

@@ -60,6 +60,15 @@ Task(prompt="<research_type>
 Project Research — Stack dimension for [domain].
 </research_type>
 
+<objective>
+Identify the standard stack for [domain].
+
+Why this matters: this research feeds requirements definition and roadmap
+creation for {project_name}. A sufficient result lets the roadmap pick
+concrete libraries (with versions and rationale) and sequence build phases —
+not a vague survey of options.
+</objective>
+
 <milestone_context>
 [greenfield OR subsequent]
 
@@ -100,6 +109,15 @@ Task(prompt="<research_type>
 Project Research — Features dimension for [domain].
 </research_type>
 
+<objective>
+Identify the feature landscape for [domain].
+
+Why this matters: this research feeds requirements definition and roadmap
+creation for {project_name}. A sufficient result lets requirements separate
+table stakes from differentiators and anti-features — not an undifferentiated
+feature list.
+</objective>
+
 <milestone_context>
 [greenfield OR subsequent]
 
@@ -140,6 +158,15 @@ Task(prompt="<research_type>
 Project Research — Architecture dimension for [domain].
 </research_type>
 
+<objective>
+Identify how [domain] systems are structured.
+
+Why this matters: this research feeds requirements definition and roadmap
+creation for {project_name}. A sufficient result lets the roadmap sequence
+phases by component dependency and data flow — not a generic architecture
+sketch.
+</objective>
+
 <milestone_context>
 [greenfield OR subsequent]
 
@@ -180,6 +207,14 @@ Task(prompt="<research_type>
 Project Research — Pitfalls dimension for [domain].
 </research_type>
 
+<objective>
+Identify the common mistakes in [domain] projects.
+
+Why this matters: this research feeds requirements definition and roadmap
+creation for {project_name}. A sufficient result lets the roadmap assign each
+pitfall a prevention step in a specific phase — not a generic warning list.
+</objective>
+
 <milestone_context>
 [greenfield OR subsequent]
 
@@ -217,7 +252,24 @@ Use template: .rihal/templates/research-project/PITFALLS.md
 ", subagent_type="rihal-project-researcher", model="{researcher_model}", description="Pitfalls research")
 ```
 
-After all 4 agents complete, spawn synthesizer to create SUMMARY.md:
+**Sufficiency loop (per dimension, runs before synthesis):**
+
+@.rihal/references/iterative-retrieval.md
+
+After the 4 parallel researchers return, evaluate each dimension's returned
+artifact (STACK / FEATURES / ARCHITECTURE / PITFALLS) for sufficiency against
+that dimension's `<objective>` — does it cover every sub-question, are
+recommendations specific (versions/rationale) not vague, and were any
+`## RESEARCH INCONCLUSIVE` or blocked signals returned. For any dimension
+that is insufficient, re-dispatch that dimension's `rihal-project-researcher`
+with a follow-up prompt naming the specific gaps and including the prior
+result, asking only for the missing pieces. This loop is hard-capped at 3
+cycles per dimension (initial + up to 2 follow-ups). After the cap, proceed
+with the best result for that dimension and note residual gaps in its
+artifact. Only then continue to synthesis.
+
+After all 4 agents complete and the sufficiency loop has settled, spawn
+synthesizer to create SUMMARY.md:
 
 ```
 Task(prompt="

package/rihal/workflows/new-workspace.md

@@ -139,7 +139,7 @@ Start work:
   /rihal-plan <task> --workspace={WORKSPACE_NAME}
   
 Switch context:
-  /rihal-workspace {WORKSPACE_NAME}
+  /rihal-workstream switch --name {WORKSPACE_NAME}
 ```
 
 ## Success Criteria

package/rihal/workflows/plan-milestone.md

@@ -0,0 +1,105 @@
+<purpose>
+Plan all phases in a milestone using parallel dependency-wave execution. Closes #732.
+Groups independent phases into waves, spawns rihal-planner agents concurrently per wave, and verifies each SPRINT.md with rihal-sprint-checker before advancing.
+</purpose>
+
+<required_reading>
+@.rihal/references/output-format.md
+@.rihal/references/revision-loop.md
+Read all files referenced by the invoking prompt's execution_context before starting.
+</required_reading>
+
+## 1. Parse arguments and load context
+
+Parse `$ARGUMENTS`:
+- `--milestone <name>` — filter to a named milestone (optional)
+- `--dry-run` — show wave plan without spawning agents
+- `--skip-research` — skip rihal-phase-researcher for all phases
+- `--wave <N>` — start from wave N (resume after partial failure)
+
+```bash
+INIT_JSON=$(node ".rihal/bin/rihal-tools.cjs" state read 2>/dev/null || echo '{}')
+ROADMAP_PHASES=$(node ".rihal/bin/rihal-tools.cjs" roadmap list-phases 2>/dev/null || echo '[]')
+```
+
+## 2. Build dependency wave graph
+
+Read ROADMAP.md. For each planned phase:
+1. Extract its `**Dependencies:**` line (if present) — list of phase numbers it depends on.
+2. Phases with no dependencies → Wave 1.
+3. Phases whose all dependencies are in Wave N → Wave N+1.
+4. Repeat until all phases are assigned.
+
+**Display wave plan:**
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ RIHAL ► PLAN MILESTONE: {MILESTONE_NAME}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Wave 1 (parallel): Phase {N1}, Phase {N2}
+Wave 2 (parallel): Phase {N3}
+Wave 3 (serial):   Phase {N4}  ← depends on N3
+```
+
+If `--dry-run`: print the plan and exit.
+
+## 3. Execute waves sequentially, phases in parallel
+
+For each wave:
+
+**3a. Spawn rihal-planner agents in parallel (one per phase in wave):**
+
+Use `run_in_background: true` for each Agent dispatch. Wait for all to complete before next wave.
+
+```
+◆ Wave {N}: planning {count} phase(s) in parallel...
+  - Phase {N1}: {name}
+  - Phase {N2}: {name}
+```
+
+Each planner agent receives:
+- Phase number, name, goal from ROADMAP
+- `--skip-research` if flag is set
+- Research from RESEARCH.md if it exists
+
+**3b. Verify each SPRINT.md with rihal-sprint-checker:**
+
+After all planners in the wave complete, spawn rihal-sprint-checker for each SPRINT.md (in parallel, same run_in_background pattern). Collect CHECK.md results.
+
+On `FAIL` for any phase:
+```
+⚠ Phase {N} sprint-checker FAIL — entering revision loop (max 2 iterations)
+```
+Spawn a revision planner with checker feedback. Max 2 revision rounds per phase.
+
+**3c. Advance to next wave:**
+
+Only advance when all phases in the current wave have a passing CHECK.md.
+
+## 4. Completion summary
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ RIHAL ► MILESTONE PLANNED ✓  {MILESTONE_NAME}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Waves: {N}
+Phases planned: {M}
+SPRINT.md files created: {M}
+
+Next step: /rihal-execute-milestone
+```
+
+## Output Format
+
+Open with wave-plan banner (step 2). Per-phase progress indicators. Closure banner (step 4).
+
+## Examples
+
+**Happy path:** `/rihal-plan-milestone` → plans all pending phases in parallel dependency waves.
+
+**Skip research:** `/rihal-plan-milestone --skip-research` → faster, uses CONTEXT.md if available.
+
+**Resume:** `/rihal-plan-milestone --wave 2` → skip wave 1 (already planned), start from wave 2.
+
+**Dry run:** `/rihal-plan-milestone --dry-run` → print wave assignment, exit.

package/rihal/workflows/plan-research-validation.md

@@ -111,7 +111,7 @@ Reason: {explain why}
 Task(
   prompt=research_prompt,
   subagent_type="rihal-phase-researcher",
-  model="sonnet",
+  model="{model}",
   model="{researcher_model}",
   description="Research Phase {phase}"
 )

package/rihal/workflows/plan-spawn-planner.md

@@ -205,7 +205,7 @@ Every task MUST include these fields — they are NOT optional:
 Task(
   prompt=filled_prompt,
   subagent_type="rihal-planner",
-  model="sonnet",
+  model="{model}",
   model="{planner_model}",
   description="Plan Phase {phase}"
 )

package/rihal/workflows/plan.md

@@ -94,7 +94,7 @@ Parse JSON for: `researcher_model`, `planner_model`, `checker_model`, `research_
 
 ## 2. Parse and Normalize Arguments
 
-Extract from $ARGUMENTS: phase number (integer or decimal like `2.1`), flags (`--research`, `--skip-research`, `--gaps`, `--skip-verify`, `--prd <filepath>`, `--reviews`, `--text`).
+Extract from $ARGUMENTS: phase number (integer or decimal like `2.1`), flags (`--research`, `--skip-research`, `--gaps`, `--skip-verify`, `--from-stub`, `--prd <filepath>`, `--reviews`, `--text`).
 
 Set `TEXT_MODE=true` if `--text` is present in $ARGUMENTS OR `text_mode` from init JSON is `true`. When `TEXT_MODE` is active, replace every `AskUserQuestion` call with a plain-text numbered list and ask the user to type their choice number. This is required for Claude Code remote sessions (`/rc` mode) where TUI menus don't work through the Claude App.
 
@@ -111,6 +111,34 @@ fi
 
 When `GAPS_MODE=true`, the workflow switches to **gap-closure planning**: read the phase's VERIFICATION.md, extract verification gaps classified `gap_found` or `partial`, and produce a single new numbered plan file (`NNN-NN-SPRINT.md`) that closes them. Research, CONTEXT.md gating, and VALIDATION.md creation are skipped — gaps are grounded in already-shipped code, not new design work.
 
+**Detect from-stub mode (closes #736):**
+```bash
+if [[ "$ARGUMENTS" =~ (^|[[:space:]])--from-stub($|[[:space:]]) ]]; then
+  FROM_STUB_MODE=true
+else
+  FROM_STUB_MODE=false
+fi
+```
+
+When `FROM_STUB_MODE=true`, the workflow reads an existing stub `SPRINT.md` (or any `*-SPRINT.md`) already present in the phase directory and treats it as the authoritative task list — the researcher and CONTEXT.md gating are skipped. The stub is passed to the planner as `existing_stub_content` so it can refine, expand, and add implementation detail without rewriting the structure. This is the correct flow when a user has partially sketched a plan by hand or a prior workflow run created a skeleton.
+
+**From-stub resolution:**
+```bash
+if [[ "$FROM_STUB_MODE" == "true" ]]; then
+  STUB_FILE=$(ls "${PHASE_DIR}"/*-SPRINT.md 2>/dev/null | head -1)
+  if [[ -z "$STUB_FILE" ]]; then
+    echo "Error: --from-stub requires an existing SPRINT.md in the phase directory."
+    echo "Found: ${PHASE_DIR}"
+    echo "  (create a stub manually then re-run with --from-stub)"
+    exit 1
+  fi
+  STUB_CONTENT=$(cat "$STUB_FILE")
+  echo "◆ From-stub mode: using $(basename $STUB_FILE) as planner input"
+fi
+```
+
+When `FROM_STUB_MODE=true`: skip steps 4 (CONTEXT.md), 5 (Research), 5.5 (Validation strategy). Jump directly to step 8 (Spawn rihal-planner). Pass `STUB_CONTENT` and `STUB_FILE` to the planner prompt so it refines rather than replaces the stub.
+
 **If no phase number:** Detect next unplanned phase from roadmap.
 
 **If `phase_found` is false:** Validate phase exists in ROADMAP.md. If valid, create the directory using `phase_slug` and `padded_phase` from init:
@@ -536,7 +564,7 @@ ${AGENT_SKILLS_CHECKER}
 Task(
   prompt=checker_prompt,
   subagent_type="rihal-sprint-checker",
-  model="sonnet",
+  model="{model}",
   model="{checker_model}",
   description="Verify Phase {phase} plans"
 )
@@ -656,7 +684,7 @@ Return what changed.
 Task(
   prompt=revision_prompt,
   subagent_type="rihal-planner",
-  model="sonnet",
+  model="{model}",
   model="{planner_model}",
   description="Revise Phase {phase} plans"
 )

package/rihal/workflows/plant-seed.md

@@ -155,6 +155,12 @@ File: .planning/seeds/SEED-{PADDED}-{slug}.md
 
 This seed will surface automatically when you run /rihal-new-milestone
 and the milestone scope matches the trigger condition.
+
+▶ Next Up
+  /rihal-status                 — review current focus before context-switching
+  /rihal-note "{$IDEA}"         — capture related thoughts while fresh
+  /rihal-new-milestone           — start the milestone that will consume this seed
+  /rihal-do                      — return to the dispatcher
 ```
 </step>
 

package/rihal/workflows/quick.md

@@ -9,6 +9,7 @@ Closes the gap where /rihal-quick used to refuse + show a 4-option menu when giv
 
 <required_reading>
 @.rihal/references/verb-dictionary.md
+@.rihal/references/git-preflight.md
 </required_reading>
 
 <process>
@@ -161,15 +162,20 @@ git commit -m "{type}: {concise description of what changed}"
 </step>
 
 <step name="log_to_state">
-If `.planning/STATE.md` exists with a "Quick Tasks Completed" table, append:
+Append the completed task to `.planning/STATE.md`. Create the section if it
+doesn't exist — projects initialized with `/rihal-new-project` use a STATE.md
+shape that has no "Quick Tasks Completed" table by default (#601). Without
+this fallback the entry was silently dropped on every fresh repo.
 
 ```bash
-if grep -q "Quick Tasks Completed" .planning/STATE.md 2>/dev/null; then
-  echo "| $(date +%Y-%m-%d) | quick | $TASK | ✓ |" >> .planning/STATE.md
+mkdir -p .planning
+if [ ! -f .planning/STATE.md ]; then
+  printf '# Project State\n\n## Quick Tasks Completed\n\n| Date | Type | Task | Status |\n|------|------|------|--------|\n' > .planning/STATE.md
+elif ! grep -q "Quick Tasks Completed" .planning/STATE.md 2>/dev/null; then
+  printf '\n## Quick Tasks Completed\n\n| Date | Type | Task | Status |\n|------|------|------|--------|\n' >> .planning/STATE.md
 fi
+echo "| $(date +%Y-%m-%d) | quick | $TASK | ✓ |" >> .planning/STATE.md
 ```
-
-Skip silently if the table doesn't exist.
 </step>
 
 <step name="done">

package/rihal/workflows/research-phase.md

@@ -53,8 +53,19 @@ AGENT_SKILLS_RESEARCHER=$(node ".rihal/bin/rihal-tools.cjs" agent-skills rihal-r
 Task(
   prompt="<objective>
 Research implementation approach for Phase {phase}: {name}
+
+Why this phase matters: {description}
+Broader goal: this research output must enable the planning step to break
+Phase {phase} into concrete, buildable sprints — a sufficient result gives
+planning specific approaches, libraries (with versions/rationale), and known
+pitfalls, not a vague survey.
 </objective>
 
+<objective_context>
+Phase {phase} goal: {description}
+Downstream consumer: /rihal-plan reads {phase}-RESEARCH.md to structure sprints.
+</objective_context>
+
 <files_to_read>
 - {context_path} (USER DECISIONS from /rihal-discuss-phase)
 - {requirements_path} (Project requirements)
@@ -77,6 +88,19 @@ Write to: .planning/phases/${PHASE}-{slug}/${PHASE}-RESEARCH.md
 
 ## Step 5: Handle Return
 
+@.rihal/references/iterative-retrieval.md
+
+**Sufficiency loop (runs before routing):** When `rihal-phase-researcher`
+returns its `## RESEARCH COMPLETE` summary, evaluate it for sufficiency
+against the Step-4 objective — does it cover every dimension the phase goal
+asked for, are recommendations specific (versions/rationale) not vague, and
+were any `## RESEARCH INCONCLUSIVE` or blocked signals returned. If
+insufficient, re-dispatch `rihal-phase-researcher` with a follow-up prompt
+that names the specific gaps and includes the prior result, asking only for
+the missing pieces. This loop is hard-capped at 3 cycles (initial + up to 2
+follow-ups). After the cap, proceed with the best result and note residual
+gaps in the RESEARCH.md artifact. Then offer the routing options below.
+
 - `## RESEARCH COMPLETE` — Display summary, offer: Plan/Dig deeper/Review/Done
 - `## CHECKPOINT REACHED` — Present to user, spawn continuation
 - `## RESEARCH INCONCLUSIVE` — Show attempts, offer: Add context/Try different mode/Manual

package/rihal/workflows/scaffold-milestone.md

@@ -0,0 +1,60 @@
+<purpose>
+Bulk-create all phase directories for a milestone from a pipe-separated name list or from ROADMAP.md planned phases. Closes #731.
+</purpose>
+
+<process>
+
+## 1. Parse arguments
+
+If `--names` is provided in `$ARGUMENTS`:
+
+```bash
+node ".rihal/bin/rihal-tools.cjs" phase scaffold-milestone --names "${NAMES_ARG}" ${START_ARG:+--start $START_ARG}
+```
+
+Print the result JSON and exit.
+
+## 2. Auto-detect from ROADMAP.md (when no --names)
+
+Read `.planning/ROADMAP.md`. Extract all phase entries that:
+
+- Have a `**Status:** Planned` line
+- Do NOT have a corresponding directory under `.planning/phases/`
+
+Collect their names in order. Build a pipe-separated list and pass to scaffold-milestone:
+
+```bash
+PLANNED_NAMES="Phase A|Phase B|Phase C"
+node ".rihal/bin/rihal-tools.cjs" phase scaffold-milestone --names "${PLANNED_NAMES}"
+```
+
+## 3. Report
+
+Print a summary:
+
+```
+✓ Scaffolded {N} phase directories:
+  {number}-{slug}/
+  {number}-{slug}/
+  ...
+
+Next step: /rihal-plan {first_number}
+```
+
+</process>
+
+## Output Format
+
+One line per created phase directory. Final "Next step" routing.
+
+## Examples
+
+**With names:** `/rihal-scaffold-milestone --names "Auth System|Dashboard|API Layer"` → creates 3 phase dirs.
+
+**Auto-detect:** `/rihal-scaffold-milestone` → reads ROADMAP.md, creates dirs for all Planned phases without existing directories.
+
+## Success Criteria
+
+- [ ] Phase directories created under `.planning/phases/`
+- [ ] Summary printed with one line per created directory
+- [ ] Next-step routing printed

package/rihal/workflows/scaffold-skill.md

@@ -0,0 +1,137 @@
+# Workflow: rihal-scaffold-skill
+
+<purpose>
+Create a new compliant SKILL.md file for a Rihal role in one command. Eliminates the friction of finding a folder, reading an existing skill, copying it, renaming, and chasing the 5-component compliance check.
+
+Output: a SKILL.md that already passes `test/compliance.test.cjs` and is ready to be filled in.
+</purpose>
+
+## Step 0 — Parse Arguments
+
+Expected forms:
+
+```
+/rihal-scaffold-skill --role <role> --name <skill-name>
+/rihal-scaffold-skill --role pm --name sharper-prd-discovery
+/rihal-scaffold-skill --help
+```
+
+Required: `--role` (one of: `pm`, `qa`, `architect`, `frontend`, `backend`, `marketing`, `designer`, `writer`, `engineer`, `ml`, `branding`, `eng-manager`, `analyst`, `director`, `scout`).
+
+Required: `--name` — kebab-case identifier. Validate it matches `^[a-z][a-z0-9-]+$`.
+
+Optional: `--dry-run` — print the file content to stdout instead of writing.
+
+If `$ARGUMENTS` is `--help` or empty, print usage and STOP.
+
+## Step 1 — Resolve target path
+
+Map `--role` to a directory under `rihal/skills/actions/`. Group by role family:
+
+| Role flag | Target directory |
+|-----------|------------------|
+| `pm` | `rihal/skills/actions/1-discovery/rihal-<name>/` |
+| `architect` | `rihal/skills/actions/2-planning/rihal-<name>/` |
+| `engineer`, `frontend`, `backend`, `ml` | `rihal/skills/actions/4-implementation/rihal-<name>/` |
+| `qa` | `rihal/skills/actions/5-verification/rihal-<name>/` |
+| `designer`, `branding` | `rihal/skills/actions/3-design/rihal-<name>/` |
+| `marketing`, `writer`, `eng-manager`, `analyst`, `director`, `scout` | `rihal/skills/actions/6-other/rihal-<name>/` |
+
+If the directory already exists, abort with: `Skill rihal-<name> already exists at <path>. Pick a different --name or delete the existing directory first.`
+
+## Step 2 — Write the template
+
+Write `rihal/skills/actions/<group>/rihal-<name>/SKILL.md` with this content (substitute `<NAME>`, `<ROLE>`, `<DESCRIPTION_FILLER>`):
+
+```yaml
+---
+name: rihal-<NAME>
+description: >
+  <One-line summary of what this skill does. Activates when the user says
+  "<trigger phrase>", "<another phrase>". Do NOT use for: <negative
+  boundaries>.>
+triggers:
+  - "<trigger phrase 1>"
+  - "<trigger phrase 2>"
+  - "<trigger phrase 3>"
+  - "<trigger phrase 4>"
+  - "<trigger phrase 5>"
+---
+
+# <NAME> — <ROLE>
+
+## Overview
+
+<2-3 sentences explaining what the skill does and when it's invoked. What
+real-world problem does it solve? What does the user get back when they
+invoke it?>
+
+## Workflow
+
+<Step-by-step instructions the model follows. Use numbered steps. Each step
+should be specific enough that two different models converge to similar
+output. Reference rihal-tools subcommands where state changes are needed.>
+
+1. <First step>
+2. <Second step>
+3. <Third step>
+
+## Output Format
+
+<Exact shape of the output. If markdown, include the headers. If JSON, the
+schema. The compliance check expects this section verbatim — keep the
+heading text as "## Output Format".>
+
+## Examples
+
+### Happy path
+
+<Input → output example showing the skill at its best>
+
+### Edge case
+
+<Input → output for a tricky variant (missing data, ambiguous request, etc.)>
+
+### Negative
+
+<Input that should NOT trigger this skill — show the redirect>
+```
+
+## Step 3 — Verify compliance
+
+Run the 5-component check on the new file:
+
+```bash
+F="rihal/skills/actions/<group>/rihal-<name>/SKILL.md"
+fails=""
+grep -q "^triggers:" "$F" || fails="$fails triggers-frontmatter"
+grep -q "^## Overview"      "$F" || fails="$fails overview"
+grep -q "^## Workflow"      "$F" || fails="$fails workflow"
+grep -q "^## Output Format" "$F" || fails="$fails output-format"
+grep -q "^## Examples"      "$F" || fails="$fails examples"
+
+if [ -n "$fails" ]; then
+  echo "✖ Scaffolded skill missing components:$fails"
+  echo "  This is a bug in the scaffolder template — file an issue."
+  exit 1
+fi
+```
+
+## Step 4 — Confirm and Next Up
+
+Print:
+
+```
+✓ Skill scaffolded: rihal-<NAME>
+  Location: rihal/skills/actions/<group>/rihal-<NAME>/SKILL.md
+
+  All 5 required components are present (triggers, Overview, Workflow,
+  Output Format, Examples). The placeholders need real content before
+  the skill becomes useful.
+
+▶ Next Up
+  $EDITOR rihal/skills/actions/<group>/rihal-<NAME>/SKILL.md
+                                                  # fill in placeholders
+  npx @hanzlaa/rcode install --force              # install to .claude/skills/
+  node --test test/compliance.test.cjs            # verify compliance
+```

package/rihal/workflows/scan.md

@@ -227,7 +227,7 @@ Task(
 
   This scope section is non-negotiable — the orchestrator will reject documents missing it.",
   subagent_type="rihal-codebase-mapper",
-  model="sonnet",
+  model="{model}",
   model="{resolved_model}"
 )
 ```