pi-plans 0.1.1 → 0.1.2

package/README.md

@@ -13,9 +13,11 @@
 <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="./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>
 
 ---
@@ -113,7 +115,10 @@ Planning artifacts live under `./docs/pi-plans/YYYY-MM-DD-<topic>/` by default (
 | 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 |
 | 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 |
+| 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 |
 | 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 |
 
@@ -121,16 +126,17 @@ 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-role`, `start-run`, `set-status`, `record-decision`, `record-ref`, `record-subagent` |
+| `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` |
 | `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 |
-| `/plans-execute [plan.md]` | Manual execution handoff (defaults to highest `PLAN_vN.md`) |
+| `execute_plan` | Execution handoff: re-confirms with the user, prompts for an execution model if needed, 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) |
 | `/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-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 collapsed footer or expanded panel → ⛔ stopped / 🎯 done / 🚫 abandoned |
 
 ## The execution rules
 

package/index.ts

@@ -19,19 +19,31 @@ 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,
+	handleExecutionBeforeCompact,
+	handleExecutionCompact,
+	handleExecutionCompactFailed,
+	handlePlanningBeforeCompact,
+	handlePlanningCompact,
+	handlePlanningCompactFailed,
+	PLANNING_PLAN_WRITTEN_CUSTOM_TYPE,
+	registerExecutionTurnHandlers,
 	recordTouchedPaths,
+	refreshPlanningCompactionCooldown,
+	requestPlanningCompaction,
 	restoreFromSession,
+	ensureExecutionModelActive,
 	stopExecution,
 	syncExecutionPanel,
 	toggleExecutionPanelView,
 	updateStatusWidget,
+	shouldTriggerPlanningCompaction,
 } from "./src/exec.ts";
 import { planningWriteBlockReason } from "./src/guard.ts";
 import { latestPlanVersion, nextPlanVersionPath } from "./src/plan.ts";
@@ -43,6 +55,31 @@ import { registerRefineTool } from "./tools/refine.ts";
 
 const baseDir = dirname(fileURLToPath(import.meta.url));
 
+// 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()}`;
+	}
+}
+
 function extractPathsFromBash(command: string): string[] {
 	const values = new Set<string>();
 	for (const token of command.split(/\s+/)) {
@@ -120,16 +157,67 @@ export default function piPlansExtension(pi: ExtensionAPI): void {
 		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") {
+			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,
+					});
+				}
+			}
+		}
+		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);
+		await ensureExecutionModelActive(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,37 +227,17 @@ 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()) {
+			refreshPlanningCompactionCooldown(ctx);
+			if (consumePlanningCompactionResumeGuard(ctx)) {
+				if (consumePendingPanelSync()) syncExecutionPanel(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.
@@ -215,6 +283,7 @@ export default function piPlansExtension(pi: ExtensionAPI): void {
 					lines.push(`  ${item.done ? "☑" : "☐"} ${item.id}`);
 				}
 			}
+			lines.push(extensionStalenessLine());
 			ctx.ui.notify(lines.join("\n"), "info");
 		},
 	});
@@ -292,7 +361,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 +422,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 +440,10 @@ 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.
+			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 +458,6 @@ 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]);
 	});
 }

package/package.json

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