@fyeeme/pi-goal 1.0.3 → 1.0.5

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## [Unreleased]
 
+## [1.0.5] - 2026-10-02
+
+### Changed
+
+- Relaxed the `@earendil-works/pi-agent-core` peer dependency from exact `0.99.2` to `>=0.99.0`, matching the other peer floors.
+- Dev toolchain pinned to `@earendil-works/pi-agent-core`/`pi-ai`/`pi-coding-agent`/`pi-tui` 1.0.0; typecheck and tests pass against 1.0.0 unchanged.
+
+## [1.0.4] - 2026-10-01
+
 ### Added
 
 - Objective length cap (`MAX_OBJECTIVE_CHARS`, 4,000 code points) enforced by the runtime on `create` and `replace` — the objective is re-injected into context on every continuation and passed to the evaluator subprocess, so an oversized one silently burns budget every turn; the error guides long instructions into a referenced file. Counting is code-point-based, not UTF-16 units. (Borrowed from mitsuhiko/agent-stuff `extensions/goal.ts`.)
@@ -16,6 +25,7 @@
 
 - Context hygiene: hidden goal messages no longer accumulate in the LLM's view. A `context` handler keeps only the newest `goal-mode-context` and `goal-budget-limit` messages plus the newest `goal-continuation` stamped for the currently active goal id (`details.goalId`); stale ones — including all continuations once no goal is active — are dropped from the model's view, not from the transcript. (Borrowed from mitsuhiko/agent-stuff `extensions/goal.ts`.)
 - Run-error handling: when a run ends with an assistant `stopReason: "error"`, the active goal now pauses (persisted) instead of letting the continuation loop fire into a likely retry loop, with a classified notice — provider usage/rate/quota/limit errors read differently from generic faults. Abort behavior is unchanged. (Borrowed from mitsuhiko/agent-stuff `extensions/goal.ts`.)
+- Peer dependency floor raised to `@earendil-works/pi-coding-agent >= 0.99.0`; dev toolchain pinned to 0.99.2 (typecheck and tests pass against 0.99.2 unchanged).
 
 ## [1.0.2] - 2026-09-16
 

package/index.ts

@@ -27,12 +27,18 @@
  *   goal_updated session event             → pi.events.emit("goal_updated")
  *   sendHiddenMessage (budget steer)       → pi.sendMessage display:false
  *   prompt-time prependMessages goal context
- *                                          → before_agent_start message
- *                                            injection (hidden custom message)
+ *                                          → context_with_system per-request
+ *                                            injection (0.87.0): survives
+ *                                            compaction, supersedes transcript
+ *                                            copies instead of accumulating
  *   #scheduleGoalContinuation 800ms TUI timer
- *                                          → followUp delivery + triggerTurn
- *                                            (editor-empty guard dropped: pi
- *                                            extensions cannot read the editor)
+ *                                          → agent_before_settle actionable
+ *                                            boundary (0.87.0):
+ *                                            { entries: [continuation draft],
+ *                                              continue: true } — exactly one
+ *                                            next provider request; sendMessage
+ *                                            fallback kept for continuations
+ *                                            withheld after settlement
  *   setActiveToolsByName                   → pi.setActiveTools
  *   status-line segment                    → ctx.ui.setStatus("goal", ...)
  *   settings goal.enabled / continuationModes / statusInFooter
@@ -59,7 +65,12 @@
 import { readFileSync } from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type {
+	ContextEditEntryDraft,
+	ExtensionAPI,
+	ExtensionContext,
+	SessionBoundaryDraft,
+} from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import {
 	createGoalCommand,
@@ -105,6 +116,34 @@ interface EntryUsageLike {
 	usage?: EntryMessageLike["usage"];
 }
 
+/** Budget slimming drafts (opt-in via PI_GOAL_SLIM_ON_BUDGET=1, attached once
+ *  per goal at the budget-limited flip): omit toolResult entries that precede
+ *  the newest real user message from future provider context via append-only
+ *  context-edit drafts — superseded turns' work products. Raw history, usage
+ *  and UI history stay untouched (context_edit contract). Pure: returns the
+ *  drafts; the settle boundary attaches them. */
+export function contextSlimDrafts(branch: unknown[]): ContextEditEntryDraft[] {
+	const drafts: ContextEditEntryDraft[] = [];
+	let keepFrom = -1;
+	for (let i = branch.length - 1; i >= 0; i--) {
+		const entry = branch[i] as { type?: string; message?: { role?: string } } | undefined;
+		if (entry?.type === "message" && entry.message?.role === "user") {
+			keepFrom = i;
+			break;
+		}
+	}
+	if (keepFrom <= 0) return drafts;
+	const seen = new Set<string>();
+	for (let i = 0; i < keepFrom; i++) {
+		const entry = branch[i] as { type?: string; id?: string; message?: { role?: string } } | undefined;
+		if (entry?.type !== "message" || entry.message?.role !== "toolResult") continue;
+		if (!entry.id || seen.has(entry.id)) continue;
+		seen.add(entry.id);
+		drafts.push({ type: "context_edit", targetId: entry.id, replacement: null });
+	}
+	return drafts;
+}
+
 export default function piGoalExtension(pi: ExtensionAPI): void {
 	// ------------------------------------------------------------------
 	// Closure state (omp session fields)
@@ -126,6 +165,10 @@ export default function piGoalExtension(pi: ExtensionAPI): void {
 	/** A blocking ctx.ui dialog is open (ui_prompt_start/end). While open, no
 	 *  continuation may fire: the modal would hide a turn starting behind it. */
 	let uiPromptOpen = false;
+	/** Goal id whose budget-limited flip already armed context slimming. */
+	let slimmedBudgetGoalId: string | undefined;
+	/** Context-slimming drafts pending attachment at the next settle boundary. */
+	let pendingSlim = false;
 
 	// ------------------------------------------------------------------
 	// Usage accounting (mirror of pi getSessionStats().tokens sums)
@@ -257,6 +300,14 @@ export default function piGoalExtension(pi: ExtensionAPI): void {
 			return;
 		}
 		goalState = state;
+		if (
+			state?.goal.status === "budget-limited" &&
+			process.env.PI_GOAL_SLIM_ON_BUDGET === "1" &&
+			slimmedBudgetGoalId !== state.goal.id
+		) {
+			slimmedBudgetGoalId = state.goal.id;
+			pendingSlim = true;
+		}
 		if (!state?.enabled) {
 			continuationInFlight = false;
 		}
@@ -416,7 +467,9 @@ export default function piGoalExtension(pi: ExtensionAPI): void {
 		return renderTemplate(goalModeContextPrompt, { goalContext: content, todoContext });
 	}
 
-	/** omp #scheduleGoalContinuation (TUI timer replaced by followUp delivery). */
+	/** omp #scheduleGoalContinuation. Post-settlement fallback path only: the
+	 *  primary continuation decision lives in the agent_before_settle boundary
+	 *  below (0.87.0). */
 	function scheduleContinuation(): void {
 		if (!goalState?.enabled || goalState.goal.status !== "active") return;
 		if (suppressNextContinuation) return;
@@ -433,6 +486,26 @@ export default function piGoalExtension(pi: ExtensionAPI): void {
 		);
 	}
 
+	/** omp #scheduleGoalContinuation decision chain, settled into a draft:
+	 *  guards pass → one custom_message draft carrying the continuation
+	 *  prompt (details.goalId keys context pruning). */
+	function continuationDraft(ctx: ExtensionContext): SessionBoundaryDraft | undefined {
+		if (!goalState?.enabled || goalState.goal.status !== "active") return undefined;
+		if (suppressNextContinuation) return undefined;
+		if (uiPromptOpen) return undefined; // modal open: never start a turn behind it
+		if (ctx.hasPendingMessages()) return undefined;
+		const prompt = runtime.buildContinuationPrompt();
+		if (!prompt) return undefined;
+		continuationInFlight = true;
+		return {
+			type: "custom_message",
+			customType: "goal-continuation",
+			content: prompt,
+			display: false,
+			details: { goalId: goalState.goal.id },
+		};
+	}
+
 	// ------------------------------------------------------------------
 	// Tool + command registration
 	// ------------------------------------------------------------------
@@ -584,13 +657,25 @@ export default function piGoalExtension(pi: ExtensionAPI): void {
 		}
 	});
 
-	pi.on("before_agent_start", (_event, ctx) => {
+	// Goal context injection (0.87.0 context_with_system): runs after `context`
+	// handlers on the full transcript including system messages; the result is
+	// sent verbatim. Per-request injection survives compaction (re-applied every
+	// call) and the fresh copy supersedes any steer-injected transcript copies.
+	pi.on("context_with_system", (event, ctx) => {
 		currentCtx = ctx;
 		const content = buildGoalModeMessage();
 		if (!content) return undefined;
-		return {
-			message: { customType: "goal-mode-context", content, display: false },
-		};
+		const messages = event.messages.filter((message) => {
+			const msg = message as { role?: string; customType?: string } | undefined;
+			return !(msg?.role === "custom" && msg.customType === "goal-mode-context");
+		});
+		messages.push({
+			role: "custom",
+			customType: "goal-mode-context",
+			content,
+			display: false,
+		} as (typeof event.messages)[number]);
+		return { messages };
 	});
 
 	// Context hygiene (borrowed from mitsuhiko/agent-stuff goal.ts): hidden goal
@@ -649,7 +734,31 @@ export default function piGoalExtension(pi: ExtensionAPI): void {
 			return;
 		}
 		updateStatus();
-		scheduleContinuation();
+	});
+
+	// omp #scheduleGoalContinuation migrated to the 0.87.0 actionable boundary:
+	// at settle time decide ONCE whether exactly one more provider request
+	// should run, attaching the continuation prompt as a custom_message draft.
+	// No timer, no followUp scheduling — pi owns the request. Guards mirror the
+	// old scheduleContinuation chain; continuations withheld after settlement
+	// (modal closed late, budget set while idle) still recover via the
+	// sendMessage fallback in scheduleContinuation().
+	pi.on("agent_before_settle", (_event, ctx) => {
+		currentCtx = ctx;
+		// Context slimming (opt-in): attach pending context_edit drafts first —
+		// they persist even when the continuation itself is withheld.
+		const drafts: SessionBoundaryDraft[] = [];
+		if (pendingSlim) {
+			pendingSlim = false;
+			drafts.push(...contextSlimDrafts(ctx.sessionManager.getBranch()));
+		}
+		const continuation = continuationDraft(ctx);
+		if (continuation) drafts.push(continuation);
+		if (drafts.length === 0) return undefined;
+		// Absent `continue` = no opinion on auto-continuation (budget-limited
+		// goals settle without one); `continue: true` guarantees exactly one
+		// next provider request.
+		return continuation !== undefined ? { entries: drafts, continue: true } : { entries: drafts };
 	});
 
 	pi.on("turn_end", (_event, ctx) => {

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@fyeeme/pi-goal",
-	"version": "1.0.3",
-	"description": "Goal mode for pi \u2014 one persistent autonomous objective looped until verified success: goal tool (create/get/complete/resume/drop), token/time budget accounting with budget-limit steering, automatic continuation turns, /goal and /guided-goal commands, and a goal_updated event bus for other extensions.",
+	"version": "1.0.5",
+	"description": "Goal mode for pi — one persistent autonomous objective looped until verified success: goal tool (create/get/complete/resume/drop), token/time budget accounting with budget-limit steering, automatic continuation turns, /goal and /guided-goal commands, and a goal_updated event bus for other extensions.",
 	"type": "module",
 	"license": "MIT",
 	"author": "fyeeme",
@@ -47,17 +47,17 @@
 		"typecheck": "tsc"
 	},
 	"peerDependencies": {
-		"@earendil-works/pi-ai": ">=0.84.4",
-		"@earendil-works/pi-coding-agent": ">=0.84.4",
-		"@earendil-works/pi-tui": ">=0.84.4",
+		"@earendil-works/pi-ai": ">=0.99.0",
+		"@earendil-works/pi-coding-agent": ">=0.99.0",
+		"@earendil-works/pi-tui": ">=0.99.0",
 		"typebox": ">=1.0.0",
-		"@earendil-works/pi-agent-core": "0.84.4"
+		"@earendil-works/pi-agent-core": ">=0.99.0"
 	},
 	"devDependencies": {
-		"@earendil-works/pi-agent-core": "0.84.4",
-		"@earendil-works/pi-ai": "0.84.4",
-		"@earendil-works/pi-coding-agent": "0.84.4",
-		"@earendil-works/pi-tui": "0.84.4",
+		"@earendil-works/pi-agent-core": "1.0.0",
+		"@earendil-works/pi-ai": "1.0.0",
+		"@earendil-works/pi-coding-agent": "1.0.0",
+		"@earendil-works/pi-tui": "1.0.0",
 		"@types/node": "22.19.19",
 		"typescript": "5.9.3",
 		"vitest": "3.2.7"

package/test/index.test.ts

@@ -152,6 +152,19 @@ async function fire(host: FakeHost, event: string, payload: unknown, ctx?: unkno
 	}
 }
 
+/** Fire agent_before_settle and return its boundary result. */
+function fireBeforeSettle(
+	host: FakeHost,
+	ctx?: unknown,
+): { continue?: boolean; entries?: Array<{ type: string; customType?: string; details?: unknown }> } | undefined {
+	const list = host.handlers.get("agent_before_settle") ?? [];
+	let result: unknown;
+	for (const handler of list) {
+		result = handler({ type: "agent_before_settle" }, ctx ?? createContext(host));
+	}
+	return result as { continue?: boolean; entries?: Array<{ type: string; customType?: string; details?: unknown }> } | undefined;
+}
+
 function fireBus(host: FakeHost, channel: string, data: unknown): void {
 	for (const handler of host.busHandlers.get(channel) ?? []) {
 		handler(data);
@@ -268,30 +281,52 @@ describe("pi-goal extension wiring", () => {
 		expect(host.statuses.get("goal")).toBe("🎯 Goal 0");
 	});
 
-	it("before_agent_start injects the hidden goal-mode-context message only while a goal is active", async () => {
+	it("context_with_system injects the goal-mode-context message only while a goal is active", async () => {
 		const host = fakeHost();
 		defaultExport(host.pi);
 		await fire(host, "session_start", { type: "session_start", reason: "startup" });
 
-		let result: unknown;
-		const handler = host.handlers.get("before_agent_start")?.[0];
-		result = await handler!({ prompt: "hi", systemPrompt: "" }, createContext(host));
+		const handler = host.handlers.get("context_with_system")?.[0]!;
+		const transcript = [{ role: "user", content: "hi" }];
+		let result = (await handler({ type: "context_with_system", messages: transcript }, createContext(host))) as
+			| { messages: Array<{ customType?: string; content?: string }> }
+			| undefined;
 		expect(result).toBeUndefined();
 
 		await host.commands.goal!.handler("Do the thing", createContext(host));
-		result = await handler!({ prompt: "hi", systemPrompt: "" }, createContext(host));
-		expect(result).toMatchObject({ message: { customType: "goal-mode-context", display: false } });
-		const content = (result as { message: { content: string } }).message.content;
-		expect(content).toContain("<goal_context>");
-		expect(content).toContain("Do the thing");
+		result = (await handler({ type: "context_with_system", messages: transcript }, createContext(host))) as
+			| { messages: Array<{ customType?: string; content?: string }> }
+			| undefined;
+		const contexts = result!.messages.filter((m) => m.customType === "goal-mode-context");
+		expect(contexts).toHaveLength(1);
+		expect(contexts[0]?.content).toContain("<goal_context>");
+		expect(contexts[0]?.content).toContain("Do the thing");
 	});
 
-	it("agent_end schedules a continuation when the goal is still active", async () => {
+	it("context_with_system supersedes steer-injected transcript copies (single fresh context)", async () => {
+		const host = fakeHost();
+		defaultExport(host.pi);
+		await fire(host, "session_start", { type: "session_start", reason: "startup" });
+		await host.commands.goal!.handler("Do the thing", createContext(host));
+
+		const handler = host.handlers.get("context_with_system")?.[0]!;
+		const transcript = [
+			{ role: "user", content: "hi" },
+			{ role: "custom", customType: "goal-mode-context", content: "stale copy", display: false },
+		];
+		const result = (await handler({ type: "context_with_system", messages: transcript }, createContext(host))) as {
+			messages: Array<{ customType?: string; content?: string }>;
+		};
+		const contexts = result.messages.filter((m) => m.customType === "goal-mode-context");
+		expect(contexts).toHaveLength(1);
+		expect(contexts[0]?.content).not.toBe("stale copy");
+	});
+
+	it("agent_before_settle continues exactly one request when the goal is still active", async () => {
 		const host = fakeHost();
 		defaultExport(host.pi);
 		await fire(host, "session_start", { type: "session_start", reason: "startup" });
 		await host.commands.goal!.handler("Do the thing", createContext(host));
-		host.sentMessages.length = 0;
 
 		await fire(host, "agent_start", { type: "agent_start" });
 		await fire(host, "tool_execution_end", {
@@ -303,13 +338,16 @@ describe("pi-goal extension wiring", () => {
 		});
 		await fire(host, "agent_end", { type: "agent_end", messages: [assistantMessage("toolUse")] });
 
-		const continuation = host.sentMessages.find((m) => m.customType === "goal-continuation");
-		expect(continuation).toBeDefined();
-		expect(continuation?.display).toBe(false);
-		expect(continuation?.options).toMatchObject({ triggerTurn: true, deliverAs: "followUp" });
+		const result = fireBeforeSettle(host);
+		expect(result?.continue).toBe(true);
+		// The continuation prompt rides as a custom_message draft.
+		const draft = result?.entries?.[0];
+		expect(draft).toMatchObject({ type: "custom_message", customType: "goal-continuation", display: false });
 		// details.goalId keys the context-pruning handler.
 		const goalId = (host.entries.find((e) => e.customType === GOAL_STATE_ENTRY_TYPE)?.data as { goal: Goal }).goal.id;
-		expect(continuation?.details).toMatchObject({ goalId });
+		expect(draft?.details).toMatchObject({ goalId });
+		// The boundary path sends no followUp message.
+		expect(host.sentMessages.filter((m) => m.customType === "goal-continuation")).toHaveLength(0);
 	});
 
 	it("suppresses the next continuation when a continuation turn produced no tool calls", async () => {
@@ -317,18 +355,16 @@ describe("pi-goal extension wiring", () => {
 		defaultExport(host.pi);
 		await fire(host, "session_start", { type: "session_start", reason: "startup" });
 		await host.commands.goal!.handler("Do the thing", createContext(host));
-		host.sentMessages.length = 0;
 
 		// Continuation turn: agent replies with no tool calls.
 		await fire(host, "agent_start", { type: "agent_start" });
 		await fire(host, "agent_end", { type: "agent_end", messages: [assistantMessage("stop")] });
-		expect(host.sentMessages.filter((m) => m.customType === "goal-continuation")).toHaveLength(1);
+		expect(fireBeforeSettle(host)?.continue).toBe(true);
 
-		// That turn's end marks suppression: the following end schedules nothing.
-		host.sentMessages.length = 0;
+		// That turn's end marks suppression: the following settle continues nothing.
 		await fire(host, "agent_start", { type: "agent_start" });
 		await fire(host, "agent_end", { type: "agent_end", messages: [assistantMessage("stop")] });
-		expect(host.sentMessages.filter((m) => m.customType === "goal-continuation")).toHaveLength(0);
+		expect(fireBeforeSettle(host)?.continue).toBeUndefined();
 
 		// A real user message re-arms the loop.
 		await fire(host, "message_start", { type: "message_start", message: { role: "user" } });
@@ -340,9 +376,8 @@ describe("pi-goal extension wiring", () => {
 			result: {},
 			isError: false,
 		});
-		host.sentMessages.length = 0;
 		await fire(host, "agent_end", { type: "agent_end", messages: [assistantMessage("stop")] });
-		expect(host.sentMessages.filter((m) => m.customType === "goal-continuation")).toHaveLength(1);
+		expect(fireBeforeSettle(host)?.continue).toBe(true);
 	});
 
 	it("interrupt aborts pause the goal instead of continuing", async () => {
@@ -355,7 +390,7 @@ describe("pi-goal extension wiring", () => {
 		await fire(host, "agent_start", { type: "agent_start" });
 		await fire(host, "agent_end", { type: "agent_end", messages: [assistantMessage("aborted")] });
 
-		expect(host.sentMessages.filter((m) => m.customType === "goal-continuation")).toHaveLength(0);
+		expect(fireBeforeSettle(host)?.continue).toBeUndefined();
 		// omp footer segment: pause icon + usage.
 		expect(host.statuses.get("goal")).toBe("⏸ Goal 0");
 		const pauseEntry = [...host.entries].reverse().find((e) => e.customType === GOAL_STATE_ENTRY_TYPE);
@@ -380,7 +415,7 @@ describe("pi-goal extension wiring", () => {
 		expect(host.entries.some((e) => e.customType === GOAL_CLEARED_ENTRY_TYPE)).toBe(true);
 		expect(host.notifications).toContain("Goal mode completed.");
 		expect(host.statuses.has("goal")).toBe(false);
-		expect(host.sentMessages.filter((m) => m.customType === "goal-continuation")).toHaveLength(0);
+		expect(fireBeforeSettle(host)?.continue).toBeUndefined();
 	});
 
 	it("budget-limit steering sends one hidden steer message when usage crosses the budget", async () => {
@@ -443,6 +478,96 @@ describe("pi-goal extension wiring", () => {
 		expect(host.sentMessages.filter((m) => m.customType === "goal-budget-limit")).toHaveLength(0);
 	});
 
+	it("budget flip attaches context-slimming drafts when PI_GOAL_SLIM_ON_BUDGET=1", async () => {
+		const host = fakeHost();
+		defaultExport(host.pi);
+		await fire(host, "session_start", { type: "session_start", reason: "startup" });
+		await host.commands.goal!.handler("Do the thing", createContext(host));
+		await host.commands.goal!.handler("budget 10", createContext(host));
+
+		const entries: unknown[] = [
+			{ type: "message", id: "t-old", message: { role: "toolResult" } },
+			{ type: "message", id: "u1", message: { role: "user" } },
+			{ type: "message", id: "t-new", message: { role: "toolResult" } },
+		];
+		const ctx = createContext(host, { entries });
+
+		vi.stubEnv("PI_GOAL_SLIM_ON_BUDGET", "1");
+		await fire(host, "turn_start", { type: "turn_start", turnIndex: 0, timestamp: 0 }, ctx);
+		entries.push({
+			type: "message",
+			id: "m1",
+			message: { role: "assistant", stopReason: "toolUse", usage: { input: 25, output: 0, cacheRead: 0, cacheWrite: 0 } },
+		});
+		await fire(host, "tool_execution_end", {
+			type: "tool_execution_end",
+			toolCallId: "t1",
+			toolName: "read",
+			result: {},
+			isError: false,
+		}, ctx);
+
+		// Budget flip arms slimming; the boundary attaches the drafts.
+		// Budget-limited goals stop auto-continuing (omp semantics), so the
+		// boundary persists the edits without a next request.
+		const result = fireBeforeSettle(host, ctx);
+		expect(result?.continue).toBeUndefined();
+		const edits = (result?.entries ?? []).filter((e) => e.type === "context_edit");
+		expect(edits).toEqual([{ type: "context_edit", targetId: "t-old", replacement: null }]);
+
+		// Once per goal: the next settle carries no further slimming drafts.
+		entries.push({
+			type: "message",
+			id: "m2",
+			message: { role: "assistant", stopReason: "toolUse", usage: { input: 50, output: 0, cacheRead: 0, cacheWrite: 0 } },
+		});
+		await fire(host, "tool_execution_end", {
+			type: "tool_execution_end",
+			toolCallId: "t2",
+			toolName: "read",
+			result: {},
+			isError: false,
+		}, ctx);
+		expect(fireBeforeSettle(host, ctx)).toBeUndefined();
+		vi.unstubAllEnvs();
+	});
+
+	it("context slimming stays off by default (opt-in via PI_GOAL_SLIM_ON_BUDGET)", async () => {
+		const host = fakeHost();
+		defaultExport(host.pi);
+		await fire(host, "session_start", { type: "session_start", reason: "startup" });
+		await host.commands.goal!.handler("Do the thing", createContext(host));
+		await host.commands.goal!.handler("budget 10", createContext(host));
+
+		const entries: unknown[] = [
+			{ type: "message", id: "t-old", message: { role: "toolResult" } },
+			{ type: "message", id: "u1", message: { role: "user" } },
+			{ type: "message", id: "t-new", message: { role: "toolResult" } },
+		];
+		const ctx = createContext(host, { entries });
+
+		// Explicitly opt out (order-independent against leaking stubs).
+		vi.stubEnv("PI_GOAL_SLIM_ON_BUDGET", "");
+		await fire(host, "turn_start", { type: "turn_start", turnIndex: 0, timestamp: 0 }, ctx);
+		entries.push({
+			type: "message",
+			id: "m1",
+			message: { role: "assistant", stopReason: "toolUse", usage: { input: 25, output: 0, cacheRead: 0, cacheWrite: 0 } },
+		});
+		await fire(host, "tool_execution_end", {
+			type: "tool_execution_end",
+			toolCallId: "t1",
+			toolName: "read",
+			result: {},
+			isError: false,
+		}, ctx);
+
+		// Budget flip steers but arms no slimming drafts; budget-limited goals
+		// do not auto-continue, so the boundary settles empty.
+		expect(fireBeforeSettle(host, ctx)).toBeUndefined();
+		vi.unstubAllEnvs();
+	});
+
 	it("/guided-goal queues a hidden interview kickoff", async () => {
 		const host = fakeHost();
 		defaultExport(host.pi);
@@ -503,7 +628,8 @@ describe("pi-goal extension wiring", () => {
 
 		await fire(host, "agent_start", { type: "agent_start" });
 		await fire(host, "agent_end", { type: "agent_end", messages: [assistantMessage("stop")] });
-		expect(host.sentMessages.filter((m) => m.customType === "goal-continuation")).toHaveLength(0);
+		// Modal open at settle: the boundary withholds the continuation.
+		expect(fireBeforeSettle(host)?.continue).toBeUndefined();
 
 		// Dialog closes while idle: the withheld continuation is scheduled now.
 		const idleCtx = createContext(host, { idle: true });
@@ -532,7 +658,8 @@ describe("pi-goal extension wiring", () => {
 		expect(host.sentMessages.filter((m) => m.customType === "goal-continuation")).toHaveLength(0);
 
 		await fire(host, "agent_end", { type: "agent_end", messages: [assistantMessage("stop")] });
-		expect(host.sentMessages.filter((m) => m.customType === "goal-continuation")).toHaveLength(1);
+		// Modal already closed: the boundary itself continues the run.
+		expect(fireBeforeSettle(host)?.continue).toBe(true);
 	});
 
 	it("refreshes the status on agent_settled (status integrations per docs)", async () => {
@@ -667,7 +794,7 @@ describe("pi-goal extension wiring", () => {
 		const pauseEntry = [...host.entries].reverse().find((e) => e.customType === GOAL_STATE_ENTRY_TYPE);
 		expect(pauseEntry?.data).toMatchObject({ enabled: false, goal: { status: "paused" } });
 		expect(host.notifications.some((n) => n.includes("rate limits"))).toBe(true);
-		expect(host.sentMessages.filter((m) => m.customType === "goal-continuation")).toHaveLength(0);
+		expect(fireBeforeSettle(host)?.continue).toBeUndefined();
 	});
 
 	it("pauses with a generic notice on non-usage errors", async () => {