@hanzlaa/rcode 3.4.3 → 3.4.5

package/rihal/workflows/autonomous-smart-discuss.md

@@ -0,0 +1,247 @@
+<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
+PADDED_PHASE=$(printf "%02d" "${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>

package/rihal/workflows/autonomous.md

@@ -170,7 +170,9 @@ if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 STATE=$(node .rihal/bin/rihal-tools.cjs state read 2>/dev/null || echo '{}')
 ```
 
-Parse JSON for: `milestone_version`, `milestone_name`, `phase_count`, `completed_phases`, `roadmap_exists`, `state_exists`, `commit_docs`.
+Parse JSON for: `milestone_version`, `milestone_name`, `phase_count`, `completed_phases`, `roadmap_exists`, `state_exists`, `commit_docs`, `response_language`.
+
+**If `response_language` is set:** include `Respond in {response_language}.` in all spawned subagent prompts.
 
 **If `roadmap_exists` is false:** Error — "No ROADMAP.md found. Run `/rihal-new-milestone` first."
 **If `state_exists` is false:** Error — "No STATE.md found. Run `/rihal-new-milestone` first."
@@ -201,10 +203,10 @@ Parse ROADMAP.md directly (rihal-tools does not expose `roadmap analyze`):
 
 ```bash
 cat .planning/ROADMAP.md
-# For per-phase detail, inspect .planning/phases/<phase_slug>/ directory for PLAN.md, SPRINT.md, SUMMARY.md presence
+# For per-phase detail, inspect .planning/phases/<phase_slug>/ directory for SPRINT.md, SUMMARY.md presence
 ```
 
-Build an internal `phases` array with: `number`, `name`, `goal`, `disk_status` (complete if SUMMARY.md exists, partial if PLAN.md exists without SUMMARY.md, planned if neither), `has_ui_hint`.
+Build an internal `phases` array with: `number`, `name`, `goal`, `disk_status` (complete if SUMMARY.md exists, partial if SPRINT.md exists without SUMMARY.md, planned if neither), `has_ui_hint`.
 
 **Filter to incomplete phases:** Keep only phases where `disk_status !== "complete"`.
 
@@ -343,6 +345,13 @@ All implementation choices are at Claude's discretion — discuss phase was skip
 
 </decisions>
 
+<canonical_refs>
+## Canonical References
+
+No external specs pre-gathered — discuss phase skipped. Planner will extract canonical refs from ROADMAP.md during research.
+
+</canonical_refs>
+
 <code_context>
 ## Existing Code Insights
 
@@ -468,7 +477,7 @@ Auto-invoke code review and fix chain. Autonomous mode chains both review and fi
 
 **Config gate:**
 ```bash
-CODE_REVIEW_ENABLED=$(node .rihal/bin/rihal-tools.cjs config 2>/dev/null | grep -oE '"code_review"[^,}]*' | grep -oE 'true|false' || echo "true")
+CODE_REVIEW_ENABLED=$(node .rihal/bin/rihal-tools.cjs config 2>/dev/null | grep -oE '"code_review"[^,}]*' | grep -oE 'true|false' || echo "false")
 ```
 If `"false"`: display "Code review skipped (workflow.code_review=false)" and proceed to 3d.
 
@@ -501,7 +510,7 @@ Go to handle_blocker: "Execute phase ${PHASE_NUM} did not produce verification r
 
 Display:
 ```
-Phase ${PHASE_NUM} ✅ ${PHASE_NAME} — Verification passed
+Phase ${PHASE_NUM} ✓ ${PHASE_NAME} — Verification passed
 ```
 
 Proceed to iterate step.
@@ -518,7 +527,7 @@ On **"Validate now"**: Present the specific items from VERIFICATION.md. After us
 - **question:** "Validation result?"
 - **options:** "All good — continue" / "Found issues"
 
-On "All good — continue": Display `Phase ${PHASE_NUM} ✅ Human validation passed` and proceed to iterate step.
+On "All good — continue": Display `Phase ${PHASE_NUM} ✓ Human validation passed` and proceed to iterate step.
 
 On "Found issues": Go to handle_blocker with the user's reported issues as the description.
 
@@ -532,11 +541,14 @@ Read gap summary from VERIFICATION.md (score and missing items). Display:
 Score: {N}/{M} must-haves verified
 ```
 
-Ask user via AskUserQuestion:
+**If `INTERACTIVE` is set:** Ask via AskUserQuestion:
 - **question:** "Gaps found in phase ${PHASE_NUM}. How to proceed?"
 - **options:** "Run gap closure" / "Continue without fixing" / "Stop autonomous mode"
+- On "Stop": go to handle_blocker
+
+**If `INTERACTIVE` is NOT set (default autonomous):** Auto-select "Run gap closure" — display `⚙ Phase ${PHASE_NUM}: auto-running gap closure` and proceed.
 
-On **"Run gap closure"**: Execute gap closure cycle (limit: 1 attempt):
+Execute gap closure cycle (limit: 1 attempt):
 
 ```
 Skill(skill="rihal-plan", args="${PHASE_NUM} --gaps")
@@ -549,15 +561,12 @@ Re-execute:
 Skill(skill="rihal-execute", args="${PHASE_NUM} --no-transition")
 ```
 
-Re-read verification status. If `passed` or `human_needed`: route normally. If still `gaps_found` after this retry: ask via AskUserQuestion:
-- **options:** "Continue anyway" / "Stop autonomous mode"
+Re-read verification status. If `passed` or `human_needed`: route normally. If still `gaps_found` after this retry:
+- **If `INTERACTIVE`:** ask "Continue anyway / Stop autonomous mode"
+- **Otherwise:** display `⏭ Phase ${PHASE_NUM}: gaps persist after closure — continuing` and proceed to iterate step.
 
 This limits gap closure to 1 automatic retry to prevent infinite loops.
 
-On **"Continue without fixing"**: Display `Phase ${PHASE_NUM} ⏭ Gaps deferred` and proceed to iterate step.
-
-On **"Stop autonomous mode"**: Go to handle_blocker with "User stopped — gaps remain in phase ${PHASE_NUM}".
-
 ### 3d.5. UI Review (Frontend Phases)
 
 > Run after any successful execution routing (passed, human_needed accepted, or gaps deferred/accepted) — before proceeding to the iterate step.
@@ -585,249 +594,8 @@ Display the review result summary (score from UI-REVIEW.md if produced). Continu
 
 </step>
 
-<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` from execute_phase. Resolve phase paths:
-
-```bash
-PHASE_NUM="${PHASE_NUM}"
-PADDED_PHASE=$(printf "%02d" "${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 all prior CONTEXT.md files:**
-
-```bash
-(find .planning/phases -name "*-CONTEXT.md" -o -name "CONTEXT.md" 2>/dev/null || true) | sort
-```
-
-For each CONTEXT.md where phase number < current phase:
-- 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`
+@rihal/workflows/autonomous-smart-discuss.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>
 
 <step name="iterate">
 
@@ -900,6 +668,25 @@ Check for blockers in the Blockers/Concerns section. If blockers are found, go t
 
 If incomplete phases remain: proceed to next phase, loop back to execute_phase.
 
+**Token cost report and /clear offer (closes #586):**
+
+After each phase completes, display a cost summary:
+
+```
+Phase {N} ✓ {name} — {sprint_count} sprints, {revision_count} revision(s)
+```
+
+Track `PHASES_COMPLETED` (increment after each iterate). Every 3 completed phases:
+
+```
+⚠ Context growing — {PHASES_COMPLETED} phases done in this session.
+  Tip: /clear now and resume to keep remaining phases lean:
+  /rihal-autonomous --from {next_phase} --to {TO_PHASE}
+  Continue anyway? [Yes, keep going] / [I'll clear now — show resume command]
+```
+
+In `mode: yolo`: skip the offer and just print the resume command as an info line.
+
 **Interactive mode overlap:** When `INTERACTIVE` is set, the iterate step enables pipeline parallelism:
 1. After discuss completes for Phase N, dispatch plan+execute as background agents
 2. Immediately start discuss for Phase N+1 while Phase N builds
@@ -963,7 +750,7 @@ AUDIT_STATUS=$(grep "^status:" "${AUDIT_FILE}" 2>/dev/null | head -1 | cut -d: -
 **If `passed`:**
 
 ```
-Audit ✅ passed — proceeding to complete milestone
+Audit ✓ passed — proceeding to complete milestone
 ```
 
 Proceed to 5b.
@@ -975,22 +762,22 @@ Read the gaps summary from the audit file. Display:
 ⚠ Audit: Gaps Found
 ```
 
-Ask user via AskUserQuestion:
+**If `INTERACTIVE`:** Ask via AskUserQuestion:
 - **question:** "Milestone audit found gaps. How to proceed?"
 - **options:** "Continue anyway — accept gaps" / "Stop — fix gaps manually"
+- On "Stop": Go to handle_blocker.
 
-On **"Continue anyway"**: Display `Audit ⏭ Gaps accepted` and proceed to 5b.
-
-On **"Stop"**: Go to handle_blocker.
+**Otherwise (autonomous):** Display `Audit ⏭ Gaps accepted — continuing` and proceed to 5b.
 
 **If `tech_debt`:**
 
-Show the summary, then ask user via AskUserQuestion:
-- **options:** "Continue with tech debt" / "Stop — address debt first"
+Show the summary, then:
 
-On **"Continue with tech debt"**: Proceed to 5b.
+**If `INTERACTIVE`:** Ask via AskUserQuestion:
+- **options:** "Continue with tech debt" / "Stop — address debt first"
+- On "Stop": Go to handle_blocker.
 
-On **"Stop"**: Go to handle_blocker.
+**Otherwise (autonomous):** Display `Tech debt noted — continuing` and proceed to 5b.
 
 ### 5b. Complete Milestone
 
@@ -1022,8 +809,8 @@ Cleanup shows its own dry-run and asks user for approval internally — this is
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
  Milestone: {milestone_version} — {milestone_name}
- Status: Complete ✅
- Lifecycle: audit ✅ → complete ✅ → cleanup ✅
+ Status: Complete ✓
+ Lifecycle: audit ✓ → complete ✓ → cleanup ✓
 
  Ship it! 🚀
 ```