pi-plans 0.1.2 → 0.2.0

package/README.md

@@ -7,7 +7,7 @@
 <h2 align="center"><b>Plan. Review. Execute.</b></h2>
 
 <p align="center">
-  <i>Versioned, reviewed Markdown plans land before any code changes.<br>Human-in-the-loop planning for the Pi coding agent.</i>
+  <i>Versioned, reviewed Markdown plans land before any code changes.<br>Human-in-the-loop planning for the <a href="https://github.com/earendil-works/pi">Pi coding agent</a>.</i>
 </p>
 
 <p align="center">
@@ -16,6 +16,7 @@
   <a href="https://www.npmjs.com/package/pi-plans"><img alt="npm downloads" src="https://img.shields.io/npm/dt/pi-plans?color=38bdf8" /></a>
   <a href="https://www.npmjs.com/package/pi-plans"><img alt="npm version" src="https://img.shields.io/npm/v/pi-plans?color=60a5fa" /></a>
   <a href="https://github.com/earendil-works/pi"><img alt="Pi package" src="https://img.shields.io/badge/Pi-package-fbbf24" /></a>
+  <a href="https://github.com/earendil-works/pi"><img alt="Pi coding agent" src="https://img.shields.io/badge/Pi%20coding%20agent-earendil--works-22d3ee" /></a>
   <a href="./LICENSE"><img alt="License" src="https://img.shields.io/npm/l/pi-plans?color=22c55e" /></a>
   <a href="https://github.com/MaxInGaussian/pi-plans/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/MaxInGaussian/pi-plans/actions/workflows/ci.yml/badge.svg" /></a>
 </p>
@@ -62,7 +63,7 @@ A rough change request becomes a versioned Markdown plan instead of a surprise d
         tracked execution loop
    fused AGENTS.md × Ponytail executor rules
    checklist injected each turn, [DONE:VC-xxx]
-   markers tracked via bottom status bar + detail panel
+   markers tracked via bottom status bar
                  |
                  v
            run status: done
@@ -112,13 +113,15 @@ Planning artifacts live under `./docs/pi-plans/YYYY-MM-DD-<topic>/` by default (
 | Capability | In short |
 |---|---|
 | Planning router + five specialist skills | Start with `/skill:planning` to route to the narrowest matching specialist (`plan-small` → `plan-big`, `debug-and-plan`, `plan-with-refs`) |
-| Choice prompts | `ask_choice`: recommended option first, answers auto-recorded per run |
-| Refinement rounds | Read-only reviewer/criticizer Pi subagents consolidate findings into the next plan version |
+| Choice prompts | `ask_choice`: recommended option first, answers auto-recorded per run; choosing Auto-complete enables recommendation-only answers for later eligible questions in the current planning run, with `/plans-autocomplete-stop` available to take back control |
+| Refinement rounds | Read-only reviewer/criticizer Pi subagents consolidate findings into the next plan version; delegated runs have standalone `Reviewer`/`Criticizer` progress overlays that close before the tool result returns |
 | Workspace state | Config, runs, decisions, refs, and subagent ledgers in `.git/pi_plans/` (git common dir) |
-| Tracked execution | Checklist injected each turn; `[DONE:VC-xxx]` markers drive completion; implementation items report progress with `[I-xxx:implemented]` / `[I-xxx:validating]` markers; `plans-list` groups work by I-item with `[Pending/Implementing/Implemented/Validating/VC passed]` states (passed items struck through); the collapsed footer and expanded panel share the same progress projection, so `x/y` updates in real time in both views |
-| Execution model | With `plans set-execution-model <provider/model[:thinking]>`, the main session switches to it at handoff and restores the planning model + thinking level on stop/complete/abandon; when unset, the first execution handoff prompts for one and recommends inheriting the current session model |
-| Execution-phase compaction | Pi core owns threshold, overflow, and manual compaction scheduling; pi-plans only supplies a plan-aware `session_before_compact` summary and queues one hidden continuation when Pi reports `willRetry: false`, while preserving the raw execution tail and `previousSummary` chaining |
-| Planning-phase auto compaction | In active planning runs (run.status=planning, no execution), context usage >=100% triggers a plan-aware compaction too: pre-plan history compresses, Q&A during planning stays in a dedicated section, the latest `PLAN_vN.md` and later conversation stay raw; cooldown + resume guard prevent ping-pong, and manual `/compact` follows the same rules |
+| Smart compact (I-aware) | History is sliced by `I-###` instead of VC. The current-I slice above 20% of the model window triggers a bounded summary with paired `Read:` records, retains a legal recent suffix, targets <10% post-context, and records a hard-floor reason when unreachable. Planning phase falls back to the latest plan/Q&A focus when no current marker exists; cooldown + resume guard prevent ping-pong; one hidden continuation is queued when Pi reports `willRetry: false` |
+| Visible Refiner overlay | Delegated reviewer/criticizer subagents surface as a named public overlay in the TUI — one `Reviewer`/`Criticizer` panel with per-lane tool progress, bounded output preview, and clean cancelled/timed-out vs completed states. The overlay opens when the round starts and closes before the tool result returns to the main session |
+| Tracked execution | Checklist injected each turn; `[DONE:VC-xxx]` markers drive completion; implementation items report progress with `[I-xxx:implemented]` / `[I-xxx:validating]` markers; the bottom status bar shows lifecycle, `x/y` progress, elapsed time, and input/output token usage in real time |
+| Execution handoff | The accepted plan resumes in the current session model; no separate model selection is performed. |
+| Execution-phase compaction | Pi core owns threshold, overflow, and manual scheduling; pi-plans adds a current-I proactive check once the current-I slice exceeds 20% of the model window, summarizes I-level history and bounded `Read:` records, retains a legal recent suffix, targets under 10% when possible, and records hard-floor reasons when not; one hidden continuation is queued when Pi reports `willRetry: false` |
+| Planning-phase auto compaction | In active planning runs (run.status=planning, no execution), the current-I check uses the same 20%/10% best-effort policy when a marker exists; without a marker it protects the latest plan/Q&A focus, while Pi threshold, overflow, and manual compaction remain supported; cooldown + resume guard prevent ping-pong and hidden resume messages stay out of model context |
 | Efficient executor prompt | Each turn, the executor is steered by a fused rule set — Marcos Hernanz's AGENTS.md principles × Ponytail minimalism: layered growth, simplest implementation, long-term architecture (no stopgaps), library discipline — so plans finish in fewer tokens and fewer detours |
 | Write guard | `edit`/`write` blocked outside planning artifacts while a run is active |
 
@@ -126,17 +129,37 @@ Planning artifacts live under `./docs/pi-plans/YYYY-MM-DD-<topic>/` by default (
 
 | Tool / Command | Purpose |
 |---|---|
-| `plans` | State CLI: `init`, `show`, `set-language`, `set-artifact-root`, `set-execution-model`, `set-role`, `start-run`, `set-status`, `record-decision`, `record-ref`, `record-subagent` |
+| `plans` | State CLI: `init`, `show`, `set-language`, `set-artifact-root`, `set-role`, `start-run`, `set-status`, `record-decision`, `record-ref`, `record-subagent` |
 | `ask_choice` | Numbered choice prompt; `autoComplete: false` for the merged accept/execute question and external-state questions |
-| `refine` | Reviewer/criticizer round via read-only subagents (`--tools read,grep,find,ls`); `reviewers: 3` for big plans; enforces role/model confirmation gates |
-| `execute_plan` | Execution handoff: re-confirms with the user, prompts for an execution model if needed, and enters extension-managed execution mode |
+| `refine` | Reviewer/criticizer round via standalone read-only subagents (`--mode json -p --no-session --tools read,grep,find,ls`); delegated TUI runs show one `Reviewer`/`Criticizer` overlay and close it before returning; `reviewers: 3` for big plans; enforces role/model confirmation gates |
+| `execute_plan` | Execution handoff: re-confirms with the user and enters extension-managed execution mode |
 | `/plans` | Show config, active run, and execution progress |
-| `/plans-list` | Toggle the execution checklist panel |
-| `/plans-execute [plan.md]` | Manual execution handoff (defaults to highest `PLAN_vN.md`; prompts for an execution model if unset) |
+| `/plans-execute [plan.md]` | Manual execution handoff (defaults to highest `PLAN_vN.md`) |
 | `/update-plan [plan.md] [reason…]` | Interrupt-and-refine: stops execution (if any), returns the run to planning, and directs the agent to revise the plan into `PLAN_vN+1.md` while preserving verified work |
+| `/plans-autocomplete-stop` | Stop the current run's Auto-complete mode and return later planning questions to normal interaction |
 | `/plans-stop` | Stop execution mode |
 | `/plans-abandon` | Abandon the active run (lifts the write guard; artifacts stay) |
-| Status bar (lifecycle) | 💬 Q&A → 📝 draft written (planning sub-phases) → ⌛ executing `x/y · spent · in/out-toks` in the collapsed footer or expanded panel → ⛔ stopped / 🎯 done / 🚫 abandoned |
+| Status bar (lifecycle) | 💬 Q&A → 📝 draft written (planning sub-phases) → ⌛ executing `x/y · spent · in/out-toks` in the bottom status bar → ⛔ stopped / 🎯 done / 🚫 abandoned |
+
+## Smart compact (I-aware)
+
+Default `compaction` is Pi-core-owned: threshold, overflow, and manual `/compact` always run as designed. On top of that, pi-plans layers an **I-aware policy** so long, tool-heavy sessions survive the same run instead of running out of context:
+
+- **Slice by implementation item.** History is grouped by `[I-###:current]` markers instead of `[DONE:VC-xxx]`. The current I's prefix can be summarized, the current I's recent suffix stays raw, and finished `I-###` items become independent sections.
+- **Bounded read history.** Every paired `read` call/result is reduced to `Read: <path> line <X-Y> Extracted information summary: ...` (line range is `unknown` when no offset/limit is given). Records deduplicate by path/range across compactions and never embed full raw tool output.
+- **20%/10% best-effort budget.** When the current-I slice exceeds 20% of `ctx.getContextUsage().contextWindow`, a compact is requested on the next settled turn. The summary's `details` record `contextWindow`, `tokensBefore`, `currentITokens`, `summaryTokens`, `keptSuffixTokens`, `estimatedAfterTokens`, `targetRatio`, `currentI`, `firstKeptEntryId`, `targetMet`, and a `hardFloorReason` when the 10% target cannot be reached (system prompt, tool definitions, single oversized tool result). Hard floors stop the loop; they do not silently fall through.
+- **Pi-owned scheduling preserved.** Threshold, overflow, and manual triggers still come from Pi core. pi-plans only customizes the summary and re-arms once usage falls below the low watermark. The hidden `Continue execution.` resume message is queued on non-retry compactions and never enters model context.
+- **Bounded model call.** Custom summaries reuse the current Pi model via `ctx.modelRegistry.complete(model, context, options)` with `event.signal`, `cacheRetention: "none"`, a fresh `sessionId`, and bounded `maxTokens`. Empty, length-stopped, error, or tool-call responses fall back to Pi's default compaction — no half-checkpoint is ever written.
+- **Phase isolation.** Planning and execution keep independent compaction state (`pi-plans-plan-resume` vs `pi-plans-exec-resume`); planning without a current marker protects the latest plan/Q&A focus rather than leaking execution state.
+
+## Visible Refiner overlay
+
+Delegated `refine` rounds (reviewer or criticizer) show their progress directly inside the Pi TUI instead of disappearing into the child process's terminal. The overlay is a public, named panel so users always know who is doing what:
+
+- **Named public overlays.** Each round uses the literal overlay name `Reviewer` or `Criticizer` (no dependency on `pi-btw`; the renderer is built on Pi's public `pi-tui` primitives). The big-plan concurrent reviewer round renders one reviewer lane per subagent under the same `Reviewer` overlay.
+- **Bounded live detail.** The overlay tracks lane state (`pending → running → completed | cancelled | timed-out`) and the most recent tool call plus a clipped argument preview. Raw tool output is never surfaced, so progress stays legible even when subagents read large files.
+- **Clean lifecycle edges.** The overlay opens at round start, advances via the JSONL progress feed emitted by `pi --mode json`, and is `close()`d before the round's conclusion returns as a tool result to the main session. Cancelled and timed-out children render as terminal states with the original error message — never as silent drops.
+- **Tool-only progress.** The overlay only consumes tool and message lifecycle events from the child; unrelated `pi` events are ignored, so a noisy upstream release does not desync the panel.
 
 ## The execution rules
 
@@ -154,6 +177,9 @@ Once you approve the handoff, every turn injects a compact rule set that fuses M
 
 The rules cost four lines per turn and buy back far more: fewer wrong turns, shorter implementation paths, plans that finish in fewer tokens.
 
+Waiting for subprocess-backed verification:
+For subprocess-backed verification, when a step starts a subprocess and needs its result before verifying, use literal `waiting for` with backoff `5s -> 10s -> 20s -> 40s -> 80s`, then keep polling at 80s; restart at 5s for each new subprocess.
+
 ## Skills
 
 Invoked via `resources_discover`, callable as `/skill:<name>`, directly as `/<name>` (e.g. `/planning`, `/plan-small` — extension aliases that forward to the skill), or picked automatically from the task description.
@@ -194,12 +220,12 @@ or register the absolute path in `~/.pi/agent/settings.json`:
 pi-plans/
 ├── index.ts               # Extension entry: tools, commands, guard, execution loop
 ├── tools/                 # plans, ask-choice, refine, execute-plan
-├── src/                   # state, guard, plan parsing, subagent runner, exec loop
+├── src/                   # state, guard, plan parsing, subagent runner, refine overlay, exec loop
 ├── skills/                # The planning router plus five specialist planning skills
 ├── references/            # Shared workflow, state/config, plan template (normative)
 ├── agents/                # reviewer.md / criticizer.md subagent prompts
 ├── scripts/validate.ts    # Structure validator
-└── tests/                 # node:test suite (state, guard, plan parsing, execution)
+└── tests/                 # node:test suite (state, guard, plan parsing, execution, refine progress)
 ```
 
 ## Safety model
@@ -223,7 +249,7 @@ The plan is the contract. Refinement converges on scope while nothing is writabl
 
 **What can Auto-complete decide on my behalf?**
 
-Planning and refinement choices only (the recommended option). It is never offered for execution approval, installs, publishing, deployment, merge, push, or credentials — those questions stop and wait for you.
+Planning and refinement choices only (the recommended option). Choosing Auto-complete enables the recommended answer for later eligible planning questions in the current run and the extension continues the planning turn when the model stops early. Use `/plans-autocomplete-stop` to take back control. It is never offered for execution approval, installs, publishing, deployment, merge, push, or credentials — those questions stop and wait for you.
 
 **Where does all the state live?**
 

package/index.ts

@@ -10,7 +10,7 @@
  *   - `refine` tool     — reviewer/criticizer rounds via read-only pi subagents
  *   - `execute_plan`    — execution handoff into the tracked execution loop
  *   - write guard       — planning runs may only write planning artifacts
- *   - execution loop    — checklist injection, [DONE:VC-xxx] tracking, progress widget
+ *   - execution loop    — checklist injection, [DONE:VC-xxx] tracking, progress status
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
@@ -19,7 +19,6 @@ import * as path from "node:path";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import {
-	consumePendingPanelSync,
 	consumePlanningCompactionResumeGuard,
 	drainExecutionFlush,
 	executionContextMessage,
@@ -29,23 +28,28 @@ import {
 	handleExecutionBeforeCompact,
 	handleExecutionCompact,
 	handleExecutionCompactFailed,
+	handleExecutionTurnCompaction,
 	handlePlanningBeforeCompact,
 	handlePlanningCompact,
 	handlePlanningCompactFailed,
 	PLANNING_PLAN_WRITTEN_CUSTOM_TYPE,
 	registerExecutionTurnHandlers,
-	recordTouchedPaths,
 	refreshPlanningCompactionCooldown,
 	requestPlanningCompaction,
 	restoreFromSession,
-	ensureExecutionModelActive,
 	stopExecution,
-	syncExecutionPanel,
-	toggleExecutionPanelView,
 	updateStatusWidget,
 	shouldTriggerPlanningCompaction,
 } from "./src/exec.ts";
+import {
+	autoCompleteStatus,
+	disableAutoComplete,
+	markPlanWritten,
+	registerAutoCompleteTurnHandlers,
+	restoreAutoCompleteFromSession,
+} from "./src/autocomplete.ts";
 import { planningWriteBlockReason } from "./src/guard.ts";
+import { registerQueryInterviewHooks } from "./src/query-hook.ts";
 import { latestPlanVersion, nextPlanVersionPath } from "./src/plan.ts";
 import { getRun, readActive, recordDecision, resolveStateRootOrNull, setRunStatus } from "./src/state.ts";
 import { registerAskChoiceTool } from "./tools/ask-choice.ts";
@@ -80,20 +84,12 @@ function extensionStalenessLine(): string {
 	}
 }
 
-function extractPathsFromBash(command: string): string[] {
-	const values = new Set<string>();
-	for (const token of command.split(/\s+/)) {
-		const cleaned = token.replace(/^["'`(<[{]+|["'`)>}\],;]+$/g, "");
-		if (!cleaned || cleaned === "." || cleaned === ".." || cleaned.startsWith("-") || cleaned.includes("=") ) continue;
-		const looksLikePath =
-			cleaned.includes("/") ||
-			cleaned.startsWith(".") ||
-			cleaned.startsWith("~") ||
-			/^[A-Za-z0-9._-]+\.[A-Za-z0-9._-]+$/.test(cleaned);
-		if (!looksLikePath) continue;
-		values.add(cleaned);
-	}
-	return [...values];
+function hasActivePlanningWorkflow(ctx: Parameters<typeof updateStatusWidget>[0]): boolean {
+	if (getExecution()) return true;
+	const active = readActive(ctx.cwd);
+	if (!active) return false;
+	const status = getRun(ctx.cwd, active.run_id)?.status;
+	return status === "planning" || status === "accepted" || status === "executing";
 }
 
 export default function piPlansExtension(pi: ExtensionAPI): void {
@@ -101,6 +97,7 @@ export default function piPlansExtension(pi: ExtensionAPI): void {
 	registerAskChoiceTool(pi);
 	registerRefineTool(pi, baseDir);
 	registerExecutePlanTool(pi);
+	registerQueryInterviewHooks(pi, hasActivePlanningWorkflow);
 
 	// Contribute the router skill plus the five specialist planning skills.
 	pi.on("resources_discover", () => ({
@@ -142,25 +139,14 @@ export default function piPlansExtension(pi: ExtensionAPI): void {
 	// not been approved), edit/write may only target planning artifacts.
 	// -----------------------------------------------------------------------
 	pi.on("tool_call", async (event, ctx) => {
-		const execution = getExecution();
-		if (execution) {
-			if (event.toolName === "edit" || event.toolName === "write") {
-				const rawPath = String((event.input as { path?: string }).path ?? "");
-				if (rawPath) recordTouchedPaths(ctx.cwd, [rawPath]);
-			}
-			if (event.toolName === "bash") {
-				const command = String((event.input as { command?: string }).command ?? "");
-				if (command) recordTouchedPaths(ctx.cwd, extractPathsFromBash(command));
-			}
-			return;
-		}
+		if (getExecution()) return;
 		const rawPath = String((event.input as { path?: string }).path ?? "");
 		if (!rawPath) return;
 		const reason = planningWriteBlockReason({ workdir: ctx.cwd, toolName: event.toolName, rawPath });
 		if (reason) return { block: true, reason };
 		// Allowed write: if it lands exactly on the run's latest plan file, drop a
 		// marker entry so planning-phase compaction can anchor its cut point there.
-		if (event.toolName === "write") {
+		if (event.toolName === "write" || event.toolName === "edit") {
 			const active = readActive(ctx.cwd);
 			if (active) {
 				const latest = latestPlanVersion(active.artifact_dir);
@@ -169,6 +155,7 @@ export default function piPlansExtension(pi: ExtensionAPI): void {
 						runId: active.run_id,
 						planPath: latest.path,
 					});
+					markPlanWritten(ctx);
 				}
 			}
 		}
@@ -210,7 +197,6 @@ export default function piPlansExtension(pi: ExtensionAPI): void {
 	// -----------------------------------------------------------------------
 	pi.on("before_agent_start", async (_event, ctx) => {
 		drainExecutionFlush(pi, ctx);
-		await ensureExecutionModelActive(pi, ctx);
 		const content = executionContextMessage();
 		if (!content) {
 			if (!getExecution() && shouldTriggerPlanningCompaction(ctx)) {
@@ -228,10 +214,11 @@ export default function piPlansExtension(pi: ExtensionAPI): void {
 	});
 
 	registerExecutionTurnHandlers(pi, async (ctx) => {
-		if (!getExecution()) {
+		if (getExecution()) {
+			handleExecutionTurnCompaction(ctx);
+		} else {
 			refreshPlanningCompactionCooldown(ctx);
 			if (consumePlanningCompactionResumeGuard(ctx)) {
-				if (consumePendingPanelSync()) syncExecutionPanel(ctx);
 				updateStatusWidget(ctx);
 				return;
 			}
@@ -239,26 +226,14 @@ export default function piPlansExtension(pi: ExtensionAPI): void {
 				requestPlanningCompaction(ctx);
 			}
 		}
-		// A busy-toggle during the previous turn deferred its re-render; the
-		// turn just ended, so this is the safe point to apply it.
-		if (consumePendingPanelSync()) syncExecutionPanel(ctx);
+		// A completed turn is the safe point for status updates.
 		updateStatusWidget(ctx);
 	});
+	registerAutoCompleteTurnHandlers(pi);
 
 	// -----------------------------------------------------------------------
-	// Commands and shortcuts
+	// Commands
 	// -----------------------------------------------------------------------
-	pi.registerShortcut("alt+o", {
-		description: "Toggle pi-plans execution checklist widget",
-		handler: async (ctx) => {
-			const expanded = toggleExecutionPanelView(pi, ctx);
-			if (expanded === null) {
-				ctx.ui.notify("No execution in progress.", "info");
-				return;
-			}
-			ctx.ui.notify(expanded ? "Execution checklist expanded." : "Execution checklist collapsed.", "info");
-		},
-	});
 
 	pi.registerCommand("plans", {
 		description: "Show pi-plans state: config, active run, and execution progress",
@@ -283,20 +258,17 @@ export default function piPlansExtension(pi: ExtensionAPI): void {
 					lines.push(`  ${item.done ? "☑" : "☐"} ${item.id}`);
 				}
 			}
+			lines.push(`Auto-complete: ${autoCompleteStatus(ctx)}`);
 			lines.push(extensionStalenessLine());
 			ctx.ui.notify(lines.join("\n"), "info");
 		},
 	});
 
-	pi.registerCommand("plans-list", {
-		description: "Toggle the pi-plans execution checklist widget",
+	pi.registerCommand("plans-autocomplete-stop", {
+		description: "Stop Auto-complete for the active planning run",
 		handler: async (_args, ctx) => {
-			const expanded = toggleExecutionPanelView(pi, ctx);
-			if (expanded === null) {
-				ctx.ui.notify("No execution in progress.", "info");
-				return;
-			}
-			ctx.ui.notify(expanded ? "Execution checklist expanded." : "Execution checklist collapsed.", "info");
+			const stopped = disableAutoComplete(ctx, "stopped by user");
+			ctx.ui.notify(stopped ? "Auto-complete stopped." : "Auto-complete is not active.", stopped ? "info" : "warning");
 		},
 	});
 
@@ -333,6 +305,7 @@ export default function piPlansExtension(pi: ExtensionAPI): void {
 
 			const active = readActive(ctx.cwd);
 			const execution = getExecution();
+			disableAutoComplete(ctx, "plan update");
 
 			// Resolve the plan to revise: explicit arg > running execution > latest in artifact dir.
 			let sourcePlanPath: string | null = planArg
@@ -441,6 +414,7 @@ export default function piPlansExtension(pi: ExtensionAPI): void {
 			);
 			if (!ok) return;
 			// Abandon must end execution first so the planning model is restored.
+			disableAutoComplete(ctx, "run abandoned");
 			if (getExecution()) {
 				await stopExecution(pi, ctx, "run abandoned via /plans-abandon");
 			}
@@ -459,5 +433,6 @@ export default function piPlansExtension(pi: ExtensionAPI): void {
 	// -----------------------------------------------------------------------
 	pi.on("session_start", async (_event, ctx) => {
 		await restoreFromSession(pi, ctx, ctx.sessionManager.getEntries() as unknown as Parameters<typeof restoreFromSession>[2]);
+		restoreAutoCompleteFromSession(ctx, ctx.sessionManager.getEntries() as unknown as Parameters<typeof restoreAutoCompleteFromSession>[1]);
 	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-plans",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Human-in-the-loop planning extension for the Pi coding agent: researched, refined Markdown plans before any code changes.",
   "license": "MIT",
   "type": "module",

package/references/pi-planning-workflow.md

@@ -9,8 +9,9 @@ This skill set is written for the Pi coding agent's documented behavior:
 - the five skills are contributed by the pi-plans extension and loaded as Pi skills (also invokable as `/skill:<name>`);
 - skill references and helper sources are resolved relative to the directory containing `SKILL.md`;
 - the extension provides these tools: `plans` (workspace state), `ask_choice` (choice prompts), `refine` (reviewer/criticizer subagents), and `execute_plan` (execution handoff);
-- `refine` spawns read-only Pi subagents (`pi --mode json -p --no-session --tools read,grep,find,ls`) with isolated context; their results return to the main session as tool output;
-- the execution loop is extension-managed: remaining verifier items are injected each turn and `[DONE:VC-xxx]` markers are tracked with a footer progress widget.
+- `refine` spawns read-only Pi subagents (`pi --mode json -p --no-session --tools read,grep,find,ls`) with isolated context; delegated Reviewer/Criticizer runs show a standalone aggregate overlay titled `Reviewer` or `Criticizer`, close the overlay before returning, and return conclusions to the main session as tool output;
+- the execution loop is extension-managed: remaining verifier items are injected each turn, implementation items emit `[I-###:current]`/`[I-###:implemented|validating]`, and `[DONE:VC-xxx]` markers are tracked with a bottom status bar;
+- execution and planning compaction keep Pi's SessionManager as the history owner, group compacted history by implementation item, retain a legal current-I suffix, summarize paired reads as bounded `Read: <path> line <X-Y> Extracted information summary: ...` records, and target `<10%` of the model window after a current-I slice exceeds `20%`; hard-floor cases are recorded instead of looping;
 
 ## Planning Boundary
 
@@ -60,6 +61,7 @@ Every user-facing planning or refinement question goes through the `ask_choice`
 - `options`: ordered options, recommended option first with `recommended: true` (exactly one), each with the tradeoff that matters in `description`;
 - do not add `Other` or `Auto-complete` yourself — the tool appends `Other…` second-last and `Auto-complete` last;
 - pass `autoComplete: false` for the merged accept/execute question — it contains the execution approval, so Auto-complete never appears there — and for any install waiver, publishing, deployment, merge, push, credential, or external-state question. Auto-complete may choose the recommended planning or refinement option only.
+- When the user selects Auto-complete, it remains active for the current planning run: later eligible questions use their recommended options automatically, and the extension queues one deduplicated follow-up if the model stops after an auto-completed answer. `/plans-autocomplete-stop` disables it; session restore may reactivate it only for the same active run while its status is `planning`.
 
 Answers are recorded automatically in the active run's `decisions.jsonl`. You must still maintain `DECISIONS.md` in the artifact directory (summary table of questions, options, answers, answer sources, open assumptions).
 
@@ -126,7 +128,8 @@ A refinement round is complete when all reviewer outputs have returned or all cr
 
 When the user picks `✓ Accept PLAN_vN and execute it now` in the merged question, mark the plan accepted and call the `execute_plan` tool (or the user runs `/plans-execute`). It re-confirms with the user, then the extension enters execution mode:
 
-- every agent turn is injected with the remaining verifier checklist and execution rules (layered simplest implementation, no stopgaps, dependency and library discipline, minimum tests);
+- every agent turn is injected with the remaining verifier checklist and execution rules (layered simplest implementation, waiting for subprocess-backed verification with backoff 5s -> 10s -> 20s -> 40s -> 80s, then keep polling at 80s and restart at 5s for each new subprocess, no stopgaps, dependency and library discipline, minimum tests);
+- execution-phase compaction may proactively compact the current-I slice above 20% of the model window, summarizes the oldest eligible prefix and bounded Read records, preserves a legal recent suffix, and records whether the <10% target was met; Pi still owns threshold, overflow, and manual scheduling;
 - the read-only guard lifts: full write access returns;
 - the run status moves to `executing`, then `done` when the last `[DONE:VC-xxx]` marker lands;
 - `/plans-stop` stops execution; `/plans` shows progress.

package/references/state-and-config.md

@@ -120,7 +120,7 @@ If a spawn later fails because the stored selector is unavailable, reset the mar
 
 ## Subagent Spawning
 
-When `mode` is `delegated-subagent`, the `refine` tool spawns a read-only `pi` subprocess (`--mode json -p --no-session --tools read,grep,find,ls`) whose system prompt comes from `agents/reviewer.md` or `agents/criticizer.md`. The subagent:
+When `mode` is `delegated-subagent`, the `refine` tool spawns a read-only `pi` subprocess (`--mode json -p --no-session --tools read,grep,find,ls`) whose system prompt comes from `agents/reviewer.md` or `agents/criticizer.md`. In TUI mode, delegated runs also show a standalone `Reviewer` or `Criticizer` overlay with live lane/tool status; the child is awaited and the overlay is closed before the tool result returns. The subagent:
 
 - performs read-only analysis and never edits files;
 - receives the full plan text and a review/criticism brief;

package/src/autocomplete.ts

@@ -0,0 +1,163 @@
+/** Run-scoped Auto-complete state and planning-turn continuation. */
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { getRun, readActive } from "./state.ts";
+
+export const AUTOCOMPLETE_ENTRY = "pi-plans-autocomplete";
+const AUTOCOMPLETE_CONTINUE = "Continue the current planning workflow. Raise the next relevant question with ask_choice; do not stop after an auto-completed answer.";
+
+type SessionEntry = { type: string; customType?: string; data?: unknown };
+
+type AutoCompleteState = {
+	runId: string;
+	enabled: boolean;
+	pendingFollowUp: boolean;
+	askChoiceCount: number;
+	autoChoiceCount: number;
+	planWritten: boolean;
+};
+
+type SessionWithAutoComplete = ExtensionContext["sessionManager"] & {
+	__piPlansAutoComplete?: AutoCompleteState;
+};
+
+let api: ExtensionAPI | null = null;
+
+export function setAutoCompleteApi(next: ExtensionAPI | null): void {
+	api = next;
+}
+
+function sessionState(ctx: ExtensionContext): AutoCompleteState | undefined {
+	return (ctx.sessionManager as SessionWithAutoComplete).__piPlansAutoComplete;
+}
+
+function activePlanningRun(ctx: ExtensionContext): { runId: string } | null {
+	const active = readActive(ctx.cwd);
+	if (!active) return null;
+	const run = getRun(ctx.cwd, active.run_id);
+	return run?.status === "planning" ? { runId: run.run_id } : null;
+}
+
+function appendState(runId: string, enabled: boolean, reason?: string): void {
+	if (!api) return;
+	api.appendEntry(AUTOCOMPLETE_ENTRY, { runId, enabled, ...(reason ? { reason } : {}) });
+}
+
+export function enableAutoComplete(ctx: ExtensionContext): boolean {
+	const run = activePlanningRun(ctx);
+	if (!run) return false;
+	const current = sessionState(ctx);
+	if (current?.enabled && current.runId === run.runId) return true;
+	(ctx.sessionManager as SessionWithAutoComplete).__piPlansAutoComplete = {
+		runId: run.runId,
+		enabled: true,
+		pendingFollowUp: false,
+		askChoiceCount: 0,
+		autoChoiceCount: 0,
+		planWritten: false,
+	};
+	appendState(run.runId, true);
+	return true;
+}
+
+export function disableAutoComplete(ctx: ExtensionContext, reason = "disabled"): boolean {
+	const state = sessionState(ctx);
+	const run = activePlanningRun(ctx);
+	const runId = state?.runId ?? run?.runId;
+	if (!runId && !state?.enabled) return false;
+	if (state) state.enabled = false;
+	if (runId) appendState(runId, false, reason);
+	return true;
+}
+
+export function isAutoCompleteEnabled(ctx: ExtensionContext): boolean {
+	const state = sessionState(ctx);
+	const run = activePlanningRun(ctx);
+	return !!state?.enabled && !!run && state.runId === run.runId;
+}
+
+/** Record every ask_choice call for this turn; autoChoice marks a recommendation selected by the mode. */
+export function recordAskChoice(ctx: ExtensionContext, autoChoice: boolean): void {
+	const state = sessionState(ctx);
+	if (!state) return;
+	state.askChoiceCount += 1;
+	if (autoChoice) state.autoChoiceCount += 1;
+}
+
+export function markPlanWritten(ctx: ExtensionContext): void {
+	const state = sessionState(ctx);
+	if (state) state.planWritten = true;
+}
+
+export function resetAutoCompleteTurn(ctx: ExtensionContext): void {
+	const state = sessionState(ctx);
+	if (!state) return;
+	state.pendingFollowUp = false;
+	state.askChoiceCount = 0;
+	state.autoChoiceCount = 0;
+	state.planWritten = false;
+}
+
+export function shouldContinueAutoComplete(ctx: ExtensionContext): boolean {
+	const state = sessionState(ctx);
+	return isAutoCompleteEnabled(ctx)
+		&& !!state
+		&& state.autoChoiceCount > 0
+		&& state.askChoiceCount === state.autoChoiceCount
+		&& !state.planWritten
+		&& !state.pendingFollowUp;
+}
+
+export async function continueAutoComplete(ctx: ExtensionContext): Promise<boolean> {
+	if (!api || !shouldContinueAutoComplete(ctx)) return false;
+	const state = sessionState(ctx);
+	if (!state) return false;
+	state.pendingFollowUp = true;
+	try {
+		await api.sendUserMessage(AUTOCOMPLETE_CONTINUE, { deliverAs: "followUp" });
+		return true;
+	} catch {
+		state.pendingFollowUp = false;
+		return false;
+	}
+}
+
+export function registerAutoCompleteTurnHandlers(pi: ExtensionAPI): void {
+	setAutoCompleteApi(pi);
+	pi.on("turn_start", async (_event, ctx) => {
+		resetAutoCompleteTurn(ctx);
+	});
+	pi.on("turn_end", async (event, ctx) => {
+		const message = event.message as { role?: string } | undefined;
+		if (message?.role === "assistant") await continueAutoComplete(ctx);
+	});
+}
+
+export function restoreAutoCompleteFromSession(ctx: ExtensionContext, entries: SessionEntry[]): void {
+	const session = ctx.sessionManager as SessionWithAutoComplete;
+	delete session.__piPlansAutoComplete;
+	let restored: { runId: string; enabled: boolean } | null = null;
+	for (let i = entries.length - 1; i >= 0; i--) {
+		const entry = entries[i];
+		if (entry.type !== "custom" || entry.customType !== AUTOCOMPLETE_ENTRY || !entry.data) continue;
+		const data = entry.data as { runId?: unknown; enabled?: unknown };
+		if (typeof data.runId === "string" && typeof data.enabled === "boolean") {
+			restored = { runId: data.runId, enabled: data.enabled };
+			break;
+		}
+	}
+	const active = activePlanningRun(ctx);
+	if (!restored || !restored.enabled || !active || restored.runId !== active.runId) return;
+	session.__piPlansAutoComplete = {
+		runId: active.runId,
+		enabled: true,
+		pendingFollowUp: false,
+		askChoiceCount: 0,
+		autoChoiceCount: 0,
+		planWritten: false,
+	};
+}
+
+export function autoCompleteStatus(ctx: ExtensionContext): "enabled" | "disabled" {
+	return isAutoCompleteEnabled(ctx) ? "enabled" : "disabled";
+}