@hanzlaa/rcode 3.6.16 → 4.0.0

package/rihal/workflows/audit-worktrees.md

@@ -1,163 +0,0 @@
-# Workflow: audit-worktrees
-
-<purpose>
-Scan for orphaned executor worktrees and branches left behind by rihal-execute.
-Reports each orphan with its age, merge status, and safe-to-delete verdict.
-With --prune, deletes confirmed-safe orphans automatically.
-</purpose>
-
-## Step 0 — Parse arguments
-
-- `--prune` → `PRUNE=true` — delete safe orphans after reporting
-- `--help` or `-h` → print usage and stop:
-  ```
-  /rihal-audit worktrees [--prune]
-  ```
-
-## Step 1 — Scan for orphaned worktrees
-
-Executor agents use branches prefixed `worktree-agent-`. Find all such branches
-and worktrees still present in the repo:
-
-```bash
-# Active worktrees with executor branches
-git worktree list --porcelain \
-  | awk 'BEGIN{p=""} /^worktree /{p=$2} /^branch /{if($2~/refs\/heads\/worktree-agent-/) print p"\t"$2}' \
-  > /tmp/rihal-active-wts.txt
-
-# Local branches with executor prefix (includes detached/removed worktrees)
-git branch --list 'worktree-agent-*' --format='%(refname:short)' \
-  > /tmp/rihal-orphan-br.txt
-
-ACTIVE_WT_COUNT=$(wc -l < /tmp/rihal-active-wts.txt)
-ORPHAN_BR_COUNT=$(wc -l < /tmp/rihal-orphan-br.txt)
-TOTAL=$((ACTIVE_WT_COUNT + ORPHAN_BR_COUNT))
-```
-
-If `TOTAL` is 0:
-
-```
-✓ No orphaned executor worktrees or branches found.
-```
-
-Stop.
-
-## Step 2 — For each orphan, gather intelligence
-
-For each entry (worktree or branch), run:
-
-```bash
-# Is it merged into the current branch?
-MERGED=$(git branch --merged HEAD --list '<branch>' 2>/dev/null | grep -c '<branch>')
-
-# When was the last commit on this branch?
-LAST_COMMIT=$(git log -1 --format="%ar %s" '<branch>' 2>/dev/null || echo "unknown")
-
-# How many commits does it have that are NOT on HEAD?
-AHEAD=$(git rev-list HEAD..'<branch>' --count 2>/dev/null || echo "?")
-```
-
-Build a report table:
-
-```
-RIHAL ► WORKTREE AUDIT
-══════════════════════════════════════════════════════════
-
-Orphaned executor artifacts: {TOTAL}
-
-  Branch                          Merged  Ahead  Last commit
-  ──────────────────────────────  ──────  ─────  ──────────────────────
-  worktree-agent-abc123           YES     0      3 days ago  feat: add auth
-  worktree-agent-def456           NO      2      1 hour ago  wip: migrations
-  ...
-
-Active worktrees still pointing to executor branches:
-  .claude/worktrees/agent-abc123  →  worktree-agent-abc123
-  ...
-```
-
-## Step 3 — Classify each orphan
-
-For each branch/worktree:
-
-- **SAFE** → `MERGED=YES` AND `AHEAD=0` — all commits are on HEAD, nothing to lose
-- **STALE** → `MERGED=YES` AND `AHEAD>0` — commits are ahead but branch is in merged list (rebased/squash-merged); verify before deleting
-- **UNMERGED** → `MERGED=NO` — DO NOT auto-delete; show explicitly and warn
-
-Print classification next to each entry.
-
-## Step 4 — Report summary
-
-```
-Summary:
-  SAFE to delete:     {N}  (merged, 0 ahead)
-  STALE (check first): {N}  (merged but ahead — may be rebase/squash)
-  UNMERGED (keep):    {N}  (not merged — manual review required)
-
-  To prune SAFE orphans: /rihal-audit worktrees --prune
-  To inspect UNMERGED:   git log HEAD..<branch> --oneline
-```
-
-If `PRUNE=false`, stop here.
-
-## Step 5 — Prune (only when --prune passed)
-
-Delete SAFE entries only. Never touch STALE or UNMERGED.
-
-For each SAFE branch:
-
-```bash
-# Remove the worktree if it still exists
-WT_PATH=$(awk -F'\t' '$2=="refs/heads/<branch>"{print $1}' /tmp/rihal-active-wts.txt)
-if [ -n "$WT_PATH" ] && [ -d "$WT_PATH" ]; then
-  git worktree remove "$WT_PATH" --force 2>/dev/null \
-    && echo "  ✓ removed worktree: $WT_PATH" \
-    || echo "  ⚠ could not remove worktree: $WT_PATH"
-fi
-
-# Delete the branch
-git branch -D '<branch>' 2>/dev/null \
-  && echo "  ✓ deleted branch: <branch>" \
-  || echo "  ⚠ could not delete branch: <branch>"
-```
-
-After all deletes, re-run Step 1 scan and confirm `TOTAL=0` for SAFE entries.
-
-Print final report:
-
-```
-Pruned: {N} safe orphans removed
-Kept:   {N} unmerged branches (manual review required)
-
-✓ Worktree cleanup complete
-```
-
-## Step 6 — Post-audit health note
-
-If any UNMERGED branches remain, print:
-
-```
-⚠ {N} unmerged executor branch(es) still present.
-  These have commits NOT on your current branch.
-  Inspect before deleting:
-
-  git log HEAD..worktree-agent-<id> --oneline
-  git show worktree-agent-<id>:<file>   # inspect specific file
-
-  To delete after manual review:
-  git worktree remove .claude/worktrees/<id> --force
-  git branch -D worktree-agent-<id>
-```
-
-## Success Criteria
-
-- [ ] All `worktree-agent-*` branches and worktrees found and reported
-- [ ] Each classified as SAFE / STALE / UNMERGED based on actual merge status
-- [ ] `--prune` deletes only SAFE entries, never UNMERGED
-- [ ] Post-prune confirmation scan verifies cleanup succeeded
-- [ ] Non-executor worktrees (feature branches, manual worktrees) are never touched
-
-## On Error
-
-- `git worktree list` fails → print `git not available or not a repo` and stop
-- `git branch -D` fails on a branch → skip it, note it in the report, continue

package/rihal/workflows/audit.md

@@ -1,202 +0,0 @@
-# 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`, `code-review --karpathy`,
-`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 plans [--report]         # → audit-plans (structural + status + deps check)
-/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-code-review --karpathy
-/rihal-audit fix                       # → /rihal-audit-fix
-/rihal-audit work                      # → /rihal-verify-work
-/rihal-audit lens [<1-15> | all]       # → /rihal-lens-audit (15-lens methodology)
-/rihal-audit worktrees [--prune]       # → scan + report orphaned executor worktrees/branches
-```
-
-**Examples:**
-```
-/rihal-audit
-/rihal-audit plans
-/rihal-audit plans --report
-/rihal-audit milestone --strict
-/rihal-audit phase 03
-/rihal-audit lens security
-/rihal-audit lens all
-```
-
-## 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 ∈ {plans, phase, milestone, uat, code, fix, work, lens, worktrees} → 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 -o -name '*-SPRINT.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)
-
-Also probe for orphaned executor worktrees (add to context for Step 3 menu):
-
-```bash
-ORPHAN_WTS=$(git worktree list --porcelain \
-  | awk '/^branch /{if($2 ~ /refs\/heads\/worktree-agent-/) print $2}' \
-  | wc -l)
-ORPHAN_BR=$(git branch --list 'worktree-agent-*' 2>/dev/null | wc -l)
-ORPHANS=$((ORPHAN_WTS + ORPHAN_BR))
-```
-
-If `$MODE` is `yolo`, skip this step and pick the most relevant target
-automatically (priority: `worktrees` if ORPHANS>0, else `work` if dirty
-branch, else `plans` 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. plans           — planning integrity: completeness, status, deps ({PLANS} sprints)
-  2. phase           — verify a single phase against its PLAN          ({PLANS} plans)
-  3. milestone       — cross-phase milestone goal coverage             ({SUMMARIES} summaries)
-  4. uat             — outstanding UAT / verification items            ({UAT_FILES} files)
-  5. code-quality    — Karpathy 4-principle code review                (current diff)
-  6. auto-fix        — audit then auto-fix findings                    (uses #1–5 output)
-  7. work            — verify current branch / WIP                     ({ON_BRANCH}, dirty={DIRTY})
-  8. lens            — 15-lens methodology audit                       (security, perf, tests…)
-  9. worktrees       — orphaned executor worktrees/branches            ({ORPHANS} found)
-  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 |
-|---|---|---|
-| plans | `.planning/ROADMAP.md` exists | `No ROADMAP.md. Run /rihal-new-milestone first.` |
-| phase | at least one `.planning/phases/*/PLAN.md` or `*-SPRINT.md` | `No plan file 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.` |
-| lens | `rihal/` or `.rihal/` directory exists | `No rihal source found. Run: npx @hanzlaa/rcode install .` |
-| worktrees | git repo exists | `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 SPRINT.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 SPRINT.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 SPRINT.md` + `Write SUMMARY.md`.
-
-## Step 5 — Dispatch
-
-Run the target's slash command, forwarding remaining args:
-
-| target | dispatch |
-|---|---|
-| plans | execute `@.rihal/workflows/audit-plans.md` inline |
-| phase | `/rihal-verify-phase $REST_ARGS` |
-| milestone | `/rihal-audit-milestone $REST_ARGS` |
-| uat | `/rihal-audit-uat $REST_ARGS` |
-| code | `/rihal-code-review $REST_ARGS --karpathy` |
-| lens | `/rihal-lens-audit $REST_ARGS` |
-| fix | `/rihal-audit-fix $REST_ARGS` |
-| work | `/rihal-verify-work $REST_ARGS` |
-| worktrees | execute `@.rihal/workflows/audit-worktrees.md` inline |
-
-## 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-audit lens        — 15-lens methodology audit
-  /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
-- [ ] `/rihal-audit lens` dispatches to `/rihal-lens-audit` interactive picker
-- [ ] `/rihal-audit lens security` passes `security` directly to `/rihal-lens-audit`
-- [ ] When SUMMARY.md absent but SPRINT.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-smart-discuss.md

@@ -1,248 +0,0 @@
-<purpose>
-Sub-step of autonomous.md — smart discuss loop for a single phase. Proposes grey area answers in batch tables; user accepts or overrides. Produces identical CONTEXT.md output to regular discuss-phase.
-</purpose>
-
-<step name="smart_discuss">
-
-## Smart Discuss
-
-Run smart discuss for the current phase. Proposes grey area answers in batch tables — the user accepts or overrides per area. Produces identical CONTEXT.md output to regular discuss-phase.
-
-**Inputs:** `PHASE_NUM` (local loop alias for `PHASE_NUMBER` from the iterate loop) from execute_phase. Resolve phase paths:
-
-```bash
-PHASE_NUM="${PHASE_NUM}"  # local alias; other workflows use PHASE_NUMBER from init JSON
-# Issue #652 — no leading zeros. Variable name kept for backward compat.
-PADDED_PHASE="${PHASE_NUM%.*}"
-PHASE_DIR=".planning/phases/${PADDED_PHASE}-${PHASE_SLUG}"
-```
-
----
-
-### Sub-step 1: Load prior context
-
-Read project-level and prior phase context to avoid re-asking decided questions.
-
-**Read project files:**
-
-```bash
-cat .planning/PROJECT.md 2>/dev/null || true
-cat .planning/REQUIREMENTS.md 2>/dev/null || true
-cat .planning/STATE.md 2>/dev/null || true
-```
-
-Extract from these:
-- **PROJECT.md** — Vision, principles, non-negotiables, user preferences
-- **REQUIREMENTS.md** — Acceptance criteria, constraints, must-haves vs nice-to-haves
-- **STATE.md** — Current progress, decisions logged so far
-
-**Read prior CONTEXT.md files (most recent 5 phases — cap prevents context overflow on large projects):**
-
-```bash
-(find .planning/phases -name "*-CONTEXT.md" -o -name "CONTEXT.md" 2>/dev/null || true) | sort | tail -5
-```
-
-For each CONTEXT.md where phase number < current phase (max 5):
-- Read the `<decisions>` section — these are locked preferences
-- Read `<specifics>` — particular references or "I want it like X" moments
-- Note patterns (e.g., "user consistently prefers minimal UI", "user rejected verbose output")
-
-**Build internal prior_decisions context** (do not write to file).
-
-If no prior context exists, continue without — expected for early phases.
-
----
-
-### Sub-step 2: Scout Codebase
-
-Lightweight codebase scan to inform grey area identification. Keep under ~5% context.
-
-**Check for existing codebase maps:**
-
-```bash
-ls .planning/codebase/*.md 2>/dev/null || true
-```
-
-**If codebase maps exist:** Read the most relevant ones (CONVENTIONS.md, STRUCTURE.md, STACK.md based on phase type).
-
-**If no codebase maps, do targeted grep:**
-
-```bash
-grep -rl "{term1}\|{term2}" src/ app/ --include="*.ts" --include="*.tsx" --include="*.js" --include="*.jsx" 2>/dev/null | head -10 || true
-ls src/components/ src/hooks/ src/lib/ src/utils/ 2>/dev/null || true
-```
-
-Read the 3-5 most relevant files to understand existing patterns.
-
-**Build internal codebase_context** (do not write to file):
-- **Reusable assets** — existing components, hooks, utilities usable in this phase
-- **Established patterns** — how the codebase does state management, styling, data fetching
-- **Integration points** — where new code connects (routes, nav, providers)
-
----
-
-### Sub-step 3: Analyze Phase and Generate Proposals
-
-Extract `goal`, `requirements`, `success_criteria` from ROADMAP.md for this phase.
-
-**Infrastructure detection — check FIRST:**
-
-A phase is pure infrastructure when ALL are true:
-1. Goal keywords match: "scaffolding", "plumbing", "setup", "configuration", "migration", "refactor", "rename", "restructure", "upgrade", "infrastructure"
-2. AND success criteria are all technical: "file exists", "test passes", "config valid", "command runs"
-3. AND no user-facing behavior is described (no "users can", "displays", "shows", "presents")
-
-**If infrastructure-only:** Skip Sub-step 4. Jump directly to Sub-step 5 with minimal CONTEXT.md. Display:
-
-```
-Phase ${PHASE_NUM}: Infrastructure phase — skipping discuss, writing minimal context.
-```
-
-**If NOT infrastructure — generate grey area proposals:**
-
-Determine domain type from the phase goal:
-- Something users **SEE** → visual: layout, interactions, states, density
-- Something users **CALL** → interface: contracts, responses, errors, auth
-- Something users **RUN** → execution: invocation, output, behavior modes, flags
-- Something users **READ** → content: structure, tone, depth, flow
-- Something being **ORGANIZED** → organization: criteria, grouping, exceptions, naming
-
-Check prior_decisions — skip grey areas already decided in prior phases.
-
-Generate **3-4 grey areas** with **~4 questions each**. For each question:
-- **Pre-select a recommended answer** based on: prior decisions, codebase patterns, domain conventions, ROADMAP success criteria
-- Generate **1-2 alternatives** per question
-- **Annotate** with prior decision context and code context
-
----
-
-### Sub-step 4: Present Proposals Per Area
-
-Present grey areas **one at a time**. For each area (M of N), display a table:
-
-```
-### Grey Area {M}/{N}: {Area Name}
-
-| # | Question | ✓ Recommended | Alternative(s) |
-|---|----------|---------------|-----------------|
-| 1 | {question} | {answer} — {rationale} | {alt1}; {alt2} |
-| 2 | {question} | {answer} — {rationale} | {alt1} |
-| 3 | {question} | {answer} — {rationale} | {alt1}; {alt2} |
-| 4 | {question} | {answer} — {rationale} | {alt1} |
-```
-
-Then prompt via **AskUserQuestion**:
-- **header:** "Area {M}/{N}"
-- **question:** "Accept these answers for {Area Name}?"
-- **options:** Build dynamically — always "Accept all" first, then "Change Q1" through "Change QN" for each question (up to 4), then "Discuss deeper" last. Cap at 6 explicit options max.
-
-**On "Accept all":** Record all recommended answers. Move to next area.
-
-**On "Change QN":** Use AskUserQuestion with the alternatives for that specific question:
-- **options:** List the 1-2 alternatives plus "You decide" (maps to Claude's Discretion)
-
-Record the user's choice. Re-display updated table. Re-present acceptance prompt.
-
-**On "Discuss deeper":** Switch to interactive mode — ask questions one at a time using AskUserQuestion with 2-3 concrete options per question plus "You decide". After 4 questions, prompt:
-- **options:** "More questions" / "Next area"
-
-**On "Other" (free text):** Interpret as a change request or general feedback. Incorporate, re-display, re-present.
-
-**Scope creep handling:** If user mentions something outside the phase domain:
-
-```
-"{Feature} sounds like a new capability — that belongs in its own phase.
-I'll note it as a deferred idea.
-
-Back to {current area}: {return to current question}"
-```
-
-Track deferred ideas internally for inclusion in CONTEXT.md.
-
----
-
-### Sub-step 5: Write CONTEXT.md
-
-After all areas are resolved (or infrastructure skip), write the CONTEXT.md file.
-
-**File path:** `${PHASE_DIR}/${PADDED_PHASE}-CONTEXT.md`
-
-Use **exactly** this structure:
-
-```markdown
-# Phase {PHASE_NUM}: {Phase Name} - Context
-
-**Gathered:** {date}
-**Status:** Ready for planning
-
-<domain>
-## Phase Boundary
-
-{Domain boundary statement from analysis}
-
-</domain>
-
-<decisions>
-## Implementation Decisions
-
-### {Area 1 Name}
-- {Accepted/chosen answer for Q1}
-- {Accepted/chosen answer for Q2}
-
-### {Area 2 Name}
-- {Accepted/chosen answer for Q1}
-
-### Claude's Discretion
-{Any "You decide" answers collected}
-
-</decisions>
-
-<code_context>
-## Existing Code Insights
-
-### Reusable Assets
-- {From codebase scout}
-
-### Established Patterns
-- {From codebase scout}
-
-### Integration Points
-- {From codebase scout}
-
-</code_context>
-
-<specifics>
-## Specific Ideas
-
-{Any specific references from discussion}
-{If none: "No specific requirements — open to standard approaches"}
-
-</specifics>
-
-<deferred>
-## Deferred Ideas
-
-{Ideas captured but out of scope}
-{If none: "None — discussion stayed within phase scope"}
-
-</deferred>
-```
-
-Write the file.
-
-**Commit (guarded):**
-
-```bash
-git add "${PHASE_DIR}/${PADDED_PHASE}-CONTEXT.md" 2>/dev/null \
-  && git commit -m "docs(${PADDED_PHASE}): smart discuss context" 2>/dev/null \
-  || echo "ℹ .planning/ gitignored — context written, not committed"
-```
-
-Display confirmation:
-
-```
-Created: {path}
-Decisions captured: {count} across {area_count} areas
-```
-
-</step>