@dungle-scrubs/tallow 0.8.21 → 0.8.23

package/extensions/slash-command-bridge/__tests__/slash-command-bridge.test.ts

@@ -1,57 +1,142 @@
 /**
  * Unit tests for the slash-command-bridge extension.
  *
- * Uses ExtensionHarness for isolated testing of tool registration,
- * command dispatch, context injection, and error handling.
+ * Focuses on compact deferral, chosen lifecycle boundary, exactly-once guards,
+ * and deterministic timer-driven continuation behavior.
  */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import type { ContextUsage, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { AssistantMessage, ToolResultMessage, Usage } from "@mariozechner/pi-ai";
+import type {
+	ContextUsage,
+	ExtensionContext,
+	ExtensionUIContext,
+	TurnEndEvent,
+} from "@mariozechner/pi-coding-agent";
 import { ExtensionHarness } from "../../../test-utils/extension-harness.js";
-import slashCommandBridge from "../index.js";
-
-// ── Setup ────────────────────────────────────────────────────────────────────
+import { ManualTimerScheduler } from "../../../test-utils/manual-timer-scheduler.js";
+import slashCommandBridge, {
+	resetSlashCommandBridgeStateForTests,
+	setSlashCommandBridgeSchedulerForTests,
+} from "../index.js";
+
+const ZERO_USAGE: Usage = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0,
+	totalTokens: 0,
+	cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+};
 
 let harness: ExtensionHarness;
+let scheduler: ManualTimerScheduler;
 
 beforeEach(async () => {
+	scheduler = new ManualTimerScheduler();
+	setSlashCommandBridgeSchedulerForTests(scheduler.runtime);
 	harness = ExtensionHarness.create();
 	await harness.loadExtension(slashCommandBridge);
 });
 
-afterEach(async () => {
-	await harness.fireEvent("session_before_switch", {
-		type: "session_before_switch",
-		reason: "switch",
-	});
+afterEach(() => {
+	resetSlashCommandBridgeStateForTests();
 });
 
-// ── Registration ─────────────────────────────────────────────────────────────
+/**
+ * Builds a mock ExtensionContext with overridable methods.
+ *
+ * @param overrides - Methods/properties to override on the default stub context
+ * @returns Mock ExtensionContext
+ */
+function buildContext(overrides: Partial<ExtensionContext> = {}): ExtensionContext {
+	return {
+		ui: {} as ExtensionContext["ui"],
+		hasUI: false,
+		cwd: process.cwd(),
+		sessionManager: {} as ExtensionContext["sessionManager"],
+		modelRegistry: {} as ExtensionContext["modelRegistry"],
+		model: undefined,
+		isIdle: () => true,
+		abort: () => {},
+		hasPendingMessages: () => false,
+		shutdown: () => {},
+		getContextUsage: () => undefined,
+		compact: () => {},
+		getSystemPrompt: () => "",
+		...overrides,
+	};
+}
 
-describe("registration", () => {
-	test("registers run_slash_command tool", () => {
-		expect(harness.tools.has("run_slash_command")).toBe(true);
-	});
+/**
+ * Creates a realistic assistant turn_end event for compact lifecycle tests.
+ *
+ * @param stopReason - Assistant stop reason for the completed turn
+ * @returns TurnEnd event payload
+ */
+function buildAssistantTurnEnd(stopReason: AssistantMessage["stopReason"]): TurnEndEvent {
+	return {
+		type: "turn_end",
+		turnIndex: 0,
+		message: {
+			role: "assistant",
+			content: [],
+			api: "anthropic-messages",
+			provider: "mock",
+			model: "mock-model",
+			stopReason,
+			timestamp: Date.now(),
+			usage: { ...ZERO_USAGE },
+		},
+		toolResults: stopReason === "toolUse" ? [buildCompactToolResult()] : [],
+	};
+}
 
-	test("tool has correct label", () => {
-		const tool = harness.tools.get("run_slash_command");
-		expect(tool?.label).toBe("run_slash_command");
-	});
+/**
+ * Builds the compact tool result payload recorded on the tool-use turn.
+ *
+ * @returns Tool result message for `run_slash_command({ command: "compact" })`
+ */
+function buildCompactToolResult(): ToolResultMessage<{ command: string }> {
+	return {
+		role: "toolResult",
+		toolCallId: "mock-tool-call",
+		toolName: "run_slash_command",
+		content: [
+			{ type: "text", text: "Session compaction will begin after this response completes." },
+		],
+		details: { command: "compact" },
+		isError: false,
+		timestamp: Date.now(),
+	};
+}
 
-	test("tool description lists available commands", () => {
-		const tool = harness.tools.get("run_slash_command");
-		expect(tool?.description).toContain("show-system-prompt");
-		expect(tool?.description).toContain("context");
-		expect(tool?.description).toContain("compact");
-	});
+/**
+ * Executes the registered slash-command tool with the provided context.
+ *
+ * @param params - Tool parameters
+ * @param ctx - Extension context for the execution
+ * @returns Tool execution result
+ */
+async function executeTool(params: { command: string }, ctx?: ExtensionContext) {
+	const tool = harness.tools.get("run_slash_command");
+	if (!tool) {
+		throw new Error("run_slash_command tool not registered");
+	}
+
+	return tool.execute("test-call-id", params, undefined, undefined, ctx ?? buildContext());
+}
 
-	test("registers before_agent_start handler", () => {
+describe("registration", () => {
+	test("registers run_slash_command and lifecycle handlers", () => {
+		expect(harness.tools.has("run_slash_command")).toBe(true);
 		expect(harness.handlers.has("before_agent_start")).toBe(true);
+		expect(harness.handlers.has("turn_end")).toBe(true);
+		expect(harness.handlers.has("turn_start")).toBe(true);
+		expect(harness.handlers.has("session_before_switch")).toBe(true);
 	});
 });
 
-// ── Command execution: show-system-prompt ────────────────────────────────────
-
 describe("show-system-prompt", () => {
 	test("returns the current system prompt", async () => {
 		const systemPrompt = "You are a helpful assistant with custom instructions.";
@@ -60,101 +145,71 @@ describe("show-system-prompt", () => {
 		const result = await executeTool({ command: "show-system-prompt" }, ctx);
 
 		expect(result.content[0]).toEqual({ type: "text", text: systemPrompt });
-	});
-
-	test("includes prompt length in details", async () => {
-		const systemPrompt = "Short prompt.";
-		const ctx = buildContext({ getSystemPrompt: () => systemPrompt });
-
-		const result = await executeTool({ command: "show-system-prompt" }, ctx);
-
 		expect(result.details).toEqual({ command: "show-system-prompt", length: systemPrompt.length });
 	});
-
-	test("handles empty system prompt", async () => {
-		const ctx = buildContext({ getSystemPrompt: () => "" });
-
-		const result = await executeTool({ command: "show-system-prompt" }, ctx);
-
-		expect(result.content[0]).toEqual({ type: "text", text: "" });
-		expect(result.isError).toBeUndefined();
-	});
 });
 
-// ── Command execution: context ───────────────────────────────────────────────
-
 describe("context", () => {
 	test("returns formatted context usage", async () => {
 		const usage: ContextUsage = { tokens: 45000, contextWindow: 200000 };
 		const ctx = buildContext({ getContextUsage: () => usage });
 
 		const result = await executeTool({ command: "context" }, ctx);
-
 		const text = result.content[0];
+
 		expect(text).toBeDefined();
 		if (text?.type === "text") {
 			expect(text.text).toContain("45,000");
 			expect(text.text).toContain("200,000");
 			expect(text.text).toContain("22.5%");
-			expect(text.text).toContain("155,000"); // free tokens
 		}
 	});
 
-	test("includes token data in details", async () => {
-		const usage: ContextUsage = { tokens: 10000, contextWindow: 100000 };
-		const ctx = buildContext({ getContextUsage: () => usage });
-
-		const result = await executeTool({ command: "context" }, ctx);
-
-		expect(result.details).toEqual({
-			command: "context",
-			tokens: 10000,
-			contextWindow: 100000,
-		});
-	});
-
-	test("returns error when no usage data available", async () => {
-		const ctx = buildContext({ getContextUsage: () => undefined });
-
-		const result = await executeTool({ command: "context" }, ctx);
+	test("returns error when usage data is unavailable", async () => {
+		const result = await executeTool({ command: "context" }, buildContext());
 
 		expect(result.isError).toBe(true);
-		const text = result.content[0];
-		if (text?.type === "text") {
-			expect(text.text).toContain("No context usage data");
-		}
+		expect(result.details).toEqual({ command: "context", error: "no_usage_data" });
 	});
+});
 
-	test("returns no-usage error when token count is unknown", async () => {
-		const usage: ContextUsage = { tokens: null, contextWindow: 200000, percent: null };
-		const ctx = buildContext({ getContextUsage: () => usage });
-
-		const result = await executeTool({ command: "context" }, ctx);
+describe("error handling", () => {
+	test("rejects unknown commands", async () => {
+		const result = await executeTool({ command: "reboot" }, buildContext());
 
 		expect(result.isError).toBe(true);
-		expect(result.details).toEqual({ command: "context", error: "no_usage_data" });
 		const text = result.content[0];
 		if (text?.type === "text") {
-			expect(text.text).toContain("No context usage data");
-			expect(text.text).not.toContain("0 / 200,000");
-			expect(text.text).not.toContain("0.0%");
+			expect(text.text).toContain("Unknown command");
+			expect(text.text).toContain("reboot");
 		}
 	});
+});
 
-	test("handles zero context window gracefully", async () => {
-		const usage: ContextUsage = { tokens: 0, contextWindow: 0 };
-		const ctx = buildContext({ getContextUsage: () => usage });
+describe("context injection", () => {
+	test("injects hidden context listing bridged commands", async () => {
+		const results = await harness.fireEvent("before_agent_start", {
+			type: "before_agent_start",
+			prompt: "hello",
+			systemPrompt: "",
+		});
 
-		const result = await executeTool({ command: "context" }, ctx);
+		const result = results.find((entry) => entry != null) as
+			| {
+					message: { content: string; customType: string; display: boolean };
+			  }
+			| undefined;
 
-		expect(result.isError).toBeUndefined();
+		expect(result?.message.customType).toBe("slash-command-bridge-context");
+		expect(result?.message.display).toBe(false);
+		expect(result?.message.content).toContain("/show-system-prompt");
+		expect(result?.message.content).toContain("/context");
+		expect(result?.message.content).toContain("/compact");
 	});
 });
 
-// ── Command execution: compact ───────────────────────────────────────────────
-
 describe("compact", () => {
-	test("does NOT call ctx.compact() immediately — defers to agent_end", async () => {
+	test("defers compact instead of calling ctx.compact inline", async () => {
 		let compactCalled = false;
 		const ctx = buildContext({
 			compact: () => {
@@ -162,17 +217,10 @@ describe("compact", () => {
 			},
 		});
 
-		await executeTool({ command: "compact" }, ctx);
-
-		expect(compactCalled).toBe(false);
-	});
-
-	test("returns message instructing model to finish response", async () => {
-		const ctx = buildContext({ compact: () => {} });
-
 		const result = await executeTool({ command: "compact" }, ctx);
 
-		expect(result.isError).toBeUndefined();
+		expect(compactCalled).toBe(false);
+		expect(result.details).toEqual({ command: "compact" });
 		const text = result.content[0];
 		if (text?.type === "text") {
 			expect(text.text).toContain("compaction will begin after this response");
@@ -180,686 +228,234 @@ describe("compact", () => {
 		}
 	});
 
-	test("includes command name in details", async () => {
-		const ctx = buildContext({ compact: () => {} });
-
-		const result = await executeTool({ command: "compact" }, ctx);
-
-		expect(result.details).toEqual({ command: "compact" });
-	});
-
-	test("agent_end hook triggers deferred compact with callbacks", async () => {
+	test("waits through the tool-use turn and compacts on the following assistant turn_end", async () => {
+		let compactCalls = 0;
 		let compactOptions: Parameters<ExtensionContext["compact"]>[0];
-		const toolCtx = buildContext({ compact: () => {} });
-		const agentEndCtx = buildContext({
+		const ctx = buildContext({
 			compact: (options) => {
+				compactCalls++;
 				compactOptions = options;
 			},
 		});
 
-		// Tool sets the deferred flag
-		await executeTool({ command: "compact" }, toolCtx);
-
-		// agent_end fires — should trigger compact
-		await harness.fireEvent("agent_end", { type: "agent_end", messages: [] }, agentEndCtx);
+		await executeTool({ command: "compact" }, buildContext());
+		await harness.fireEvent("turn_end", buildAssistantTurnEnd("toolUse"), ctx);
+		expect(compactCalls).toBe(0);
 
-		expect(compactOptions).toBeDefined();
+		await harness.fireEvent("turn_end", buildAssistantTurnEnd("stop"), ctx);
+		expect(compactCalls).toBe(1);
 		expect(typeof compactOptions?.onComplete).toBe("function");
 		expect(typeof compactOptions?.onError).toBe("function");
-
-		// Clean up compact progress interval to avoid cross-test leakage.
-		compactOptions?.onError?.();
 	});
 
-	test("agent_end hook starts compact heartbeat updates with elapsed status", async () => {
-		let compactOptions: Parameters<ExtensionContext["compact"]>[0];
-		const workingMessages: Array<string | undefined> = [];
-		const statusUpdates: Array<{ key: string; text: string | undefined }> = [];
-		const toolCtx = buildContext({ compact: () => {} });
-		const agentEndCtx = buildContext({
-			hasUI: true,
-			ui: {
-				setWorkingMessage: (message?: string) => {
-					workingMessages.push(message);
-				},
-				setStatus: (key: string, text?: string) => {
-					statusUpdates.push({ key, text });
-				},
-			} as ExtensionContext["ui"],
-			compact: (options) => {
-				compactOptions = options;
+	test("consumes the pending request exactly once", async () => {
+		let compactCalls = 0;
+		const ctx = buildContext({
+			compact: () => {
+				compactCalls++;
 			},
 		});
 
-		await executeTool({ command: "compact" }, toolCtx);
-		await harness.fireEvent("agent_end", { type: "agent_end", messages: [] }, agentEndCtx);
+		await executeTool({ command: "compact" }, buildContext());
+		await harness.fireEvent("turn_end", buildAssistantTurnEnd("toolUse"), ctx);
+		await harness.fireEvent("turn_end", buildAssistantTurnEnd("stop"), ctx);
+		await harness.fireEvent("turn_end", buildAssistantTurnEnd("stop"), ctx);
 
-		expect(workingMessages[0]).toBe("Compacting session…");
-		expect(statusUpdates[0]?.key).toBe("compact");
-		expect(statusUpdates[0]?.text).toContain("compacting · 0s");
-
-		await sleep(1100);
-
-		const hasElapsedUpdate = statusUpdates.some((update) =>
-			update.text?.includes("compacting · 1s")
-		);
-		expect(hasElapsedUpdate).toBe(true);
-
-		compactOptions?.onError?.();
+		expect(compactCalls).toBe(1);
 	});
 
-	test("onComplete stops compact heartbeat and transitions to resuming", async () => {
+	test("drives heartbeat and continuation timers deterministically", async () => {
 		let compactOptions: Parameters<ExtensionContext["compact"]>[0];
+		const widgetUpdates: Array<{ key: string; content: string[] | undefined }> = [];
 		const workingMessages: Array<string | undefined> = [];
-		const statusUpdates: Array<{ key: string; text: string | undefined }> = [];
-		const toolCtx = buildContext({ compact: () => {} });
-		const agentEndCtx = buildContext({
+		const ctx = buildContext({
 			hasUI: true,
 			ui: {
+				setWidget: (key: string, content?: string[]) => {
+					widgetUpdates.push({ key, content });
+				},
 				setWorkingMessage: (message?: string) => {
 					workingMessages.push(message);
 				},
-				setStatus: (key: string, text?: string) => {
-					statusUpdates.push({ key, text });
-				},
-			} as ExtensionContext["ui"],
+			} as ExtensionUIContext,
 			compact: (options) => {
 				compactOptions = options;
 			},
 			isIdle: () => true,
 		});
 
-		await executeTool({ command: "compact" }, toolCtx);
-		await harness.fireEvent("agent_end", { type: "agent_end", messages: [] }, agentEndCtx);
-		await sleep(1100);
-
-		compactOptions?.onComplete?.();
-		expect(workingMessages.at(-1)).toBe("Resuming task…");
-		expect(statusUpdates.at(-1)).toEqual({ key: "compact", text: "⏳ resuming" });
-
-		const updatesAfterComplete = statusUpdates.length;
-		await sleep(1200);
-		expect(statusUpdates).toHaveLength(updatesAfterComplete);
-	});
+		await executeTool({ command: "compact" }, buildContext());
+		await harness.fireEvent("turn_end", buildAssistantTurnEnd("toolUse"), ctx);
+		await harness.fireEvent("turn_end", buildAssistantTurnEnd("stop"), ctx);
 
-	test("onComplete sends continuation message when agent is idle and no queued messages", async () => {
-		let compactOptions: Parameters<ExtensionContext["compact"]>[0];
-		const toolCtx = buildContext({ compact: () => {} });
-		const agentEndCtx = buildContext({
-			compact: (options) => {
-				compactOptions = options;
-			},
-			isIdle: () => true,
+		expect(workingMessages[0]).toBe("Compacting session…");
+		expect(widgetUpdates[0]).toEqual({
+			key: "compact-progress",
+			content: ["🧹 ⠋ Compacting session · 0s"],
 		});
 
-		await executeTool({ command: "compact" }, toolCtx);
-		await harness.fireEvent("agent_end", { type: "agent_end", messages: [] }, agentEndCtx);
+		scheduler.advanceBy(1000);
+		expect(widgetUpdates.at(-1)).toEqual({
+			key: "compact-progress",
+			content: ["🧹 ⠙ Compacting session · 1s"],
+		});
 
-		// Trigger onComplete and wait for the setTimeout(200) to fire
 		compactOptions?.onComplete?.();
-		await new Promise((resolve) => setTimeout(resolve, 300));
+		expect(workingMessages.at(-1)).toBe("Resuming task…");
+		expect(widgetUpdates.at(-1)).toEqual({
+			key: "compact-progress",
+			content: ["⏳ Resuming after compaction…"],
+		});
+
+		scheduler.advanceBy(199);
+		expect(harness.sentMessages).toHaveLength(0);
+		scheduler.advanceBy(1);
 
-		const continuation = harness.sentMessages.find((m) => m.customType === "compact-continue");
-		expect(continuation).toBeDefined();
+		const continuation = harness.sentMessages.find(
+			(message) => message.customType === "compact-continue"
+		);
 		expect(continuation?.display).toBe(false);
 		expect(continuation?.options?.triggerTurn).toBe(true);
 		expect(continuation?.content).toContain("compaction is complete");
 	});
 
-	test("onComplete always schedules continuation even when compaction queue has messages", async () => {
-		// Previously, onComplete short-circuited when hasCompactionQueuedMessages()
-		// returned true. This caused orphaned session steering messages because the
-		// method's false positive (checking session steering too) prevented the
-		// continuation timer from firing. Now the timer always fires — safety nets
-		// (turn_start cancellation, isIdle() check) prevent duplicate prompts.
-		// See plan 160.
+	test("turn_start cancels the delayed continuation and clears the inline widget", async () => {
 		let compactOptions: Parameters<ExtensionContext["compact"]>[0];
-		const toolCtx = buildContext({ compact: () => {} });
-		const agentEndCtx = buildContext({
+		const widgetUpdates: Array<{ key: string; content: string[] | undefined }> = [];
+		const ctx = buildContext({
 			hasUI: true,
 			ui: {
+				setWidget: (key: string, content?: string[]) => {
+					widgetUpdates.push({ key, content });
+				},
 				setWorkingMessage: () => {},
-				setStatus: () => {},
-				// Even with hasCompactionQueuedMessages exposed, onComplete
-				// no longer checks it.
-				hasCompactionQueuedMessages: () => true,
-			} as unknown as ExtensionContext["ui"],
+			} as ExtensionUIContext,
 			compact: (options) => {
 				compactOptions = options;
 			},
 			isIdle: () => true,
 		});
 
-		await executeTool({ command: "compact" }, toolCtx);
-		await harness.fireEvent("agent_end", { type: "agent_end", messages: [] }, agentEndCtx);
-
+		await executeTool({ command: "compact" }, buildContext());
+		await harness.fireEvent("turn_end", buildAssistantTurnEnd("toolUse"), ctx);
+		await harness.fireEvent("turn_end", buildAssistantTurnEnd("stop"), ctx);
 		compactOptions?.onComplete?.();
-		await new Promise((resolve) => setTimeout(resolve, 300));
 
-		// Continuation fires regardless — safety nets prevent duplicates
-		const continuation = harness.sentMessages.find((m) => m.customType === "compact-continue");
-		expect(continuation).toBeDefined();
-		expect(continuation?.content).toContain("compaction is complete");
+		await harness.fireEvent("turn_start", { type: "turn_start", turnIndex: 0, timestamp: 0 }, ctx);
+		scheduler.advanceBy(200);
+
+		expect(harness.sentMessages).toHaveLength(0);
+		expect(widgetUpdates.at(-1)).toEqual({ key: "compact-progress", content: undefined });
 	});
 
-	test("onComplete skips continuation and clears indicators when agent is not idle", async () => {
+	test("skips continuation and clears indicators when the session is no longer idle", async () => {
 		let compactOptions: Parameters<ExtensionContext["compact"]>[0];
-		const statusUpdates: Array<{ key: string; text: string | undefined }> = [];
+		const widgetUpdates: Array<{ key: string; content: string[] | undefined }> = [];
 		const workingMessages: Array<string | undefined> = [];
-		const toolCtx = buildContext({ compact: () => {} });
-		const agentEndCtx = buildContext({
+		const ctx = buildContext({
 			hasUI: true,
 			ui: {
+				setWidget: (key: string, content?: string[]) => {
+					widgetUpdates.push({ key, content });
+				},
 				setWorkingMessage: (message?: string) => {
 					workingMessages.push(message);
 				},
-				setStatus: (key: string, text?: string) => {
-					statusUpdates.push({ key, text });
-				},
-			} as ExtensionContext["ui"],
+			} as ExtensionUIContext,
 			compact: (options) => {
 				compactOptions = options;
 			},
 			isIdle: () => false,
 		});
 
-		await executeTool({ command: "compact" }, toolCtx);
-		await harness.fireEvent("agent_end", { type: "agent_end", messages: [] }, agentEndCtx);
-
+		await executeTool({ command: "compact" }, buildContext());
+		await harness.fireEvent("turn_end", buildAssistantTurnEnd("toolUse"), ctx);
+		await harness.fireEvent("turn_end", buildAssistantTurnEnd("stop"), ctx);
 		compactOptions?.onComplete?.();
-		await new Promise((resolve) => setTimeout(resolve, 300));
-
-		const continuation = harness.sentMessages.find((m) => m.customType === "compact-continue");
-		expect(continuation).toBeUndefined();
+		scheduler.advanceBy(200);
 
-		// When not idle, the !isIdle() branch clears indicators
-		expect(statusUpdates.at(-1)).toEqual({ key: "compact", text: undefined });
+		expect(harness.sentMessages).toHaveLength(0);
+		expect(widgetUpdates.at(-1)).toEqual({ key: "compact-progress", content: undefined });
 		expect(workingMessages.at(-1)).toBeUndefined();
 	});
 
-	test("onError stops compact heartbeat, clears status, and sends no continuation", async () => {
+	test("onError clears compact UI and sends no continuation", async () => {
 		let compactOptions: Parameters<ExtensionContext["compact"]>[0];
-		const statusUpdates: Array<{ key: string; text: string | undefined }> = [];
-		const toolCtx = buildContext({ compact: () => {} });
-		const agentEndCtx = buildContext({
-			hasUI: true,
-			ui: {
-				setWorkingMessage: () => {},
-				setStatus: (key: string, text?: string) => {
-					statusUpdates.push({ key, text });
-				},
-			} as ExtensionContext["ui"],
-			compact: (options) => {
-				compactOptions = options;
-			},
-			isIdle: () => true,
-		});
-
-		await executeTool({ command: "compact" }, toolCtx);
-		await harness.fireEvent("agent_end", { type: "agent_end", messages: [] }, agentEndCtx);
-		await sleep(1100);
-
-		compactOptions?.onError?.();
-		expect(statusUpdates.at(-1)).toEqual({ key: "compact", text: undefined });
-
-		const updatesAfterError = statusUpdates.length;
-		await sleep(1200);
-		expect(statusUpdates).toHaveLength(updatesAfterError);
-
-		const continuation = harness.sentMessages.find((m) => m.customType === "compact-continue");
-		expect(continuation).toBeUndefined();
-	});
-
-	test("agent_end hook is a no-op when no compact is pending", async () => {
-		let compactCalled = false;
+		const widgetUpdates: Array<{ key: string; content: string[] | undefined }> = [];
+		const workingMessages: Array<string | undefined> = [];
 		const ctx = buildContext({
-			compact: () => {
-				compactCalled = true;
-			},
-		});
-
-		// Fire agent_end without a preceding compact tool call
-		await harness.fireEvent("agent_end", { type: "agent_end", messages: [] }, ctx);
-
-		expect(compactCalled).toBe(false);
-	});
-
-	test("turn_start cancels continuation timer before it fires", async () => {
-		let compactOptions: Parameters<ExtensionContext["compact"]>[0];
-		const toolCtx = buildContext({ compact: () => {} });
-		const agentEndCtx = buildContext({
 			hasUI: true,
 			ui: {
-				setWorkingMessage: () => {},
-				setStatus: () => {},
-			} as ExtensionContext["ui"],
-			compact: (options) => {
-				compactOptions = options;
-			},
-			isIdle: () => true,
-		});
-
-		await executeTool({ command: "compact" }, toolCtx);
-		await harness.fireEvent("agent_end", { type: "agent_end", messages: [] }, agentEndCtx);
-
-		// Trigger onComplete — starts the 200ms timer
-		compactOptions?.onComplete?.();
-
-		// Fire turn_start before the timer expires (simulates flushCompactionQueue
-		// prompting the agent first)
-		const turnCtx = buildContext({
-			hasUI: true,
-			ui: {
-				setStatus: () => {},
-			} as ExtensionContext["ui"],
-		});
-		await harness.fireEvent("turn_start", { type: "turn_start" }, turnCtx);
-
-		// Wait longer than the 200ms timeout
-		await new Promise((resolve) => setTimeout(resolve, 300));
-
-		// Timer was cancelled — no duplicate continuation message sent
-		const continuation = harness.sentMessages.find((m) => m.customType === "compact-continue");
-		expect(continuation).toBeUndefined();
-	});
-
-	test("turn_start clears footer status when resuming after compact", async () => {
-		let compactOptions: Parameters<ExtensionContext["compact"]>[0];
-		const statusUpdates: Array<{ key: string; text: string | undefined }> = [];
-		const toolCtx = buildContext({ compact: () => {} });
-		const agentEndCtx = buildContext({
-			hasUI: true,
-			ui: {
-				setWorkingMessage: () => {},
-				setStatus: (key: string, text?: string) => {
-					statusUpdates.push({ key, text });
-				},
-			} as ExtensionContext["ui"],
-			compact: (options) => {
-				compactOptions = options;
-			},
-		});
-
-		await executeTool({ command: "compact" }, toolCtx);
-		await harness.fireEvent("agent_end", { type: "agent_end", messages: [] }, agentEndCtx);
-		compactOptions?.onComplete?.();
-
-		// Resuming status should be set
-		expect(statusUpdates.at(-1)).toEqual({ key: "compact", text: "⏳ resuming" });
-
-		// turn_start fires — should clear the footer status
-		const turnCtx = buildContext({
-			hasUI: true,
-			ui: {
-				setStatus: (key: string, text?: string) => {
-					statusUpdates.push({ key, text });
+				setWidget: (key: string, content?: string[]) => {
+					widgetUpdates.push({ key, content });
 				},
-			} as ExtensionContext["ui"],
-		});
-		await harness.fireEvent("turn_start", { type: "turn_start" }, turnCtx);
-
-		expect(statusUpdates.at(-1)).toEqual({ key: "compact", text: undefined });
-	});
-
-	test("turn_start is a no-op when not resuming after compact", async () => {
-		const statusUpdates: Array<{ key: string; text: string | undefined }> = [];
-		const turnCtx = buildContext({
-			hasUI: true,
-			ui: {
-				setStatus: (key: string, text?: string) => {
-					statusUpdates.push({ key, text });
-				},
-			} as ExtensionContext["ui"],
-		});
-
-		// Fire turn_start without any preceding compaction
-		await harness.fireEvent("turn_start", { type: "turn_start" }, turnCtx);
-
-		// No status updates should have been made
-		expect(statusUpdates).toHaveLength(0);
-	});
-
-	test("session_before_switch clears active compact heartbeat state", async () => {
-		let compactOptions: Parameters<ExtensionContext["compact"]>[0];
-		const statusUpdates: Array<{ key: string; text: string | undefined }> = [];
-		const toolCtx = buildContext({ compact: () => {} });
-		const agentEndCtx = buildContext({
-			hasUI: true,
-			ui: {
-				setWorkingMessage: () => {},
-				setStatus: (key: string, text?: string) => {
-					statusUpdates.push({ key, text });
+				setWorkingMessage: (message?: string) => {
+					workingMessages.push(message);
 				},
-			} as ExtensionContext["ui"],
+			} as ExtensionUIContext,
 			compact: (options) => {
 				compactOptions = options;
 			},
+			isIdle: () => true,
 		});
 
-		await executeTool({ command: "compact" }, toolCtx);
-		await harness.fireEvent("agent_end", { type: "agent_end", messages: [] }, agentEndCtx);
-		await sleep(1100);
-
-		expect(compactOptions).toBeDefined();
-		expect(statusUpdates.some((update) => update.text?.includes("compacting"))).toBe(true);
-
-		const switchCtx = buildContext({
-			hasUI: true,
-			ui: {
-				setStatus: (key: string, text?: string) => {
-					statusUpdates.push({ key, text });
-				},
-			} as ExtensionContext["ui"],
-		});
-		await harness.fireEvent(
-			"session_before_switch",
-			{ type: "session_before_switch", reason: "switch" },
-			switchCtx
-		);
-
-		expect(statusUpdates.at(-1)).toEqual({ key: "compact", text: undefined });
+		await executeTool({ command: "compact" }, buildContext());
+		await harness.fireEvent("turn_end", buildAssistantTurnEnd("toolUse"), ctx);
+		await harness.fireEvent("turn_end", buildAssistantTurnEnd("stop"), ctx);
+		scheduler.advanceBy(1000);
+		compactOptions?.onError?.(new Error("boom"));
+		scheduler.advanceBy(200);
 
-		const updatesAfterSwitch = statusUpdates.length;
-		await sleep(1200);
-		expect(statusUpdates).toHaveLength(updatesAfterSwitch);
+		expect(harness.sentMessages).toHaveLength(0);
+		expect(widgetUpdates.at(-1)).toEqual({ key: "compact-progress", content: undefined });
+		expect(workingMessages.at(-1)).toBeUndefined();
 	});
 
-	test("session_before_switch clears resuming state and footer status", async () => {
+	test("session_before_switch clears pending compact, timers, and UI state", async () => {
+		let compactCalls = 0;
 		let compactOptions: Parameters<ExtensionContext["compact"]>[0];
-		const statusUpdates: Array<{ key: string; text: string | undefined }> = [];
-		const toolCtx = buildContext({ compact: () => {} });
-		const agentEndCtx = buildContext({
+		const widgetUpdates: Array<{ key: string; content: string[] | undefined }> = [];
+		const workingMessages: Array<string | undefined> = [];
+		const ctx = buildContext({
 			hasUI: true,
 			ui: {
-				setWorkingMessage: () => {},
-				setStatus: (key: string, text?: string) => {
-					statusUpdates.push({ key, text });
+				setWidget: (key: string, content?: string[]) => {
+					widgetUpdates.push({ key, content });
 				},
-			} as ExtensionContext["ui"],
+				setWorkingMessage: (message?: string) => {
+					workingMessages.push(message);
+				},
+			} as ExtensionUIContext,
 			compact: (options) => {
+				compactCalls++;
 				compactOptions = options;
 			},
+			isIdle: () => true,
 		});
 
-		await executeTool({ command: "compact" }, toolCtx);
-		await harness.fireEvent("agent_end", { type: "agent_end", messages: [] }, agentEndCtx);
-		compactOptions?.onComplete?.();
-
-		// Resuming status should be set
-		expect(statusUpdates.at(-1)).toEqual({ key: "compact", text: "⏳ resuming" });
-
-		// Session switch fires — should clear resuming state
-		const switchCtx = buildContext({
-			hasUI: true,
-			ui: {
-				setStatus: (key: string, text?: string) => {
-					statusUpdates.push({ key, text });
-				},
-			} as ExtensionContext["ui"],
-		});
+		await executeTool({ command: "compact" }, buildContext());
 		await harness.fireEvent(
 			"session_before_switch",
 			{ type: "session_before_switch", reason: "switch" },
-			switchCtx
+			ctx
 		);
+		await harness.fireEvent("turn_end", buildAssistantTurnEnd("toolUse"), ctx);
+		await harness.fireEvent("turn_end", buildAssistantTurnEnd("stop"), ctx);
+		expect(compactCalls).toBe(0);
 
-		expect(statusUpdates.at(-1)).toEqual({ key: "compact", text: undefined });
-
-		// Subsequent turn_start should be a no-op (flag was cleared)
-		const turnStatusUpdates: Array<{ key: string; text: string | undefined }> = [];
-		const turnCtx = buildContext({
-			hasUI: true,
-			ui: {
-				setStatus: (key: string, text?: string) => {
-					turnStatusUpdates.push({ key, text });
-				},
-			} as ExtensionContext["ui"],
-		});
-		await harness.fireEvent("turn_start", { type: "turn_start" }, turnCtx);
-
-		expect(turnStatusUpdates).toHaveLength(0);
-	});
-
-	test("session_before_switch cancels continuation timer", async () => {
-		let compactOptions: Parameters<ExtensionContext["compact"]>[0];
-		const toolCtx = buildContext({ compact: () => {} });
-		const agentEndCtx = buildContext({
-			hasUI: true,
-			ui: {
-				setWorkingMessage: () => {},
-				setStatus: () => {},
-			} as ExtensionContext["ui"],
-			compact: (options) => {
-				compactOptions = options;
-			},
-			isIdle: () => true,
-		});
-
-		await executeTool({ command: "compact" }, toolCtx);
-		await harness.fireEvent("agent_end", { type: "agent_end", messages: [] }, agentEndCtx);
-
-		// Trigger onComplete — starts the 200ms timer
+		await executeTool({ command: "compact" }, buildContext());
+		await harness.fireEvent("turn_end", buildAssistantTurnEnd("toolUse"), ctx);
+		await harness.fireEvent("turn_end", buildAssistantTurnEnd("stop"), ctx);
 		compactOptions?.onComplete?.();
-
-		// Session switch fires before timer expires
-		const switchCtx = buildContext({
-			hasUI: true,
-			ui: {
-				setStatus: () => {},
-			} as ExtensionContext["ui"],
-		});
 		await harness.fireEvent(
 			"session_before_switch",
 			{ type: "session_before_switch", reason: "switch" },
-			switchCtx
+			ctx
 		);
+		scheduler.advanceBy(200);
 
-		// Wait longer than the 200ms timeout
-		await new Promise((resolve) => setTimeout(resolve, 300));
-
-		// Timer was cancelled — no continuation message sent
-		const continuation = harness.sentMessages.find((m) => m.customType === "compact-continue");
-		expect(continuation).toBeUndefined();
-	});
-
-	test("repeated compact lifecycle does not leave duplicate heartbeat intervals", async () => {
-		const originalSetInterval = globalThis.setInterval;
-		const originalClearInterval = globalThis.clearInterval;
-		const createdHandles: unknown[] = [];
-		const clearedHandles: unknown[] = [];
-		let handleIndex = 0;
-
-		globalThis.setInterval = ((callback: Parameters<typeof setInterval>[0], _ms?: number) => {
-			void callback;
-			handleIndex += 1;
-			const handle = { id: handleIndex };
-			createdHandles.push(handle);
-			return handle as unknown as ReturnType<typeof setInterval>;
-		}) as typeof setInterval;
-		globalThis.clearInterval = ((handle?: ReturnType<typeof setInterval>) => {
-			clearedHandles.push(handle);
-		}) as typeof clearInterval;
-
-		try {
-			const toolCtx = buildContext({ compact: () => {} });
-			const agentEndCtx = buildContext({
-				hasUI: true,
-				ui: {
-					setWorkingMessage: () => {},
-					setStatus: () => {},
-				} as ExtensionContext["ui"],
-				compact: () => {},
-			});
-
-			await executeTool({ command: "compact" }, toolCtx);
-			await harness.fireEvent("agent_end", { type: "agent_end", messages: [] }, agentEndCtx);
-
-			await executeTool({ command: "compact" }, toolCtx);
-			await harness.fireEvent("agent_end", { type: "agent_end", messages: [] }, agentEndCtx);
-
-			await harness.fireEvent("session_before_switch", {
-				type: "session_before_switch",
-				reason: "switch",
-			});
-
-			expect(createdHandles).toHaveLength(2);
-			expect(clearedHandles).toContain(createdHandles[0]);
-			expect(clearedHandles).toContain(createdHandles[1]);
-		} finally {
-			globalThis.setInterval = originalSetInterval;
-			globalThis.clearInterval = originalClearInterval;
-		}
-	});
-
-	test("session_before_switch clears pending compact", async () => {
-		let compactCalled = false;
-		const toolCtx = buildContext({ compact: () => {} });
-		const agentEndCtx = buildContext({
-			compact: () => {
-				compactCalled = true;
-			},
-		});
-
-		// Set pending compact
-		await executeTool({ command: "compact" }, toolCtx);
-
-		// Session switch fires — should clear the flag
-		await harness.fireEvent("session_before_switch", {
-			type: "session_before_switch",
-			reason: "switch",
-		});
-
-		// agent_end should now be a no-op
-		await harness.fireEvent("agent_end", { type: "agent_end", messages: [] }, agentEndCtx);
-
-		expect(compactCalled).toBe(false);
-	});
-});
-
-// ── Error handling ───────────────────────────────────────────────────────────
-
-describe("error handling", () => {
-	test("rejects unknown commands", async () => {
-		const ctx = buildContext();
-
-		const result = await executeTool({ command: "nonexistent" }, ctx);
-
-		expect(result.isError).toBe(true);
-		const text = result.content[0];
-		if (text?.type === "text") {
-			expect(text.text).toContain("Unknown command");
-			expect(text.text).toContain("nonexistent");
-			expect(text.text).toContain("show-system-prompt");
-			expect(text.text).toContain("context");
-			expect(text.text).toContain("compact");
-		}
-	});
-
-	test("rejects commands with / prefix", async () => {
-		const ctx = buildContext();
-
-		const result = await executeTool({ command: "/compact" }, ctx);
-
-		expect(result.isError).toBe(true);
-	});
-
-	test("rejects empty command string", async () => {
-		const ctx = buildContext();
-
-		const result = await executeTool({ command: "" }, ctx);
-
-		expect(result.isError).toBe(true);
-	});
-});
-
-// ── Context injection ────────────────────────────────────────────────────────
-
-describe("context injection", () => {
-	test("injects hidden message listing bridged commands", async () => {
-		const results = await harness.fireEvent("before_agent_start", {
-			type: "before_agent_start",
-			prompt: "hello",
-			systemPrompt: "",
-		});
-
-		const result = results.find((r) => r != null) as
-			| {
-					message: { customType: string; content: string; display: boolean };
-			  }
-			| undefined;
-
-		expect(result).toBeDefined();
-		expect(result?.message.customType).toBe("slash-command-bridge-context");
-		expect(result?.message.display).toBe(false);
-		expect(result?.message.content).toContain("run_slash_command");
-	});
-
-	test("context message mentions available commands", async () => {
-		const results = await harness.fireEvent("before_agent_start", {
-			type: "before_agent_start",
-			prompt: "hello",
-			systemPrompt: "",
-		});
-
-		const result = results.find((r) => r != null) as
-			| {
-					message: { content: string };
-			  }
-			| undefined;
-
-		expect(result?.message.content).toContain("/show-system-prompt");
-		expect(result?.message.content).toContain("/context");
-		expect(result?.message.content).toContain("/compact");
+		expect(harness.sentMessages).toHaveLength(0);
+		expect(widgetUpdates.at(-1)).toEqual({ key: "compact-progress", content: undefined });
+		expect(workingMessages.at(-1)).toBeUndefined();
 	});
 });
-
-// ── Helpers ──────────────────────────────────────────────────────────────────
-
-/**
- * Build a mock ExtensionContext with overridable methods.
- *
- * @param overrides - Methods to override on the default stub context
- * @returns Mock ExtensionContext
- */
-function buildContext(overrides: Partial<ExtensionContext> = {}): ExtensionContext {
-	return {
-		ui: {} as ExtensionContext["ui"],
-		hasUI: false,
-		cwd: process.cwd(),
-		sessionManager: {} as ExtensionContext["sessionManager"],
-		modelRegistry: {} as ExtensionContext["modelRegistry"],
-		model: undefined,
-		isIdle: () => true,
-		abort: () => {},
-		hasPendingMessages: () => false,
-		shutdown: () => {},
-		getContextUsage: () => undefined,
-		compact: () => {},
-		getSystemPrompt: () => "",
-		...overrides,
-	};
-}
-
-/**
- * Waits for a given number of milliseconds.
- *
- * @param milliseconds - Delay duration in milliseconds
- * @returns Promise that resolves after the delay
- */
-function sleep(milliseconds: number): Promise<void> {
-	return new Promise((resolve) => setTimeout(resolve, milliseconds));
-}
-
-/**
- * Execute the run_slash_command tool with the given params and context.
- *
- * @param params - Tool parameters
- * @param ctx - Extension context (optional, uses default stub)
- * @returns Tool execution result
- */
-async function executeTool(params: { command: string }, ctx?: ExtensionContext) {
-	const tool = harness.tools.get("run_slash_command");
-	if (!tool) throw new Error("run_slash_command tool not registered");
-
-	return tool.execute("test-call-id", params, undefined, undefined, ctx ?? buildContext());
-}