pi-plans 0.1.1 → 0.2.0

package/README.md

@@ -7,15 +7,18 @@
 <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">
   <a href="https://github.com/MaxInGaussian/pi-plans/stargazers"><img alt="GitHub stars" src="https://img.shields.io/github/stars/MaxInGaussian/pi-plans?style=square" /></a>
   <a href="https://hits.sh/github.com/MaxInGaussian/pi-plans/"><img alt="Repo views" src="https://hits.sh/github.com/MaxInGaussian/pi-plans.svg?label=repo%20views" /></a>
-  <a href="./LICENSE"><img alt="License: MIT" src="https://img.shields.io/badge/License-MIT-blue.svg?style=square" /></a>
-  <img alt="TypeScript" src="https://img.shields.io/badge/TypeScript-TS-3178C6?style=square&logo=typescript&logoColor=white" />
-  <img alt="pi-package" src="https://img.shields.io/badge/pi--package-ready-7c3aed?style=square" />
+  <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>
 
 ---
@@ -60,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
@@ -110,10 +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 progress; live `x/y · spent · in/out-toks` in the bottom status bar |
+| 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 |
 
@@ -123,14 +131,35 @@ Planning artifacts live under `./docs/pi-plans/YYYY-MM-DD-<topic>/` by default (
 |---|---|
 | `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, enters extension-managed execution mode |
-| `/plans` | Show config, active run, execution progress |
+| `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-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` → ⛔ 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
 
@@ -148,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.
@@ -188,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
@@ -217,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,21 +19,37 @@ import * as path from "node:path";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import {
-	applyDoneMarkers,
-	completeExecution,
-	consumePendingPanelSync,
+	consumePlanningCompactionResumeGuard,
+	drainExecutionFlush,
 	executionContextMessage,
+	filterExecutionResumeMessages,
+	filterPlanningResumeMessages,
 	getExecution,
-	isExecutionComplete,
-	recordExecutionCompletion,
-	recordTouchedPaths,
+	handleExecutionBeforeCompact,
+	handleExecutionCompact,
+	handleExecutionCompactFailed,
+	handleExecutionTurnCompaction,
+	handlePlanningBeforeCompact,
+	handlePlanningCompact,
+	handlePlanningCompactFailed,
+	PLANNING_PLAN_WRITTEN_CUSTOM_TYPE,
+	registerExecutionTurnHandlers,
+	refreshPlanningCompactionCooldown,
+	requestPlanningCompaction,
 	restoreFromSession,
 	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";
@@ -43,20 +59,37 @@ import { registerRefineTool } from "./tools/refine.ts";
 
 const baseDir = dirname(fileURLToPath(import.meta.url));
 
-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);
+// When THIS copy of the extension was imported into the running pi process.
+// /plans compares it against the newest source-file mtime so a stale instance
+// (code on disk newer than the loaded copy) is immediately visible.
+const extensionLoadedAt = new Date();
+
+function extensionStalenessLine(): string {
+	try {
+		const dirs = [baseDir, path.join(baseDir, "src"), path.join(baseDir, "tools")];
+		let newest = 0;
+		for (const dir of dirs) {
+			for (const name of fs.readdirSync(dir)) {
+				if (!name.endsWith(".ts")) continue;
+				const mtime = fs.statSync(path.join(dir, name)).mtimeMs;
+				if (mtime > newest) newest = mtime;
+			}
+		}
+		if (newest > extensionLoadedAt.getTime() + 2000) {
+			return `⚠ extension code on disk is newer than the loaded copy (loaded ${extensionLoadedAt.toISOString()}); run /reload to pick it up`;
+		}
+		return `Extension loaded: ${extensionLoadedAt.toISOString()} (up to date)`;
+	} catch {
+		return `Extension loaded: ${extensionLoadedAt.toISOString()}`;
 	}
-	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 {
@@ -64,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", () => ({
@@ -105,31 +139,71 @@ 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;
-		return { block: true, reason };
+		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" || event.toolName === "edit") {
+			const active = readActive(ctx.cwd);
+			if (active) {
+				const latest = latestPlanVersion(active.artifact_dir);
+				if (latest && path.resolve(ctx.cwd, rawPath) === path.resolve(ctx.cwd, latest.path)) {
+					pi.appendEntry(PLANNING_PLAN_WRITTEN_CUSTOM_TYPE, {
+						runId: active.run_id,
+						planPath: latest.path,
+					});
+					markPlanWritten(ctx);
+				}
+			}
+		}
+		return;
+	});
+
+	pi.on("context", (event) => {
+		const filteredExecution = filterExecutionResumeMessages(event.messages as Array<{ customType?: string }>);
+		const messages = filterPlanningResumeMessages(filteredExecution);
+		if (messages.length !== event.messages.length) {
+			return { messages };
+		}
+	});
+
+	pi.on("session_before_compact", async (event, ctx) => {
+		const executionResult = await handleExecutionBeforeCompact(pi, ctx, event);
+		if (executionResult) return executionResult;
+		return handlePlanningBeforeCompact(pi, ctx, event);
+	});
+	pi.on("session_compact", async (event, ctx) => {
+		handleExecutionCompact(pi, ctx, event);
+		handlePlanningCompact(pi, ctx, event);
+	});
+	pi.on("session_compact_failed", async (event, ctx) => {
+		handleExecutionCompactFailed(pi, ctx, event);
+		handlePlanningCompactFailed(pi, ctx, event);
+	});
+
+	// Flush points for deferred execution-loop writes: primary drain when the
+	// agent run fully settles, backstop drain at the next run's start (covers
+	// continuation paths that might not emit agent_settled), plus the forced
+	// synchronous flush inside stop/complete.
+	pi.on("agent_settled", async (_event, ctx) => {
+		drainExecutionFlush(pi, ctx);
 	});
 
 	// -----------------------------------------------------------------------
 	// Execution loop: inject remaining checklist each turn, track markers.
 	// -----------------------------------------------------------------------
-	pi.on("before_agent_start", async () => {
+	pi.on("before_agent_start", async (_event, ctx) => {
+		drainExecutionFlush(pi, ctx);
 		const content = executionContextMessage();
-		if (!content) return;
+		if (!content) {
+			if (!getExecution() && shouldTriggerPlanningCompaction(ctx)) {
+				requestPlanningCompaction(ctx);
+			}
+			return;
+		}
 		return {
 			message: {
 				customType: "pi-plans-exec-context",
@@ -139,58 +213,27 @@ export default function piPlansExtension(pi: ExtensionAPI): void {
 		};
 	});
 
-	// The turn_end projection does not carry usage; message_end delivers the
-	// full assistant message, so we cache it there and consume it per turn.
-	let lastAssistantUsage: { input: number; output: number } | null = null;
-	pi.on("message_end", async (event) => {
-		const message = event.message as { role?: string; usage?: { input?: number; output?: number } };
-		if (message?.role === "assistant" && message.usage) {
-			lastAssistantUsage = { input: message.usage.input ?? 0, output: message.usage.output ?? 0 };
-		}
-	});
-
-	pi.on("turn_end", async (event, ctx) => {
-		const message = event.message as { role?: string; content?: Array<{ type: string; text?: string }> };
-		if (!message || message.role !== "assistant") {
-			updateStatusWidget(ctx);
-			return;
-		}
-		const text = (message.content ?? [])
-			.filter((part) => part.type === "text")
-			.map((part) => part.text ?? "")
-			.join("\n");
-		const changedIds = applyDoneMarkers(text);
-		if (changedIds.length > 0) {
-			// Attribute this turn's token usage to the finished items.
-			const projection = (event.message as { usage?: { input?: number; output?: number } }).usage;
-			const raw = projection ?? lastAssistantUsage;
-			lastAssistantUsage = null; // consumed: never re-attribute a stale turn
-			const usage = raw ? { input: raw.input ?? 0, output: raw.output ?? 0 } : undefined;
-			recordExecutionCompletion(pi, ctx, changedIds, usage);
-		}
-		if (getExecution() && isExecutionComplete()) {
-			completeExecution(pi, ctx);
+	registerExecutionTurnHandlers(pi, async (ctx) => {
+		if (getExecution()) {
+			handleExecutionTurnCompaction(ctx);
+		} else {
+			refreshPlanningCompactionCooldown(ctx);
+			if (consumePlanningCompactionResumeGuard(ctx)) {
+				updateStatusWidget(ctx);
+				return;
+			}
+			if (shouldTriggerPlanningCompaction(ctx)) {
+				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",
@@ -215,19 +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");
 		},
 	});
 
@@ -264,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
@@ -292,7 +334,7 @@ export default function piPlansExtension(pi: ExtensionAPI): void {
 					`${doneIds.length}/${execution.items.length} verifier item(s) already verified; their work stays. Remaining items return to planning.`,
 				);
 				if (!ok) return;
-				stopExecution(pi, ctx, "interrupted by /update-plan");
+				await stopExecution(pi, ctx, "interrupted by /update-plan");
 			}
 
 			// Return the run to planning so refinement rules and guards apply again.
@@ -353,7 +395,7 @@ export default function piPlansExtension(pi: ExtensionAPI): void {
 			}
 			const ok = await ctx.ui.confirm("Stop execution?", "Remaining verifier items will be left unfinished.");
 			if (!ok) return;
-			stopExecution(pi, ctx, "stopped by user via /plans-stop");
+			await stopExecution(pi, ctx, "stopped by user via /plans-stop");
 			ctx.ui.notify("Execution stopped.", "info");
 		},
 	});
@@ -371,6 +413,11 @@ export default function piPlansExtension(pi: ExtensionAPI): void {
 				`${active.run_id}\nThe read-only guard lifts; committed artifacts stay in place.`,
 			);
 			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");
+			}
 			try {
 				setRunStatus(ctx.cwd, active.run_id, "abandoned");
 				ctx.ui.notify(`Run ${active.run_id} abandoned.`, "info");
@@ -385,6 +432,7 @@ export default function piPlansExtension(pi: ExtensionAPI): void {
 	// Session lifecycle
 	// -----------------------------------------------------------------------
 	pi.on("session_start", async (_event, ctx) => {
-		restoreFromSession(pi, ctx, ctx.sessionManager.getEntries() as unknown as Parameters<typeof restoreFromSession>[2]);
+		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.1",
+  "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;