gsd-pi 2.80.0-dev.96f4d89d5 → 2.80.0-dev.b0acf17e9

package/packages/pi-coding-agent/src/core/agent-session.ts

@@ -305,6 +305,8 @@ export class AgentSession {
 
 	// Base system prompt (without extension appends) - used to apply fresh appends each turn
 	private _baseSystemPrompt = "";
+	// Optional prompt-only skill catalog filter. Skills remain loaded and invocable by name.
+	private _visibleSkillNames: Set<string> | undefined = undefined;
 
 	constructor(config: AgentSessionConfig) {
 		this.agent = config.agent;
@@ -867,6 +869,25 @@ export class AgentSession {
 		this.agent.setSystemPrompt(this._baseSystemPrompt);
 	}
 
+	/**
+	 * Set or clear a prompt-only filter for the <available_skills> catalog.
+	 *
+	 * This does not unload skills or disable the Skill tool. It only controls
+	 * which loaded skills are advertised in the system prompt on rebuild.
+	 */
+	setVisibleSkillsByName(skillNames: string[] | undefined): void {
+		this._visibleSkillNames = skillNames === undefined
+			? undefined
+			: new Set(skillNames.map((name) => name.trim().toLowerCase()).filter(Boolean));
+		this._baseSystemPrompt = this._rebuildSystemPrompt(this.getActiveToolNames());
+		this.agent.setSystemPrompt(this._baseSystemPrompt);
+	}
+
+	/** Get the current prompt-only skill catalog filter, if one is active. */
+	getVisibleSkillNames(): string[] | undefined {
+		return this._visibleSkillNames ? [...this._visibleSkillNames] : undefined;
+	}
+
 	/** Whether compaction or branch summarization is currently running */
 	get isCompacting(): boolean {
 		return this._compactionOrchestrator.isCompacting;
@@ -1045,6 +1066,9 @@ export class AgentSession {
 		return buildSystemPrompt({
 			cwd: this._cwd,
 			skills: loadedSkills,
+			skillFilter: this._visibleSkillNames
+				? (skill) => this._visibleSkillNames!.has(skill.name.trim().toLowerCase())
+				: undefined,
 			contextFiles: loadedContextFiles,
 			customPrompt: loaderSystemPrompt,
 			appendSystemPrompt,
@@ -1626,6 +1650,11 @@ export class AgentSession {
 		// message_end/agent_end events fire while listeners are still connected.
 		// During agent_end handling the turn is already ending; aborting there can
 		// convert a successful auto-mode handoff into an aborted provider message.
+		if (!this.agent.state.isStreaming) {
+			this._retryHandler.abortRetry();
+			await this.agent.waitForIdle();
+			return;
+		}
 		await this.abort();
 	}
 
@@ -1640,6 +1669,8 @@ export class AgentSession {
 	async newSession(options?: {
 		parentSession?: string;
 		setup?: (sessionManager: SessionManager) => Promise<void>;
+		/** Explicit workspace root for the new session/tool runtime. */
+		workspaceRoot?: string;
 		/** See ExtensionCommandContext.newSession for docs (#3731). */
 		abortSignal?: AbortSignal;
 	}): Promise<boolean> {
@@ -1661,10 +1692,10 @@ export class AgentSession {
 		try {
 			await this._settleCurrentTurnForSessionTransition();
 
-			// #3731: If the caller aborted (e.g. runUnit() timed out and restored cwd to
-			// project root), discard this session before capturing process.cwd() and
-			// rebuilding the tool runtime. Without this check, the late newSession()
-			// would rebuild tools with root cwd, breaking worktree isolation.
+			// #3731: If the caller aborted (e.g. runUnit() timed out while the
+			// worktree was being torn down), discard this session before rebuilding
+			// the tool runtime. Without this check, the late newSession() could
+			// rebuild tools with a stale workspace root.
 			if (options?.abortSignal?.aborted) {
 				return false;
 			}
@@ -1674,15 +1705,18 @@ export class AgentSession {
 		} finally {
 			this._sessionSwitchPending = false;
 		}
-		// Update cwd to current process directory — auto-mode may have chdir'd
-		// into a worktree since the original session was created.
+		// Update the workspace root for the new tool runtime. Auto-mode passes
+		// this explicitly so session routing does not depend on global
+		// process.cwd() after worktree merge/teardown. Other callers keep the
+		// historical default.
 		const previousCwd = this._cwd;
-		this._cwd = process.cwd();
+		this._cwd = options?.workspaceRoot ?? process.cwd();
 		this.sessionManager.newSession({ parentSession: options?.parentSession });
 		this.agent.sessionId = this.sessionManager.getSessionId();
 		this._steeringMessages = [];
 		this._followUpMessages = [];
 		this._pendingNextTurnMessages = [];
+		this._visibleSkillNames = undefined;
 
 		this.sessionManager.appendThinkingLevelChange(this.thinkingLevel);
 
@@ -2180,6 +2214,8 @@ export class AgentSession {
 				getActiveTools: () => this.getActiveToolNames(),
 				getAllTools: () => this.getAllTools(),
 				setActiveTools: (toolNames) => this.setActiveToolsByName(toolNames),
+				getVisibleSkills: () => this.getVisibleSkillNames(),
+				setVisibleSkills: (skillNames) => this.setVisibleSkillsByName(skillNames),
 				refreshTools: () => this._refreshToolRegistry(),
 				getCommands,
 				setModel: async (model, options) => {
@@ -2211,6 +2247,9 @@ export class AgentSession {
 					})();
 				},
 				getSystemPrompt: () => this.systemPrompt,
+				setCompactionThresholdOverride: (percent) => {
+					this.settingsManager.setCompactionThresholdOverride(percent);
+				},
 			},
 		);
 	}
@@ -2345,6 +2384,7 @@ export class AgentSession {
 		this.settingsManager.reload();
 		resetApiProviders();
 		await this._resourceLoader.reload();
+		this._visibleSkillNames = undefined;
 		this._buildRuntime({
 			activeToolNames: this.getActiveToolNames(),
 			flagValues: previousFlagValues,
@@ -2534,6 +2574,7 @@ export class AgentSession {
 		this._steeringMessages = [];
 		this._followUpMessages = [];
 		this._pendingNextTurnMessages = [];
+		this._visibleSkillNames = undefined;
 
 		// Set new session
 		this.sessionManager.setSessionFile(sessionPath);

package/packages/pi-coding-agent/src/core/chat-controller-ordering.test.ts

@@ -1002,6 +1002,97 @@ test("chat-controller does not pin when there are no tool calls", async () => {
 	assert.equal(host.pinnedMessageContainer.children.length, 0, "pinned zone should stay empty without tool calls");
 });
 
+test("chat-controller rolls up only contiguous low-signal tool runs on message_end", async () => {
+	(globalThis as any)[Symbol.for("@gsd/pi-coding-agent:theme")] = {
+		fg: (_key: string, text: string) => text,
+		bg: (_key: string, text: string) => text,
+		bold: (text: string) => text,
+		italic: (text: string) => text,
+		truncate: (text: string) => text,
+	};
+
+	const host = createHost();
+	host.getMarkdownThemeWithSettings = () => ({});
+
+	const t1 = { type: "toolCall", id: "t1", name: "bash", arguments: { command: "true" } };
+	const t2 = { type: "toolCall", id: "t2", name: "bash", arguments: { command: "true" } };
+	const text = { type: "text", text: "middle output" };
+	const t3 = { type: "toolCall", id: "t3", name: "read", arguments: { path: "/tmp/a" } };
+	const t4 = { type: "toolCall", id: "t4", name: "read", arguments: { path: "/tmp/b" } };
+	const content = [t1, t2, text, t3, t4];
+
+	await handleAgentEvent(host, { type: "message_start", message: makeAssistant([]) } as any);
+	await handleAgentEvent(host, {
+		type: "message_update",
+		message: makeAssistant(content),
+		assistantMessageEvent: {
+			type: "text_delta",
+			contentIndex: 2,
+			delta: text.text,
+			partial: makeAssistant(content),
+		},
+	} as any);
+
+	for (const tool of [t1, t2, t3, t4]) {
+		await handleAgentEvent(host, {
+			type: "tool_execution_end",
+			toolCallId: tool.id,
+			isError: false,
+			result: { content: [], details: {} },
+		} as any);
+	}
+
+	await handleAgentEvent(host, { type: "message_end", message: makeAssistant(content) } as any);
+
+	assert.equal(host.chatContainer.children.length, 3, "two separated tool runs should become two summaries around text");
+	assert.equal(host.chatContainer.children[0]?.constructor?.name, "ToolPhaseSummaryComponent");
+	assert.equal(host.chatContainer.children[1]?.constructor?.name, "AssistantMessageComponent");
+	assert.equal(host.chatContainer.children[2]?.constructor?.name, "ToolPhaseSummaryComponent");
+	assert.match(host.chatContainer.children[0].render(120).join("\n"), /Setup \/ shell 2 actions/);
+	const readSummary = host.chatContainer.children[2].render(120).join("\n");
+	assert.match(readSummary, /Context reads · 2 files/);
+	assert.match(readSummary, /\/tmp\/a · \/tmp\/b/);
+	assert.equal(host.chatContainer._prevRender, null, "summary reposition must invalidate the chat container render cache");
+});
+
+test("chat-controller rolls up low-signal direct tool execution events on agent_end", async () => {
+	(globalThis as any)[Symbol.for("@gsd/pi-coding-agent:theme")] = {
+		fg: (_key: string, text: string) => text,
+		bg: (_key: string, text: string) => text,
+		bold: (text: string) => text,
+		italic: (text: string) => text,
+		truncate: (text: string) => text,
+	};
+
+	const host = createHost();
+	host.getMarkdownThemeWithSettings = () => ({});
+
+	for (const toolCallId of ["bash-1", "bash-2", "bash-3"]) {
+		await handleAgentEvent(host, {
+			type: "tool_execution_start",
+			toolCallId,
+			toolName: "bash",
+			args: { command: "true" },
+		} as any);
+		await handleAgentEvent(host, {
+			type: "tool_execution_end",
+			toolCallId,
+			isError: false,
+			result: { content: [], details: {} },
+		} as any);
+	}
+
+	assert.equal(host.chatContainer.children.length, 1, "direct tool events roll up as they finish");
+	assert.equal(host.chatContainer.children[0]?.constructor?.name, "ToolPhaseSummaryComponent");
+	assert.match(host.chatContainer.children[0].render(120).join("\n"), /Setup \/ shell 3 actions/);
+
+	await handleAgentEvent(host, { type: "agent_end" } as any);
+
+	assert.equal(host.chatContainer.children.length, 1, "direct low-signal tool rows should roll up on agent_end");
+	assert.equal(host.chatContainer.children[0]?.constructor?.name, "ToolPhaseSummaryComponent");
+	assert.match(host.chatContainer.children[0].render(120).join("\n"), /Setup \/ shell 3 actions/);
+});
+
 // Regression test for issue #4144: interleaved text/tool content must render in content[] index order.
 // Stream: [text "A", toolCall T1, text "B", toolCall T2, text "C"]
 // Expected chatContainer order: textRun(A), toolExec(T1), textRun(B), toolExec(T2), textRun(C)

package/packages/pi-coding-agent/src/core/compaction/compaction.ts

@@ -86,6 +86,13 @@ export interface CompactionSettings {
 	enabled: boolean;
 	reserveTokens: number;
 	keepRecentTokens: number;
+	/**
+	 * Optional percent-of-context-window threshold (0 < value < 1). When set,
+	 * `shouldCompact()` fires once `contextTokens > contextWindow * thresholdPercent`,
+	 * overriding the absolute `reserveTokens` calculation. Lets host integrations
+	 * (e.g. GSD) express compaction policy as a fraction independent of model size.
+	 */
+	thresholdPercent?: number;
 }
 
 export const DEFAULT_COMPACTION_SETTINGS: CompactionSettings = {
@@ -185,9 +192,20 @@ export function estimateContextTokens(messages: AgentMessage[]): ContextUsageEst
 
 /**
  * Check if compaction should trigger based on context usage.
+ *
+ * When `thresholdPercent` is set (and within (0, 1)), it overrides the absolute
+ * `reserveTokens` calculation: compaction fires at `contextWindow * thresholdPercent`.
+ * Otherwise the legacy `contextWindow - reserveTokens` headroom is used.
  */
 export function shouldCompact(contextTokens: number, contextWindow: number, settings: CompactionSettings): boolean {
 	if (!settings.enabled) return false;
+	if (
+		settings.thresholdPercent !== undefined &&
+		settings.thresholdPercent > 0 &&
+		settings.thresholdPercent < 1
+	) {
+		return contextTokens > contextWindow * settings.thresholdPercent;
+	}
 	return contextTokens > contextWindow - settings.reserveTokens;
 }
 

package/packages/pi-coding-agent/src/core/compaction-threshold.test.ts

@@ -0,0 +1,121 @@
+// pi-coding-agent / Regression tests for compaction threshold percent (#5475)
+
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import { shouldCompact, type CompactionSettings } from "./compaction/compaction.js";
+import { SettingsManager } from "./settings-manager.js";
+
+const REGISTRY_DEFAULTS: CompactionSettings = {
+	enabled: true,
+	reserveTokens: 16_384,
+	keepRecentTokens: 20_000,
+};
+
+describe("shouldCompact — thresholdPercent (#5475)", () => {
+	it("uses absolute reserveTokens when thresholdPercent is unset (legacy behavior)", () => {
+		// 200K window, 16384 reserve → fires at 183_617 tokens
+		assert.equal(shouldCompact(183_616, 200_000, REGISTRY_DEFAULTS), false);
+		assert.equal(shouldCompact(183_617, 200_000, REGISTRY_DEFAULTS), true);
+	});
+
+	it("uses thresholdPercent when set, ignoring reserveTokens", () => {
+		const settings: CompactionSettings = { ...REGISTRY_DEFAULTS, thresholdPercent: 0.7 };
+		// 200K * 0.7 = 140_000 → fires above that
+		assert.equal(shouldCompact(140_000, 200_000, settings), false);
+		assert.equal(shouldCompact(140_001, 200_000, settings), true);
+		// reserveTokens-based math would have said false at 183_616 — the percent override changes that
+		assert.equal(shouldCompact(150_000, 200_000, settings), true);
+	});
+
+	it("falls back to reserveTokens when thresholdPercent is out of range", () => {
+		// Defense in depth: reject 0, 1, negative, NaN, Infinity
+		for (const bad of [0, 1, -0.1, 1.5, Number.NaN, Number.POSITIVE_INFINITY]) {
+			const settings: CompactionSettings = { ...REGISTRY_DEFAULTS, thresholdPercent: bad };
+			assert.equal(
+				shouldCompact(183_616, 200_000, settings),
+				false,
+				`bad=${bad} should fall back to reserveTokens math`,
+			);
+			assert.equal(shouldCompact(183_617, 200_000, settings), true, `bad=${bad}`);
+		}
+	});
+
+	it("respects enabled=false regardless of thresholdPercent", () => {
+		const settings: CompactionSettings = {
+			...REGISTRY_DEFAULTS,
+			enabled: false,
+			thresholdPercent: 0.5,
+		};
+		assert.equal(shouldCompact(199_999, 200_000, settings), false);
+	});
+
+	it("scales with contextWindow — same percent, different windows", () => {
+		const settings: CompactionSettings = { ...REGISTRY_DEFAULTS, thresholdPercent: 0.8 };
+		// 100K window: fires above 80_000
+		assert.equal(shouldCompact(80_000, 100_000, settings), false);
+		assert.equal(shouldCompact(80_001, 100_000, settings), true);
+		// 1M window: fires above 800_000
+		assert.equal(shouldCompact(800_000, 1_000_000, settings), false);
+		assert.equal(shouldCompact(800_001, 1_000_000, settings), true);
+	});
+});
+
+describe("SettingsManager — compaction threshold override (#5475)", () => {
+	it("getCompactionThresholdPercent returns undefined by default", () => {
+		const sm = SettingsManager.inMemory({});
+		assert.equal(sm.getCompactionThresholdPercent(), undefined);
+		assert.equal(sm.getCompactionSettings().thresholdPercent, undefined);
+	});
+
+	it("setCompactionThresholdOverride applies in-memory and is exposed via getCompactionSettings", () => {
+		const sm = SettingsManager.inMemory({});
+		sm.setCompactionThresholdOverride(0.7);
+		assert.equal(sm.getCompactionThresholdPercent(), 0.7);
+		assert.equal(sm.getCompactionSettings().thresholdPercent, 0.7);
+	});
+
+	it("setCompactionThresholdOverride(undefined) clears a prior override", () => {
+		const sm = SettingsManager.inMemory({});
+		sm.setCompactionThresholdOverride(0.7);
+		sm.setCompactionThresholdOverride(undefined);
+		assert.equal(sm.getCompactionThresholdPercent(), undefined);
+		assert.equal(sm.getCompactionSettings().thresholdPercent, undefined);
+	});
+
+	it("setCompactionThresholdOverride preserves other compaction fields (enabled, reserveTokens)", () => {
+		const sm = SettingsManager.inMemory({
+			compaction: { enabled: true, reserveTokens: 30_000, keepRecentTokens: 25_000 },
+		});
+		sm.setCompactionThresholdOverride(0.6);
+		const settings = sm.getCompactionSettings();
+		assert.equal(settings.enabled, true);
+		assert.equal(settings.reserveTokens, 30_000);
+		assert.equal(settings.keepRecentTokens, 25_000);
+		assert.equal(settings.thresholdPercent, 0.6);
+	});
+
+	it("setCompactionThresholdOverride works when no compaction config exists yet", () => {
+		const sm = SettingsManager.inMemory({});
+		sm.setCompactionThresholdOverride(0.85);
+		assert.equal(sm.getCompactionThresholdPercent(), 0.85);
+		// Other compaction fields fall back to their defaults
+		const settings = sm.getCompactionSettings();
+		assert.equal(settings.enabled, true);
+		assert.equal(typeof settings.reserveTokens, "number");
+		assert.equal(typeof settings.keepRecentTokens, "number");
+	});
+});
+
+describe("end-to-end — getCompactionSettings + shouldCompact (#5475)", () => {
+	it("70% threshold on a 200K window fires at the documented bug-report value (140_001 not 183_617)", () => {
+		const sm = SettingsManager.inMemory({});
+		sm.setCompactionThresholdOverride(0.7);
+		const settings = sm.getCompactionSettings();
+
+		assert.equal(shouldCompact(140_000, 200_000, settings), false);
+		assert.equal(shouldCompact(140_001, 200_000, settings), true);
+		// Pre-fix behavior would have required 183_617 — verify we no longer wait that long
+		assert.equal(shouldCompact(150_000, 200_000, settings), true);
+	});
+});

package/packages/pi-coding-agent/src/core/db-snapshot.test.ts

@@ -0,0 +1,32 @@
+import assert from "node:assert/strict";
+import { describe, it, afterEach } from "node:test";
+import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { atomicWriteDbSnapshotSync } from "./db-snapshot.js";
+
+describe("atomicWriteDbSnapshotSync", () => {
+	let dir: string;
+
+	afterEach(() => {
+		if (dir) {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("writes the full snapshot and leaves no temp file after success", () => {
+		dir = mkdtempSync(join(tmpdir(), "gsd-db-snapshot-test-"));
+		const dbPath = join(dir, "agent.db");
+		const snapshot = new Uint8Array([0x53, 0x51, 0x4c, 0x69, 0x74, 0x65]);
+
+		atomicWriteDbSnapshotSync(dbPath, snapshot);
+
+		assert.deepEqual(readFileSync(dbPath), Buffer.from(snapshot));
+		assert.equal(existsSync(`${dbPath}.tmp`), false);
+		assert.deepEqual(
+			readdirSync(dir).filter((entry) => entry.includes("agent.db") && entry.includes(".tmp")),
+			[],
+		);
+	});
+});

package/packages/pi-coding-agent/src/core/db-snapshot.ts

@@ -0,0 +1,66 @@
+import { randomUUID } from "node:crypto";
+import { closeSync, fsyncSync, openSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+
+export type DbSnapshot = Buffer | Uint8Array;
+
+function closeBestEffort(fd: number | null): void {
+	if (fd === null) return;
+	try {
+		closeSync(fd);
+	} catch {
+		// Preserve the original write/rename failure when cleaning up.
+	}
+}
+
+function fsyncDirectoryBestEffort(dirPath: string): void {
+	let fd: number | null = null;
+	try {
+		fd = openSync(dirPath, "r");
+		fsyncSync(fd);
+	} catch {
+		// Directory fsync is unsupported on some platforms/filesystems.
+	} finally {
+		closeBestEffort(fd);
+	}
+}
+
+/**
+ * Persist a sql.js database export without exposing callers to a torn live file.
+ *
+ * The snapshot is written to a unique temp file in the same directory, flushed,
+ * then renamed over the target. A hard kill during the temp write leaves the
+ * previous target intact; after rename, readers see the complete new snapshot.
+ *
+ * The rename replaces the target inode: existing file mode/ownership is not
+ * preserved, and a symlink at dbPath is replaced rather than written through.
+ * Agent DB snapshots are owned runtime files, so this trade-off favors a
+ * private 0600 replacement over retaining prior target metadata.
+ */
+export function atomicWriteDbSnapshotSync(dbPath: string, snapshot: DbSnapshot): void {
+	const dirPath = dirname(dbPath);
+	const tmpPath = join(dirPath, `.${basename(dbPath)}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`);
+	let fd: number | null = null;
+	let renamed = false;
+
+	try {
+		fd = openSync(tmpPath, "wx", 0o600);
+		writeFileSync(fd, Buffer.from(snapshot));
+		fsyncSync(fd);
+		closeSync(fd);
+		fd = null;
+
+		renameSync(tmpPath, dbPath);
+		renamed = true;
+		fsyncDirectoryBestEffort(dirPath);
+	} finally {
+		closeBestEffort(fd);
+		if (!renamed) {
+			try {
+				unlinkSync(tmpPath);
+			} catch {
+				// The temp file may not have been created yet.
+			}
+		}
+	}
+}

package/packages/pi-coding-agent/src/core/extensions/loader.ts

@@ -415,6 +415,8 @@ export function createExtensionRuntime(): ExtensionRuntime {
 		getActiveTools: notInitialized,
 		getAllTools: notInitialized,
 		setActiveTools: notInitialized,
+		getVisibleSkills: notInitialized,
+		setVisibleSkills: notInitialized,
 		// registerTool() is valid during extension load; refresh is only needed post-bind.
 		refreshTools: () => {},
 		getCommands: notInitialized,
@@ -566,6 +568,14 @@ function createExtensionAPI(
 			runtime.setActiveTools(toolNames);
 		},
 
+		getVisibleSkills(): string[] | undefined {
+			return runtime.getVisibleSkills();
+		},
+
+		setVisibleSkills(skillNames: string[] | undefined): void {
+			runtime.setVisibleSkills(skillNames);
+		},
+
 		getCommands() {
 			return runtime.getCommands();
 		},

package/packages/pi-coding-agent/src/core/extensions/runner.test.ts

@@ -102,10 +102,65 @@ describe("ExtensionRunner.emitToolCall", () => {
 		assert.equal(errors[0].event, "tool_call");
 		assert.equal(errors[0].extensionPath, "/test/throwing-ext");
 	});
+
+	it("preserves shutdown in tool_call handler context", async (t) => {
+		const dir = mkdtempSync(join(tmpdir(), "runner-test-"));
+		t.after(() => {
+			rmSync(dir, { recursive: true, force: true });
+		});
+
+		const sessionManager = SessionManager.create(dir, dir);
+		const authStorage = AuthStorage.create();
+		const modelRegistry = new ModelRegistry(authStorage, join(dir, "models.json"));
+		const runtime = makeMinimalRuntime();
+		let shutdownCount = 0;
+		const handlers = new Map();
+		handlers.set("tool_call", [
+			async (_event: unknown, ctx: { shutdown: () => void }) => {
+				ctx.shutdown();
+			},
+		]);
+		const extension = {
+			path: "/test/shutdown-on-tool-call",
+			handlers,
+			commands: new Map(),
+			shortcuts: new Map(),
+			tools: new Map(),
+			flags: new Map(),
+			diagnostics: [],
+		} as unknown as Extension;
+		const runner = new ExtensionRunner([extension], runtime, dir, sessionManager, modelRegistry);
+		runner.bindCore({} as any, {
+			getModel: () => undefined,
+			isIdle: () => true,
+			abort: () => {},
+			hasPendingMessages: () => false,
+			shutdown: () => {
+				shutdownCount += 1;
+			},
+			getContextUsage: () => undefined,
+			compact: () => {},
+			getSystemPrompt: () => "",
+			setCompactionThresholdOverride: () => {},
+		});
+
+		const errors: any[] = [];
+		runner.onError((err) => errors.push(err));
+
+		await runner.emitToolCall({
+			type: "tool_call",
+			toolCallId: "test-123",
+			toolName: "test_tool",
+			input: {},
+		} as ToolCallEvent);
+
+		assert.equal(shutdownCount, 1);
+		assert.equal(errors.length, 0);
+	});
 });
 
 describe("ExtensionRunner.createContext", () => {
-	it("uses the live process cwd instead of the constructor cwd", (t) => {
+	it("uses the constructor workspace root instead of ambient process cwd", (t) => {
 		const originalCwd = process.cwd();
 		const dir = mkdtempSync(join(tmpdir(), "runner-test-"));
 		const projectDir = join(dir, "project");
@@ -124,8 +179,63 @@ describe("ExtensionRunner.createContext", () => {
 		const realProjectDir = realpathSync(projectDir);
 		process.chdir(realProjectDir);
 
-		assert.equal(runner.createContext().cwd, realProjectDir);
-		assert.equal(runner.createCommandContext().cwd, realProjectDir);
+		assert.equal(runner.createContext().cwd, originalCwd);
+		assert.equal(runner.createCommandContext().cwd, originalCwd);
+	});
+
+	it("does not let lifecycle event handlers close the TUI", async (t) => {
+		const dir = mkdtempSync(join(tmpdir(), "runner-test-"));
+		t.after(() => {
+			rmSync(dir, { recursive: true, force: true });
+		});
+
+		const sessionManager = SessionManager.create(dir, dir);
+		const authStorage = AuthStorage.create();
+		const modelRegistry = new ModelRegistry(authStorage, join(dir, "models.json"));
+		const runtime = makeMinimalRuntime();
+		let shutdownCount = 0;
+		const handlers = new Map();
+		handlers.set("agent_end", [
+			async (_event: unknown, ctx: { shutdown: () => void }) => {
+				ctx.shutdown();
+			},
+		]);
+		const extension = {
+			path: "/test/shutdown-on-agent-end",
+			handlers,
+			commands: new Map(),
+			shortcuts: new Map(),
+			tools: new Map(),
+			flags: new Map(),
+			diagnostics: [],
+		} as unknown as Extension;
+		const runner = new ExtensionRunner([extension], runtime, dir, sessionManager, modelRegistry);
+		runner.bindCore({} as any, {
+			getModel: () => undefined,
+			isIdle: () => true,
+			abort: () => {},
+			hasPendingMessages: () => false,
+			shutdown: () => {
+				shutdownCount += 1;
+			},
+			getContextUsage: () => undefined,
+			compact: () => {},
+			getSystemPrompt: () => "",
+			setCompactionThresholdOverride: () => {},
+		});
+
+		const errors: any[] = [];
+		runner.onError((err) => errors.push(err));
+
+		await runner.emit({ type: "agent_end", messages: [] } as any);
+
+		assert.equal(shutdownCount, 0);
+		assert.equal(errors.length, 1);
+		assert.equal(errors[0].event, "agent_end");
+		assert.match(errors[0].error, /cannot request TUI shutdown/);
+
+		runner.createCommandContext().shutdown();
+		assert.equal(shutdownCount, 1);
 	});
 });