@pareto4/pp-core 1.11.0 → 1.12.0

package/pp-core/workflows/autonomous.md

@@ -1,6 +1,6 @@
 <purpose>
 
-Drive milestone phases autonomously — all remaining phases, a range via `--from N`/`--to N`, or a single phase via `--only N`. For each incomplete phase: discuss → plan → execute using Skill() flat invocations. When `--converge` or `--cross-ai` is set, route the planning step through plan-review convergence before execution. Pauses only for explicit user decisions (grey area acceptance, blockers, validation requests). Re-reads ROADMAP.md after each phase to catch dynamically inserted phases.
+Drive one phase autonomously — by default the next incomplete phase; a range via `--from N`/`--to N`; a named phase via `--only N`. For each incomplete phase: discuss → plan → execute using Skill() flat invocations. When `--converge` or `--cross-ai` is set, route the planning step through plan-review convergence before execution. Best-effort by default: at every decision point it takes the recommended option, appends it to `{padded}-AUTONOMOUS-REPORT.md` and continues; `--supervised` restores the prompts. Hard stops (blocking gates, human-action checkpoints, anything outward) remain — `pp-core/references/autonomous-best-effort.md`. Re-reads ROADMAP.md after each phase to catch dynamically inserted phases.
 
 </purpose>
 
@@ -16,7 +16,7 @@ Read all files referenced by the invoking prompt's execution_context before star
 
 ## 1. Initialize
 
-Parse `$ARGUMENTS` for `--from N`, `--to N`, `--only N`, `--interactive`, `--converge`/`--cross-ai`, reviewer selector flags, and `--max-cycles N`:
+Parse `$ARGUMENTS` for `--from N`, `--to N`, `--only N`, `--interactive`, `--supervised`, `--converge`/`--cross-ai`, reviewer selector flags, and `--max-cycles N`:
 
 ```bash
 FROM_PHASE=""
@@ -40,6 +40,11 @@ if echo "$ARGUMENTS" | grep -q '\-\-interactive'; then
   INTERACTIVE="true"
 fi
 
+SUPERVISED=""
+if echo "$ARGUMENTS" | grep -q '\-\-supervised'; then SUPERVISED="true"; fi
+UNATTENDED_ARG=""
+if [ -z "$SUPERVISED" ]; then UNATTENDED_ARG=" --unattended"; fi
+
 PLAN_STRATEGY="local"
 if echo "$ARGUMENTS" | grep -qE '(^|[[:space:]])\-\-(converge|cross-ai)([[:space:]]|$)'; then
   PLAN_STRATEGY="converge"
@@ -59,16 +64,16 @@ if echo "$ARGUMENTS" | grep -qE '\-\-max-cycles\s+[0-9]+'; then
 fi
 ```
 
-When `--only` is set, also set `FROM_PHASE` to the same value so existing filter logic applies.
-
 When `--interactive` is set, discuss runs inline with questions (not auto-answered). On runtimes where a backgrounded agent can spawn subagents, plan and execute are dispatched as background agents — keeping the main context lean (only discuss conversations accumulate) and enabling overlap. On Claude Code, where a backgrounded agent cannot nest subagents, plan and execute run inline to preserve worktree isolation and independent verification, so they run sequentially and their work accumulates in the main context. Either way, user input is preserved on all design decisions.
 
 When `PLAN_STRATEGY=converge`, the planning step MUST invoke the plan-review convergence workflow instead of `pp-plan-phase`. `--cross-ai` is an alias for `--converge`. Forward `CONVERGENCE_ARGS` exactly as parsed so reviewer flags and `--max-cycles N` retain the same meaning as they have on `/pp:plan-review-convergence`.
 
+With `--supervised` every prompt appears as before; otherwise each decision is best-effort and recorded (reference § Rules). `--interactive` only moves discuss inline.
+
 Bootstrap via milestone-level init:
 
 ```bash
-_PP_SHIM_NAME="pp-tools.cjs"; _PP_RUNTIME_ROOT="${RUNTIME_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"; PP_TOOLS="${_PP_RUNTIME_ROOT}/pp-core/bin/${_PP_SHIM_NAME}"; if [ -f "$PP_TOOLS" ]; then pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${_PP_RUNTIME_ROOT}/.claude/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${_PP_RUNTIME_ROOT}/.claude/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${_PP_RUNTIME_ROOT}/.codex/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${_PP_RUNTIME_ROOT}/.codex/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif command -v pp-tools >/dev/null 2>&1; then PP_TOOLS="$(command -v pp-tools)"; pp_run() { "$PP_TOOLS" "$@"; }; elif [ -f "$HOME/.claude/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="$HOME/.claude/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${HERMES_HOME:-$HOME/.hermes}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${HERMES_HOME:-$HOME/.hermes}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${CURSOR_CONFIG_DIR:-$HOME/.cursor}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${CURSOR_CONFIG_DIR:-$HOME/.cursor}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${CODEX_HOME:-$HOME/.codex}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${CODEX_HOME:-$HOME/.codex}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${GEMINI_CONFIG_DIR:-$HOME/.gemini}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${GEMINI_CONFIG_DIR:-$HOME/.gemini}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${COPILOT_CONFIG_DIR:-$HOME/.copilot}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${COPILOT_CONFIG_DIR:-$HOME/.copilot}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${WINDSURF_CONFIG_DIR:-$HOME/.codeium/windsurf}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${WINDSURF_CONFIG_DIR:-$HOME/.codeium/windsurf}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${AUGMENT_CONFIG_DIR:-$HOME/.augment}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${AUGMENT_CONFIG_DIR:-$HOME/.augment}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${TRAE_CONFIG_DIR:-$HOME/.trae}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${TRAE_CONFIG_DIR:-$HOME/.trae}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${QWEN_CONFIG_DIR:-$HOME/.qwen}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${QWEN_CONFIG_DIR:-$HOME/.qwen}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${CODEBUDDY_CONFIG_DIR:-$HOME/.codebuddy}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${CODEBUDDY_CONFIG_DIR:-$HOME/.codebuddy}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${CLINE_CONFIG_DIR:-$HOME/.cline}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${CLINE_CONFIG_DIR:-$HOME/.cline}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${GROK_AGENTS_HOME:-$HOME/.agents}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${GROK_AGENTS_HOME:-$HOME/.agents}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${ANTIGRAVITY_CONFIG_DIR:-$HOME/.gemini/antigravity}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${ANTIGRAVITY_CONFIG_DIR:-$HOME/.gemini/antigravity}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${OPENCODE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/opencode}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${OPENCODE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/opencode}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; elif [ -f "${KILO_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/kilo}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${KILO_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/kilo}/pp-core/bin/${_PP_SHIM_NAME}"; pp_run() { node "$PP_TOOLS" "$@"; }; else echo "ERROR: pp-tools.cjs not found at $PP_TOOLS and pp-tools is not on PATH. Run: npx -y @pareto4/pp-core@latest --claude --local" >&2; exit 1; fi; if [ -n "${CLAUDE_ENV_FILE:-}" ] && [ -n "${PP_TOOLS:-}" ]; then printf "export PATH='%s':\"\$PATH\"\n" "${PP_TOOLS%/*}" >> "$CLAUDE_ENV_FILE" 2>/dev/null || true; fi
+_PP_SHIM_NAME="pp-tools.cjs"; _pp_root() { ( for _v in $(env | sed -n 's/^\(GIT_[A-Za-z0-9_]*\)=.*/\1/p'); do unset "$_v"; done; _c=$(git rev-parse --git-common-dir 2>/dev/null); if [ "${_c##*/}" = .git ] && cd "$_c/.." 2>/dev/null; then pwd -P; else git rev-parse --show-toplevel 2>/dev/null || pwd; fi ); }; pp_run() { case "$PP_TOOLS" in *.cjs) node "$PP_TOOLS" "$@";; *) "$PP_TOOLS" "$@";; esac; }; _PP_RUNTIME_ROOT="${RUNTIME_DIR:-$(_pp_root)}"; PP_TOOLS="${_PP_RUNTIME_ROOT}/pp-core/bin/${_PP_SHIM_NAME}"; if [ -f "$PP_TOOLS" ]; then :; elif [ -f "${_PP_RUNTIME_ROOT}/.claude/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${_PP_RUNTIME_ROOT}/.claude/pp-core/bin/${_PP_SHIM_NAME}"; elif [ -f "${_PP_RUNTIME_ROOT}/.codex/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${_PP_RUNTIME_ROOT}/.codex/pp-core/bin/${_PP_SHIM_NAME}"; elif [ -f "$HOME/.claude/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="$HOME/.claude/pp-core/bin/${_PP_SHIM_NAME}"; elif [ -f "${HERMES_HOME:-$HOME/.hermes}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${HERMES_HOME:-$HOME/.hermes}/pp-core/bin/${_PP_SHIM_NAME}"; elif [ -f "${CURSOR_CONFIG_DIR:-$HOME/.cursor}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${CURSOR_CONFIG_DIR:-$HOME/.cursor}/pp-core/bin/${_PP_SHIM_NAME}"; elif [ -f "${CODEX_HOME:-$HOME/.codex}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${CODEX_HOME:-$HOME/.codex}/pp-core/bin/${_PP_SHIM_NAME}"; elif [ -f "${GEMINI_CONFIG_DIR:-$HOME/.gemini}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${GEMINI_CONFIG_DIR:-$HOME/.gemini}/pp-core/bin/${_PP_SHIM_NAME}"; elif [ -f "${COPILOT_CONFIG_DIR:-$HOME/.copilot}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${COPILOT_CONFIG_DIR:-$HOME/.copilot}/pp-core/bin/${_PP_SHIM_NAME}"; elif [ -f "${WINDSURF_CONFIG_DIR:-$HOME/.codeium/windsurf}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${WINDSURF_CONFIG_DIR:-$HOME/.codeium/windsurf}/pp-core/bin/${_PP_SHIM_NAME}"; elif [ -f "${AUGMENT_CONFIG_DIR:-$HOME/.augment}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${AUGMENT_CONFIG_DIR:-$HOME/.augment}/pp-core/bin/${_PP_SHIM_NAME}"; elif [ -f "${TRAE_CONFIG_DIR:-$HOME/.trae}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${TRAE_CONFIG_DIR:-$HOME/.trae}/pp-core/bin/${_PP_SHIM_NAME}"; elif [ -f "${QWEN_CONFIG_DIR:-$HOME/.qwen}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${QWEN_CONFIG_DIR:-$HOME/.qwen}/pp-core/bin/${_PP_SHIM_NAME}"; elif [ -f "${CODEBUDDY_CONFIG_DIR:-$HOME/.codebuddy}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${CODEBUDDY_CONFIG_DIR:-$HOME/.codebuddy}/pp-core/bin/${_PP_SHIM_NAME}"; elif [ -f "${CLINE_CONFIG_DIR:-$HOME/.cline}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${CLINE_CONFIG_DIR:-$HOME/.cline}/pp-core/bin/${_PP_SHIM_NAME}"; elif [ -f "${GROK_AGENTS_HOME:-$HOME/.agents}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${GROK_AGENTS_HOME:-$HOME/.agents}/pp-core/bin/${_PP_SHIM_NAME}"; elif [ -f "${ANTIGRAVITY_CONFIG_DIR:-$HOME/.gemini/antigravity}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${ANTIGRAVITY_CONFIG_DIR:-$HOME/.gemini/antigravity}/pp-core/bin/${_PP_SHIM_NAME}"; elif [ -f "${OPENCODE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/opencode}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${OPENCODE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/opencode}/pp-core/bin/${_PP_SHIM_NAME}"; elif [ -f "${KILO_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/kilo}/pp-core/bin/${_PP_SHIM_NAME}" ]; then PP_TOOLS="${KILO_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/kilo}/pp-core/bin/${_PP_SHIM_NAME}"; elif command -v pp-tools >/dev/null 2>&1; then PP_TOOLS="$(command -v pp-tools)"; else echo "ERROR: pp-tools.cjs not found at $PP_TOOLS and pp-tools is not on PATH. Run: npx -y @pareto4/pp-core@latest --claude --local" >&2; exit 1; fi; if [ -n "${CLAUDE_ENV_FILE:-}" ] && [ -n "${PP_TOOLS:-}" ]; then printf "export PATH='%s':\"\$PATH\"\n" "${PP_TOOLS%/*}" >> "$CLAUDE_ENV_FILE" 2>/dev/null || true; fi
 INIT=$(pp_run query init.milestone-op)
 if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 ```
@@ -111,7 +116,9 @@ Display startup banner:
 If `ONLY_PHASE` is set, display: `Single phase mode: Phase ${ONLY_PHASE}`
 Else if `FROM_PHASE` is set, display: `Starting from phase ${FROM_PHASE}`
 If `TO_PHASE` is set, display: `Stopping after phase ${TO_PHASE}`
+Else (none of the three): display `Mode: next incomplete phase only (default) — pass --from/--to for a range`
 If `INTERACTIVE` is set, display: `Mode: Interactive (discuss inline, plan+execute in background)`
+If `SUPERVISED` is set, display `Mode: Supervised (prompts restored)`; else `Decisions: best-effort — recorded per phase in {padded}-AUTONOMOUS-REPORT.md`
 If `PLAN_STRATEGY` is `converge`, display: `Planning: Plan-review convergence enabled`
 
 </step>
@@ -166,18 +173,18 @@ Exit cleanly.
 
 Exit cleanly.
 
-**Display phase plan:**
+**Default — single phase:** If `FROM_PHASE`, `TO_PHASE` and `ONLY_PHASE` are all empty, set `ONLY_PHASE` to the `number` of the first remaining phase and keep only that phase — from here on this is the `--only N` path. Then apply rule A-5 (waiting on the operator) from the reference:
 
+```bash
+PD=$(pp_run query init.phase-op "$ONLY_PHASE" --pick phase_dir)
+[ -n "$PD" ] && WAIT=$(pp_run query verification.status "$PD" --pick status 2>/dev/null)
 ```
-## Phase Plan
 
-| # | Phase | Status |
-|---|-------|--------|
-| 5 | Skill Scaffolding & Phase Discovery | In Progress |
-| 6 | Smart Discuss | Not Started |
-| 7 | Auto-Chain Refinements | Not Started |
-| 8 | Lifecycle Orchestration | Not Started |
-```
+If `WAIT` is `human_needed` or `gaps_found`: print `Phase ${ONLY_PHASE} is waiting on you — verification status: ${WAIT}.`, `  Finish it with: /pp:verify-work ${ONLY_PHASE}` and, when a later incomplete phase `NEXT` exists, `  Or run the next phase instead: /pp:autonomous --only ${NEXT}`; exit 0.
+
+Set `FIRST_PHASE` to the first remaining phase's number, derive `RUN_STATE` per reference § Run state and write it with `run-state-write`.
+
+**Display phase plan:** a `## Phase Plan` table with columns `# | Phase | Status` (In Progress / Not Started), one row per selected phase.
 
 **Fetch details for each phase:**
 
@@ -193,6 +200,8 @@ Extract `phase_name`, `goal`, `success_criteria` from each. Store for use in exe
 
 ## 3. Execute Phase
 
+**Before anything else for this phase:** Read `pp-core/references/autonomous-best-effort.md` (again — every phase), then set `REPORT` per its § Recording.
+
 For the current phase, display the progress banner:
 
 ```
@@ -201,9 +210,7 @@ For the current phase, display the progress banner:
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ```
 
-Where N = current phase number (from the ROADMAP, e.g., 63), T = total milestone phases (from `phase_count` parsed in initialize step, e.g., 67). **Important:** T must be `phase_count` (the total number of phases in this milestone), NOT the count of remaining/incomplete phases. When phases are numbered 61-67, T=7 and the banner should read `Phase 63/7` (phase 63, 7 total in milestone), not `Phase 63/3` (which would confuse 3 remaining with 3 total). P = percentage of all milestone phases completed so far. Calculate P as: (number of phases with `disk_status` "complete" from the latest `roadmap analyze` / T × 100). Use █ for filled and ░ for empty segments in the progress bar (8 characters wide).
-
-**Alternative display when phase numbers exceed total** (e.g., multi-milestone projects where phases are numbered globally): If N > T (phase number exceeds milestone phase count), use the format `Phase {N} ({position}/{T})` where `position` is the 1-based index of this phase among incomplete phases being processed. This prevents confusing displays like "Phase 63/5".
+Banner math (N, T, P and the N > T fallback): reference § Banner math.
 
 **3a. Smart Discuss**
 
@@ -235,63 +242,7 @@ SKIP_DISCUSS=$(pp_run query config-get workflow.skip_discuss 2>/dev/null || echo
 Phase ${PHASE_NUM}: Discuss skipped (workflow.skip_discuss=true) — using ROADMAP phase goal as spec.
 ```
 
-Write a minimal CONTEXT.md so downstream plan-phase has valid input. Get phase details:
-
-```bash
-DETAIL=$(pp_run query roadmap.get-phase ${PHASE_NUM})
-```
-
-Extract `goal` and `requirements` from JSON. Write `${phase_dir}/${padded_phase}-CONTEXT.md` with:
-
-```markdown
-# Phase {PHASE_NUM}: {Phase Name} - Context
-
-**Gathered:** {date}
-**Status:** Ready for planning
-**Mode:** Auto-generated (discuss skipped via workflow.skip_discuss)
-
-<domain>
-## Phase Boundary
-
-{goal from ROADMAP phase description}
-
-</domain>
-
-<decisions>
-## Implementation Decisions
-
-### Claude's Discretion
-All implementation choices are at Claude's discretion — discuss phase was skipped per user setting. Use ROADMAP phase goal, success criteria, and codebase conventions to guide decisions.
-
-</decisions>
-
-<code_context>
-## Existing Code Insights
-
-Codebase context will be gathered during plan-phase research.
-
-</code_context>
-
-<specifics>
-## Specific Ideas
-
-No specific requirements — discuss phase skipped. Refer to ROADMAP phase description and success criteria.
-
-</specifics>
-
-<deferred>
-## Deferred Ideas
-
-None — discuss phase skipped.
-
-</deferred>
-```
-
-Commit the minimal context:
-
-```bash
-pp_run query commit "docs(${PADDED_PHASE}): auto-generated context (discuss skipped)" --files "${phase_dir}/${padded_phase}-CONTEXT.md"
-```
+Write and commit the minimal CONTEXT.md in reference § Minimal CONTEXT.md (skip_discuss).
 
 Proceed to 3b.
 
@@ -322,7 +273,7 @@ Resolve active `plan:pre` hooks:
 
 ```bash
 UI_SPEC_FILE=$(ls "${PHASE_DIR}"/*-UI-SPEC.md 2>/dev/null | head -1)
-HOOKS_JSON=$(pp_run loop render-hooks plan:pre --raw)
+HOOKS_JSON=$(pp_run loop render-hooks plan:pre --raw --phase "${PHASE_NUM}")
 ```
 
 Read the `activeHooks` array directly from `HOOKS_JSON` (in-context — do NOT invoke a shell pipeline). **Compute the active UI step hooks** = entries from `activeHooks` where `kind == "step"` and `ref.skill` is set. **If there are NO active step hooks → skip silently to 3b.** (This covers `workflow.ui_phase=false` — including configurations where only a gate-only entry is present, e.g. `ui_phase=false` + `ui_safety_gate=true` produces `activeHooks=[{kind:"gate"}]`. Autonomous never runs the plan:pre gate — it is always pipeline mode — so a gate-only active set is equivalent to no active step and is silently skipped here. This matches OLD §3a.5 behaviour.)
@@ -360,7 +311,7 @@ UI_SPEC_FILE=$(ls "${PHASE_DIR}"/*-UI-SPEC.md 2>/dev/null | head -1)
 **If `INTERACTIVE` is set:** Background dispatch is only safe where a backgrounded agent can still spawn subagents. On Claude Code a backgrounded agent has no `Agent`/`Task` tool, so the plan-checker never runs and `workflow.plan_check` silently degrades to a self-check. Resolve the runtime first:
 
 ```bash
-RUNTIME=$(pp_run query config-get runtime --default claude 2>/dev/null || echo "claude")
+RUNTIME=$(pp_run query config-get runtime --default claude --raw 2>/dev/null || echo "claude")
 ```
 
 - **On Claude Code (`RUNTIME` is `claude`):** Run plan **inline** (do NOT background) so the plan-checker runs. The next phase's discuss does not overlap planning here — correctness over overlap.
@@ -374,7 +325,7 @@ RUNTIME=$(pp_run query config-get runtime --default claude 2>/dev/null || echo "
   - Otherwise (local planning):
 
   ```
-  Skill(skill="pp-plan-phase", args="${PHASE_NUM}")
+  Skill(skill="pp-plan-phase", args="${PHASE_NUM}${UNATTENDED_ARG}")
   ```
 
 - **On other runtimes:** Dispatch plan as a background agent to keep the main context lean. While plan runs, the workflow can immediately start discussing the next phase (see step 4).
@@ -395,7 +346,7 @@ RUNTIME=$(pp_run query config-get runtime --default claude 2>/dev/null || echo "
   Agent(
     description="Plan phase ${PHASE_NUM}: ${PHASE_NAME}",
     run_in_background=true,
-    prompt="Run plan-phase for phase ${PHASE_NUM}: Skill(skill=\"pp-plan-phase\", args=\"${PHASE_NUM}\")"
+    prompt="Run plan-phase for phase ${PHASE_NUM}: Skill(skill=\"pp-plan-phase\", args=\"${PHASE_NUM}${UNATTENDED_ARG}\")"
   )
   ```
 
@@ -412,7 +363,7 @@ Skill(skill="pp-plan-review-convergence", args="${PHASE_NUM} ${CONVERGENCE_ARGS}
 If `PLAN_STRATEGY=local`, run the regular planner:
 
 ```
-Skill(skill="pp-plan-phase", args="${PHASE_NUM}")
+Skill(skill="pp-plan-phase", args="${PHASE_NUM}${UNATTENDED_ARG}")
 ```
 
 Verify plan produced output — re-run `init phase-op` and check `has_plans`. If false → go to handle_blocker: "Plan phase ${PHASE_NUM} did not produce any plans."
@@ -422,13 +373,13 @@ Verify plan produced output — re-run `init phase-op` and check `has_plans`. If
 **If `INTERACTIVE` is set:** Wait for the plan agent to complete (if not already) and verify plans exist. Background dispatch is only safe where a backgrounded agent can still spawn subagents. On Claude Code a backgrounded agent has no `Agent`/`Task` tool, so the per-plan worktree-isolated executors and the verifier never run (`workflow.use_worktrees` and `workflow.verifier` silently degrade). Resolve the runtime first:
 
 ```bash
-RUNTIME=$(pp_run query config-get runtime --default claude 2>/dev/null || echo "claude")
+RUNTIME=$(pp_run query config-get runtime --default claude --raw 2>/dev/null || echo "claude")
 ```
 
 - **On Claude Code (`RUNTIME` is `claude`):** Run execute **inline** (do NOT background) so worktree isolation and verification run:
 
 ```
-Skill(skill="pp-execute-phase", args="${PHASE_NUM} --no-transition")
+Skill(skill="pp-execute-phase", args="${PHASE_NUM} --no-transition${UNATTENDED_ARG}")
 ```
 
 - **On other runtimes:** Dispatch execute as a background agent:
@@ -437,7 +388,7 @@ Skill(skill="pp-execute-phase", args="${PHASE_NUM} --no-transition")
 Agent(
   description="Execute phase ${PHASE_NUM}: ${PHASE_NAME}",
   run_in_background=true,
-  prompt="Run execute-phase for phase ${PHASE_NUM}: Skill(skill=\"pp-execute-phase\", args=\"${PHASE_NUM} --no-transition\")"
+  prompt="Run execute-phase for phase ${PHASE_NUM}: Skill(skill=\"pp-execute-phase\", args=\"${PHASE_NUM} --no-transition${UNATTENDED_ARG}\")"
 )
 ```
 
@@ -446,7 +397,7 @@ Agent(
 **If `INTERACTIVE` is NOT set (default):** Run execute inline as before.
 
 ```
-Skill(skill="pp-execute-phase", args="${PHASE_NUM} --no-transition")
+Skill(skill="pp-execute-phase", args="${PHASE_NUM} --no-transition${UNATTENDED_ARG}")
 ```
 
 **3c.5. Code Review and Fix**
@@ -455,7 +406,7 @@ Auto-invoke code review and fix chain. Autonomous mode chains both review and fi
 
 **Capability dispatch:**
 ```bash
-EXECUTE_POST_HOOKS_JSON=$(pp_run loop render-hooks execute:post --raw)
+EXECUTE_POST_HOOKS_JSON=$(pp_run loop render-hooks execute:post --raw --phase "${PHASE_NUM}")
 ```
 
 Resolve active step hooks from `EXECUTE_POST_HOOKS_JSON` where `kind == "step"` and `ref.skill == "code-review"`.
@@ -482,18 +433,12 @@ Skill(skill="pp-code-review", args="${PHASE_NUM} --fix --auto")
 After execute-phase returns (or the execute agent completes), read the verification result:
 
 ```bash
-VERIFY_STATUS=$(grep "^status:" "${PHASE_DIR}"/*-VERIFICATION.md 2>/dev/null | head -1 | cut -d: -f2 | tr -d ' ')
+VERIFY_STATUS=$(pp_run query verification.status "${PHASE_DIR}" --pick status 2>/dev/null)
 ```
 
-Where `PHASE_DIR` comes from the `init phase-op` call already made in step 3a. If the variable is not in scope, re-fetch:
+`PHASE_DIR` is `phase_dir` from step 3a's `init phase-op` (re-run it if out of scope).
 
-```bash
-PHASE_STATE=$(pp_run query init.phase-op ${PHASE_NUM})
-```
-
-Parse `phase_dir` from the JSON.
-
-**If VERIFY_STATUS is empty** (no VERIFICATION.md or no status field):
+**If VERIFY_STATUS is empty, `missing` or `unknown`** (no VERIFICATION.md or no status field):
 
 Go to handle_blocker: "Execute phase ${PHASE_NUM} did not produce verification results."
 
@@ -504,72 +449,29 @@ Display:
 Phase ${PHASE_NUM} ✅ ${PHASE_NAME} — Verification passed
 ```
 
-Proceed to iterate step.
-
-**If `human_needed`:**
-
-Read the human_verification section from VERIFICATION.md to get the count and items requiring manual testing.
-
-
-**Text mode (`workflow.text_mode: true` in config or `--text` flag):** 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 non-Claude runtimes (OpenAI Codex, Gemini CLI, etc.) where `AskUserQuestion` is not available.
-Display the items, then ask user via AskUserQuestion:
-- **question:** "Phase ${PHASE_NUM} has items needing manual verification. Validate now or continue to next phase?"
-- **options:** "Validate now" / "Continue without validation"
+`OUTCOME=passed`; go to **3d exit**.
 
-On **"Validate now"**: Present the specific items from VERIFICATION.md's human_verification section. After user reviews, ask:
-- **question:** "Validation result?"
-- **options:** "All good — continue" / "Found issues"
+**If `human_needed`:** rule A-2 — display the items, record, print the deferred line, `OUTCOME=human_needed`, go to **3d exit**; never flip to passed. `--supervised`: reference § Supervised menus.
 
-On "All good — continue": Display `Phase ${PHASE_NUM} ✅ Human validation passed` and proceed to iterate step.
+**If `gaps_found`:** rule A-3 — one closure attempt:
 
-On "Found issues": Go to handle_blocker with the user's reported issues as the description.
-
-On **"Continue without validation"**: Display `Phase ${PHASE_NUM} ⏭ Human validation deferred` and proceed to iterate step.
-
-**If `gaps_found`:**
-
-Read gap summary from VERIFICATION.md (score and missing items). Display:
 ```
-⚠ Phase ${PHASE_NUM}: ${PHASE_NAME} — Gaps Found
-Score: {N}/{M} must-haves verified
-```
-
-Ask user via AskUserQuestion:
-- **question:** "Gaps found in phase ${PHASE_NUM}. How to proceed?"
-- **options:** "Run gap closure" / "Continue without fixing" / "Stop autonomous mode"
-
-On **"Run gap closure"**: Execute gap closure cycle (limit: 1 attempt):
-
-```
-Skill(skill="pp-plan-phase", args="${PHASE_NUM} --gaps")
+Skill(skill="pp-plan-phase", args="${PHASE_NUM} --gaps${UNATTENDED_ARG}")
 ```
 
 Verify gap plans were created — re-run `init phase-op ${PHASE_NUM}` and check `has_plans`. If no new gap plans → go to handle_blocker: "Gap closure planning for phase ${PHASE_NUM} did not produce plans."
 
-Re-execute:
 ```
-Skill(skill="pp-execute-phase", args="${PHASE_NUM} --no-transition")
+Skill(skill="pp-execute-phase", args="${PHASE_NUM} --no-transition${UNATTENDED_ARG}")
 ```
 
-Re-read verification status:
 ```bash
-VERIFY_STATUS=$(grep "^status:" "${PHASE_DIR}"/*-VERIFICATION.md 2>/dev/null | head -1 | cut -d: -f2 | tr -d ' ')
+VERIFY_STATUS=$(pp_run query verification.status "${PHASE_DIR}" --pick status 2>/dev/null)
 ```
 
-If `passed` or `human_needed`: Route normally (continue or ask user as above).
-
-If still `gaps_found` after this retry: Display "Gaps persist after closure attempt." and ask via AskUserQuestion:
-- **question:** "Gap closure did not fully resolve issues. How to proceed?"
-- **options:** "Continue anyway" / "Stop autonomous mode"
+Route the new status through A-3 (passed → `OUTCOME=passed`; human_needed → A-2; still gaps_found → record, print the deferred line, `OUTCOME=gaps_found`), then go to **3d exit**. `--supervised`: reference § Supervised menus.
 
-On "Continue anyway": Proceed to iterate step.
-On "Stop autonomous mode": Go to handle_blocker.
-
-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 exit — every branch of 3d ends here, including an A-4 stop:** run the reference's `phase-exit` snippet (appends `handled=${PHASE_NUM}:${OUTCOME}` once, commits `$REPORT` if it exists), then continue to 3d.5 (A-4 stop: print its banner and exit).
 
 **3d.5. UI Review (Frontend Phases)**
 
@@ -579,7 +481,7 @@ Resolve the active post-verification hooks and the UI-SPEC gate:
 
 ```bash
 UI_SPEC_FILE=$(ls "${PHASE_DIR}"/*-UI-SPEC.md 2>/dev/null | head -1)
-HOOKS_JSON=$(pp_run loop render-hooks verify:post --raw)
+HOOKS_JSON=$(pp_run loop render-hooks verify:post --raw --phase "${PHASE_NUM}")
 ```
 
 Read the `activeHooks` array directly from the `HOOKS_JSON` value already in context (do not invoke a shell `jq` pipeline — parse as the JSON object it is). **If `activeHooks` is empty or absent:** skip silently to the iterate step.
@@ -605,7 +507,7 @@ Display the review result summary and score from UI-REVIEW.md if produced. Conti
 
 > Full instructions are in `pp-core/references/autonomous-smart-discuss.md`. Read that file now and follow it exactly.
 
-Smart discuss is an autonomous-optimized variant of `pp-discuss-phase`. It proposes grey area answers in batch tables — the user accepts or overrides per area — and writes an identical CONTEXT.md to what discuss-phase produces.
+Smart discuss is an autonomous-optimized variant of `pp-discuss-phase`. It proposes grey area answers in batch tables — best-effort accepts the recommended answers and records them (rule A-1); `--supervised` restores the per-area prompts — and writes an identical CONTEXT.md to what discuss-phase produces.
 
 **Inputs:** `PHASE_NUM` from execute_phase.
 
@@ -628,11 +530,12 @@ Read and execute: `$HOME/.claude/pp-core/references/autonomous-smart-discuss.md`
 
  Completed through phase ${TO_PHASE} as requested.
  Remaining phases were not executed.
+ Deferred (not complete): ${DEFERRED}   ← if non-empty (A-7)
 
  Resume with: /pp:autonomous --from ${next_incomplete_phase}
 ```
 
-Proceed directly to lifecycle step (which handles partial completion — skips audit/complete/cleanup since not all phases are done). Exit cleanly.
+Run `run-end` (rule A-7) first. Proceed directly to lifecycle step (which handles partial completion — skips audit/complete/cleanup since not all phases are done). Exit cleanly.
 
 **Otherwise:** After each phase completes, re-read ROADMAP.md to catch phases inserted mid-execution (decimal phases like 5.1):
 
@@ -645,14 +548,15 @@ Re-filter incomplete phases using the same logic as discover_phases:
 - Apply `--from N` filter if originally provided
 - Apply `--to N` filter if originally provided
 - Sort by number ascending
+- Exclude phases handled this run: run `run-state-read` and drop every number in `HANDLED` (review defect 6a — a deferred or blocked phase must not be re-selected).
 
-Read STATE.md fresh:
+Read STATE.md fresh (workstream-aware):
 
 ```bash
-cat .planning/STATE.md
+STATE_RAW=$(pp_run query state.load --pick state_raw 2>/dev/null)
 ```
 
-Check for blockers in the Blockers/Concerns section. If blockers are found, go to handle_blocker with the blocker description.
+Check the Blockers/Concerns section of `$STATE_RAW`. If blockers are found, go to handle_blocker with the blocker description.
 
 If incomplete phases remain: proceed to next phase, loop back to execute_phase.
 
@@ -663,7 +567,7 @@ If incomplete phases remain: proceed to next phase, loop back to execute_phase.
 
 This means the user is always answering discuss questions (lightweight, interactive) while the heavy work (planning, code generation) runs in the background. The main context only accumulates discuss conversations — plan and execute contexts are isolated in their agents. (On Claude Code, plan and execute run inline, so they run sequentially and their work accumulates in the main context.)
 
-If all phases complete, proceed to lifecycle step.
+If no selectable phase remains, apply rule A-7: run `run-end`; if `DEFERRED` is non-empty, print the end-of-run summary naming each deferred phase and `/pp:verify-work N`, and exit — never the lifecycle, never "All phases complete". Otherwise proceed to lifecycle step.
 
 </step>
 
@@ -671,180 +575,35 @@ If all phases complete, proceed to lifecycle step.
 
 ## 5. Lifecycle
 
-**If `ONLY_PHASE` is set:** Skip lifecycle. A single phase does not trigger audit/complete/cleanup. Display:
-
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- pp-core ► AUTONOMOUS ▸ PHASE ${ONLY_PHASE} COMPLETE ✓
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
- Phase ${ONLY_PHASE}: ${PHASE_NAME} — Done
- Mode: Single phase (--only)
-
- Lifecycle skipped — run /pp:autonomous without --only
- after all phases complete to trigger audit/complete/cleanup.
-```
-
-Exit cleanly.
-
-**Otherwise:** After all phases complete, run the milestone lifecycle sequence: audit → complete → cleanup.
-
-Display lifecycle transition banner:
-
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- pp-core ► AUTONOMOUS ▸ LIFECYCLE
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
- All phases complete → Starting lifecycle: audit → complete → cleanup
- Milestone: {milestone_version} — {milestone_name}
-```
-
-**5a. Audit**
-
-```
-Skill(skill="pp-audit-milestone")
-```
-
-After audit completes, detect the result:
-
-```bash
-AUDIT_FILE=".planning/v${milestone_version}-MILESTONE-AUDIT.md"
-AUDIT_STATUS=$(grep "^status:" "${AUDIT_FILE}" 2>/dev/null | head -1 | cut -d: -f2 | tr -d ' ')
-```
-
-**If AUDIT_STATUS is empty** (no audit file or no status field):
-
-Go to handle_blocker: "Audit did not produce results — audit file missing or malformed."
-
-**If `passed`:**
-
-Display:
-```
-Audit ✅ passed — proceeding to complete milestone
-```
-
-Proceed to 5b (no user pause — per CTRL-01).
-
-**If `gaps_found`:**
-
-Read the gaps summary from the audit file. Display:
-```
-⚠ Audit: Gaps Found
-```
-
-Ask user via AskUserQuestion:
-- **question:** "Milestone audit found gaps. How to proceed?"
-- **options:** "Continue anyway — accept gaps" / "Stop — fix gaps manually"
-
-On **"Continue anyway"**: Display `Audit ⏭ Gaps accepted — proceeding to complete milestone` and proceed to 5b.
-
-On **"Stop"**: Go to handle_blocker with "User stopped — audit gaps remain. Run /pp:audit-milestone to review, then /pp:complete-milestone when ready."
-
-**If `tech_debt`:**
-
-Read the tech debt summary from the audit file. Display:
-```
-⚠ Audit: Tech Debt Identified
-```
-
-Show the summary, then ask user via AskUserQuestion:
-- **question:** "Milestone audit found tech debt. How to proceed?"
-- **options:** "Continue with tech debt" / "Stop — address debt first"
-
-On **"Continue with tech debt"**: Display `Audit ⏭ Tech debt acknowledged — proceeding to complete milestone` and proceed to 5b.
-
-On **"Stop"**: Go to handle_blocker with "User stopped — tech debt to address. Run /pp:audit-milestone to review details."
-
-**5b. Complete Milestone**
-
-```
-Skill(skill="pp-complete-milestone", args="${milestone_version}")
-```
-
-After complete-milestone returns, verify it produced output:
-
-```bash
-ls .planning/milestones/v${milestone_version}-ROADMAP.md 2>/dev/null || true
-```
-
-If the archive file does not exist, go to handle_blocker: "Complete milestone did not produce expected archive files."
-
-**5c. Cleanup**
-
-```
-Skill(skill="pp-cleanup")
-```
-
-Cleanup shows its own dry-run and asks user for approval internally — this is an acceptable pause per CTRL-01 since it's an explicit decision about file deletion.
-
-**5d. Final Completion**
-
-Display final completion banner:
-
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- pp-core ► AUTONOMOUS ▸ COMPLETE 🎉
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+> Full instructions are in `pp-core/references/autonomous-lifecycle.md`. Read that file now and follow it exactly.
 
- Milestone: {milestone_version} — {milestone_name}
- Status: Complete ✅
- Lifecycle: audit ✅ → complete ✅ → cleanup ✅
+Read and execute: `$HOME/.claude/pp-core/references/autonomous-lifecycle.md`
 
- Ship it! 🚀
-```
-
-</step>
-
-<step name="handle_blocker">
+It covers the `--only` skip, the audit → complete → cleanup sequence, and the
+milestone-complete banner. Return here only to proceed to §6 on a blocker.
 
 ## 6. Handle Blocker
 
-When any phase operation fails or a blocker is detected, present 3 options via AskUserQuestion:
-
-**Prompt:** "Phase {N} ({Name}) encountered an issue: {description}"
-
-**Options:**
-1. **"Fix and retry"** — Re-run the failed step (discuss, plan, or execute) for this phase
-2. **"Skip this phase"** — Mark phase as skipped, continue to the next incomplete phase
-3. **"Stop autonomous mode"** — Display summary of progress so far and exit cleanly
-
-**On "Fix and retry":** Loop back to the failed step within execute_phase. If the same step fails again after retry, re-present these options.
-
-**On "Skip this phase":** Log `Phase {N} ⏭ {Name} — Skipped by user` and proceed to iterate.
-
-**On "Stop autonomous mode":** Display progress summary:
-
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- pp-core ► AUTONOMOUS ▸ STOPPED
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
- Completed: {list of completed phases}
- Skipped: {list of skipped phases}
- Remaining: {list of remaining phases}
-
- Resume with: /pp:autonomous ${ONLY_PHASE ? "--only " + ONLY_PHASE : "--from " + next_phase}${TO_PHASE ? " --to " + TO_PHASE : ""}
-```
+Re-read `pp-core/references/autonomous-best-effort.md`, then apply rule A-4: best-effort retries the failed step once (counter in `$RUN_STATE`), then records the blocker, prints the STOPPED banner with the resume command and the end-of-run summary, and exits. `--supervised`: the three-option menu (Fix and retry / Skip this phase / Stop) in reference § Supervised menus.
 
 </step>
 
 </process>
 
 <success_criteria>
-- [ ] All incomplete phases executed in order (smart discuss → ui-phase → plan → execute → ui-review each)
-- [ ] Smart discuss proposes grey area answers in tables, user accepts or overrides per area
+- [ ] Selected phases (default: the next one) executed in order (smart discuss → ui-phase → plan → execute → ui-review each)
+- [ ] Smart discuss proposes grey area answers in tables; best-effort accepts the recommended ones and records them (`--supervised`: user accepts or overrides per area)
 - [ ] Progress banners displayed between phases
 - [ ] Execute-phase invoked with --no-transition (autonomous manages transitions)
 - [ ] Post-execution verification reads VERIFICATION.md and routes on status
 - [ ] Passed verification → automatic continue to next phase
-- [ ] Human-needed verification → user prompted to validate or skip
-- [ ] Gaps-found → user offered gap closure, continue, or stop
+- [ ] Human-needed verification → deferred, recorded in the report and never marked passed; `--supervised` restores the prompt
+- [ ] Gaps-found → one gap-closure attempt, then deferred and recorded; `--supervised` restores the prompt
 - [ ] Gap closure limited to 1 retry (prevents infinite loops)
 - [ ] Plan-phase and execute-phase failures route to handle_blocker
 - [ ] ROADMAP.md re-read after each phase (catches inserted phases)
 - [ ] STATE.md checked for blockers before each phase
-- [ ] Blockers handled via user choice (retry / skip / stop)
+- [ ] Blockers → one retry, then recorded and the run stops; `--supervised` restores the prompt
 - [ ] Final completion or stop summary displayed
 - [ ] After all phases complete, lifecycle step is invoked (not manual suggestion)
 - [ ] Lifecycle transition banner displayed before audit
@@ -883,4 +642,7 @@ When any phase operation fails or a blocker is detected, present 3 options via A
 - [ ] `--converge` fails fast with enable instructions when `workflow.plan_review_convergence=false`
 - [ ] `--converge` forwards reviewer selector flags and `--max-cycles N`
 - [ ] Default autonomous planning remains `pp-plan-phase` when convergence is not requested
+- [ ] No-arg run executes exactly the next incomplete phase (same path as `--only`), and stops when that phase is `human_needed`/`gaps_found`
+- [ ] Every auto-decision is appended to `{padded}-AUTONOMOUS-REPORT.md` as it is made
+- [ ] `--supervised` restores every prompt; otherwise `--unattended` is passed to plan-phase/execute-phase
 </success_criteria>