@dungle-scrubs/tallow 0.8.21 → 0.8.23

package/extensions/__integration__/background-task-widget-ownership.test.ts

@@ -0,0 +1,216 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import type { ExtensionContext, ToolDefinition } from "@mariozechner/pi-coding-agent";
+import { ExtensionHarness } from "../../test-utils/extension-harness.js";
+import backgroundTasksExtension, {
+	setBackgroundTaskSpawnForTests,
+} from "../background-task-tool/index.js";
+import { registerTasksExtension } from "../tasks/commands/register-tasks-extension.js";
+import { TaskListStore } from "../tasks/state/index.js";
+
+const ORIGINAL_PI_IS_SUBAGENT = process.env.PI_IS_SUBAGENT;
+const ORIGINAL_PI_TEAM_NAME = process.env.PI_TEAM_NAME;
+
+interface CapturedWidget {
+	render: ((width: number) => string[]) | null;
+}
+
+interface WidgetCapture {
+	widgets: Map<string, CapturedWidget>;
+}
+
+/**
+ * Build an interactive-mode-like context that captures widgets by key.
+ *
+ * @param captured - Mutable widget capture registry
+ * @returns Extension context for event and tool execution
+ */
+function createContext(captured: WidgetCapture): ExtensionContext {
+	const theme = {
+		bold: (text: string) => text,
+		fg: (_color: unknown, text: string) => text,
+		strikethrough: (text: string) => text,
+	} as ExtensionContext["ui"]["theme"];
+
+	return {
+		ui: {
+			async confirm() {
+				return false;
+			},
+			async custom() {
+				return undefined as never;
+			},
+			async editor() {
+				return undefined;
+			},
+			get theme() {
+				return theme;
+			},
+			getAllThemes() {
+				return [];
+			},
+			getEditorText() {
+				return "";
+			},
+			getTheme() {
+				return undefined;
+			},
+			getToolsExpanded() {
+				return false;
+			},
+			async input() {
+				return undefined;
+			},
+			notify() {},
+			pasteToEditor() {},
+			async select() {
+				return undefined;
+			},
+			setEditorComponent() {},
+			setEditorText() {},
+			setFooter() {},
+			setHeader() {},
+			setStatus() {},
+			setTheme() {
+				return { success: false, error: "Test stub" };
+			},
+			setTitle() {},
+			setToolsExpanded() {},
+			setWidget(name, widget) {
+				if (!widget) {
+					captured.widgets.delete(name);
+					return;
+				}
+				if (Array.isArray(widget)) {
+					captured.widgets.set(name, {
+						render: () => widget,
+					});
+					return;
+				}
+				const component = widget(undefined as never, undefined as never);
+				captured.widgets.set(name, {
+					render: (width) => component.render(width),
+				});
+			},
+			setWorkingMessage() {},
+		} as ExtensionContext["ui"],
+		hasUI: true,
+		cwd: process.cwd(),
+		sessionManager: {
+			appendEntry: () => {},
+			getEntries: () => [],
+		} as never,
+		modelRegistry: {
+			getApiKeyForProvider: async () => undefined,
+		} as never,
+		model: undefined,
+		isIdle: () => true,
+		abort: () => {},
+		hasPendingMessages: () => false,
+		shutdown: () => {},
+		getContextUsage: () => undefined,
+		compact: () => {},
+		getSystemPrompt: () => "",
+	};
+}
+
+/**
+ * Read a registered tool by name.
+ *
+ * @param harness - Extension harness instance
+ * @param name - Tool name to resolve
+ * @returns Registered tool definition
+ */
+function getTool(harness: ExtensionHarness, name: string): ToolDefinition {
+	const tool = harness.tools.get(name);
+	if (!tool) throw new Error(`Expected tool "${name}" to be registered`);
+	return tool;
+}
+
+/**
+ * Execute a tool with the widget-capturing context.
+ *
+ * @param ctx - Extension execution context
+ * @param tool - Tool definition to execute
+ * @param params - Tool parameters
+ * @returns Tool result payload
+ */
+async function execTool(
+	ctx: ExtensionContext,
+	tool: ToolDefinition,
+	params: Record<string, unknown>
+): Promise<{ details: Record<string, unknown> }> {
+	return (await tool.execute("test-tool-call", params as never, undefined, undefined, ctx)) as {
+		details: Record<string, unknown>;
+	};
+}
+
+/**
+ * Render a captured widget to plain text.
+ *
+ * @param captured - Widget capture registry
+ * @param name - Widget key
+ * @param width - Terminal width to render at
+ * @returns Joined widget text
+ */
+function renderWidget(captured: WidgetCapture, name: string, width: number): string {
+	const widget = captured.widgets.get(name);
+	if (!widget?.render) throw new Error(`Expected widget "${name}" to be captured`);
+	return widget.render(width).join("\n");
+}
+
+beforeEach(() => {
+	process.env.PI_IS_SUBAGENT = "0";
+	delete process.env.PI_TEAM_NAME;
+	setBackgroundTaskSpawnForTests(undefined);
+});
+
+afterEach(() => {
+	setBackgroundTaskSpawnForTests(undefined);
+	if (ORIGINAL_PI_IS_SUBAGENT === undefined) delete process.env.PI_IS_SUBAGENT;
+	else process.env.PI_IS_SUBAGENT = ORIGINAL_PI_IS_SUBAGENT;
+	if (ORIGINAL_PI_TEAM_NAME === undefined) delete process.env.PI_TEAM_NAME;
+	else process.env.PI_TEAM_NAME = ORIGINAL_PI_TEAM_NAME;
+});
+
+describe("background task widget ownership", () => {
+	it("keeps the standalone bg-tasks widget when tasks is not registered", async () => {
+		const harness = ExtensionHarness.create();
+		const captured: WidgetCapture = { widgets: new Map() };
+		const ctx = createContext(captured);
+		backgroundTasksExtension(harness.api);
+
+		try {
+			await harness.fireEvent("session_start", {}, ctx);
+			const bgBash = getTool(harness, "bg_bash");
+			await execTool(ctx, bgBash, { command: "sleep 5" });
+
+			expect(captured.widgets.has("bg-tasks")).toBe(true);
+			expect(renderWidget(captured, "bg-tasks", 120)).toContain("sleep 5");
+		} finally {
+			await harness.fireEvent("session_shutdown", {}, ctx);
+			harness.reset();
+		}
+	});
+
+	it("suppresses the standalone widget when tasks owns background-task presentation", async () => {
+		const harness = ExtensionHarness.create();
+		const captured: WidgetCapture = { widgets: new Map() };
+		const ctx = createContext(captured);
+		backgroundTasksExtension(harness.api);
+		registerTasksExtension(harness.api, new TaskListStore(null), null);
+
+		try {
+			await harness.fireEvent("session_start", {}, ctx);
+			const bgBash = getTool(harness, "bg_bash");
+			await execTool(ctx, bgBash, { command: "sleep 5" });
+
+			expect(captured.widgets.has("bg-tasks")).toBe(false);
+			expect(captured.widgets.has("1-tasks")).toBe(true);
+			expect(renderWidget(captured, "1-tasks", 120)).toContain("Background Tasks (1)");
+			expect(renderWidget(captured, "1-tasks", 120)).toContain("sleep 5");
+		} finally {
+			await harness.fireEvent("session_shutdown", {}, ctx);
+			harness.reset();
+		}
+	});
+});

package/extensions/__integration__/claude-hooks-compat.test.ts

@@ -192,3 +192,159 @@ describe("Claude hooks compatibility integration", () => {
 		expect(handlers).not.toContain("echo project-claude");
 	});
 });
+
+describe("Package hooks with Claude format", () => {
+	it("translates Claude event names in package hooks.json", () => {
+		const pkgDir = join(cwd, "my-package");
+		writeJson(join(pkgDir, "hooks.json"), {
+			PreToolUse: [
+				{
+					matcher: "Bash",
+					hooks: [{ type: "command", command: "echo pkg-pre" }],
+				},
+			],
+			Stop: [
+				{
+					hooks: [{ type: "command", command: "echo pkg-stop" }],
+				},
+			],
+		});
+
+		writeJson(join(homeDir, ".tallow", "settings.json"), {
+			packages: [pkgDir],
+		});
+
+		const config = loadHooksConfig(cwd);
+		expect(config.tool_call).toHaveLength(1);
+		expect(config.tool_call[0]?.matcher).toBe("bash");
+		expect(config.tool_call[0]?.hooks[0]?.command).toBe("echo pkg-pre");
+		expect(config.tool_call[0]?.hooks[0]?._claudeSource).toBe(true);
+		expect(config.tool_call[0]?.hooks[0]?._claudeEventName).toBe("PreToolUse");
+		expect(config.agent_end).toHaveLength(1);
+		expect(config.agent_end[0]?.hooks[0]?.command).toBe("echo pkg-stop");
+	});
+
+	it("does not double-translate native tallow hooks in packages", () => {
+		const pkgDir = join(cwd, "native-package");
+		writeJson(join(pkgDir, "hooks.json"), {
+			tool_call: [
+				{
+					matcher: "bash",
+					hooks: [{ type: "command", command: "echo native" }],
+				},
+			],
+		});
+
+		writeJson(join(homeDir, ".tallow", "settings.json"), {
+			packages: [pkgDir],
+		});
+
+		const config = loadHooksConfig(cwd);
+		expect(config.tool_call).toHaveLength(1);
+		expect(config.tool_call[0]?.matcher).toBe("bash");
+		expect(config.tool_call[0]?.hooks[0]?.command).toBe("echo native");
+		expect(config.tool_call[0]?.hooks[0]?._claudeSource).toBeUndefined();
+	});
+
+	it("handles mixed Claude and native events in a package hooks.json", () => {
+		const pkgDir = join(cwd, "mixed-package");
+		writeJson(join(pkgDir, "hooks.json"), {
+			PreToolUse: [
+				{
+					matcher: "Edit|Write",
+					hooks: [{ type: "command", command: "echo claude-pre" }],
+				},
+			],
+			tool_call: [
+				{
+					matcher: "bash",
+					hooks: [{ type: "command", command: "echo native-tool" }],
+				},
+			],
+		});
+
+		writeJson(join(homeDir, ".tallow", "settings.json"), {
+			packages: [pkgDir],
+		});
+
+		const config = loadHooksConfig(cwd);
+		expect(config.tool_call).toHaveLength(2);
+		const commands = config.tool_call.map((entry) => entry.hooks[0]?.command);
+		expect(commands).toContain("echo claude-pre");
+		expect(commands).toContain("echo native-tool");
+	});
+
+	it("translates Claude hooks from project-level package settings", () => {
+		const pkgDir = join(cwd, "proj-pkg");
+		writeJson(join(pkgDir, "hooks.json"), {
+			UserPromptSubmit: [
+				{
+					hooks: [{ type: "command", command: "echo proj-input" }],
+				},
+			],
+		});
+
+		writeJson(join(cwd, ".tallow", "settings.json"), {
+			packages: [pkgDir],
+		});
+
+		const config = loadHooksConfig(cwd);
+		expect(config.input).toHaveLength(1);
+		expect(config.input[0]?.hooks[0]?.command).toBe("echo proj-input");
+		expect(config.input[0]?.hooks[0]?._claudeEventName).toBe("UserPromptSubmit");
+	});
+
+	it("blocks untrusted project package hooks with Claude format", () => {
+		const pkgDir = join(cwd, "untrusted-pkg");
+		writeJson(join(pkgDir, "hooks.json"), {
+			PreToolUse: [
+				{
+					matcher: "Bash",
+					hooks: [{ type: "command", command: "echo untrusted" }],
+				},
+			],
+		});
+
+		writeJson(join(cwd, ".tallow", "settings.json"), {
+			packages: [pkgDir],
+		});
+
+		process.env.TALLOW_PROJECT_TRUST_STATUS = "untrusted";
+		const config = loadHooksConfig(cwd);
+		expect(config.tool_call ?? []).toHaveLength(0);
+	});
+});
+
+describe("Extension hooks with Claude format", () => {
+	it("translates Claude event names in extension hooks.json", () => {
+		writeJson(join(homeDir, ".tallow", "extensions", "my-ext", "hooks.json"), {
+			PreToolUse: [
+				{
+					matcher: "Bash",
+					hooks: [{ type: "command", command: "echo ext-pre" }],
+				},
+			],
+		});
+
+		const config = loadHooksConfig(cwd);
+		expect(config.tool_call).toHaveLength(1);
+		expect(config.tool_call[0]?.matcher).toBe("bash");
+		expect(config.tool_call[0]?.hooks[0]?._claudeSource).toBe(true);
+	});
+
+	it("translates Claude hooks in project extension hooks.json", () => {
+		writeJson(join(cwd, ".tallow", "extensions", "proj-ext", "hooks.json"), {
+			PostToolUse: [
+				{
+					matcher: "Write",
+					hooks: [{ type: "command", command: "echo proj-ext-post" }],
+				},
+			],
+		});
+
+		const config = loadHooksConfig(cwd);
+		expect(config.tool_result).toHaveLength(1);
+		expect(config.tool_result[0]?.matcher).toBe("write");
+		expect(config.tool_result[0]?.hooks[0]?._claudeEventName).toBe("PostToolUse");
+	});
+});

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

@@ -1,23 +1,144 @@
 /**
- * Integration test for slash-command-bridge.
+ * Integration tests for slash-command-bridge.
  *
- * Verifies the tool works end-to-end via a session runner with a mock model
- * that invokes the run_slash_command tool.
+ * The compact regression uses the real headless session path and verifies the
+ * ordered lifecycle from tool result → deferred compact → resumed turn.
  */
 
-import { afterEach, describe, expect, it } from "bun:test";
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import type { AgentMessage } from "@mariozechner/pi-ai";
 import type { ExtensionAPI, ExtensionFactory } from "@mariozechner/pi-coding-agent";
+import { ManualTimerScheduler } from "../../test-utils/manual-timer-scheduler.js";
 import { createScriptedStreamFn } from "../../test-utils/mock-model.js";
 import { createSessionRunner, type SessionRunner } from "../../test-utils/session-runner.js";
-import slashCommandBridge from "../slash-command-bridge/index.js";
+import slashCommandBridge, {
+	resetSlashCommandBridgeStateForTests,
+	setSlashCommandBridgeSchedulerForTests,
+} from "../slash-command-bridge/index.js";
+
+interface CompactionTrackerState {
+	order: string[];
+	resumedAssistantCount: number;
+}
 
 let runner: SessionRunner | undefined;
+let scheduler: ManualTimerScheduler;
+
+beforeEach(() => {
+	scheduler = new ManualTimerScheduler();
+	setSlashCommandBridgeSchedulerForTests(scheduler.runtime);
+});
 
 afterEach(() => {
 	runner?.dispose();
 	runner = undefined;
+	resetSlashCommandBridgeStateForTests();
 });
 
+/**
+ * Returns assistant text content as a plain string for matcher-friendly assertions.
+ *
+ * @param message - Agent message to inspect
+ * @returns Flattened text content
+ */
+function getMessageText(message: AgentMessage): string {
+	if (typeof message.content === "string") {
+		return message.content;
+	}
+
+	return message.content
+		.filter((part) => part.type === "text")
+		.map((part) => part.text)
+		.join("\n");
+}
+
+/**
+ * Builds a tracking extension that records the compact lifecycle order.
+ *
+ * The hook also provides a deterministic compaction result so the regression can
+ * exercise the real deferred path without making a network summarization call.
+ *
+ * @param state - Shared mutable tracker state for assertions
+ * @returns Extension factory that records compact lifecycle events
+ */
+function buildCompactionTracker(state: CompactionTrackerState): ExtensionFactory {
+	return (pi: ExtensionAPI): void => {
+		pi.on("tool_result", async (event) => {
+			if (event.toolName !== "run_slash_command") {
+				return;
+			}
+			if ((event.details as { command?: string } | undefined)?.command !== "compact") {
+				return;
+			}
+			state.order.push("tool_result");
+		});
+
+		pi.on("turn_end", async (event) => {
+			if (event.message.role !== "assistant") {
+				return;
+			}
+			state.order.push(`turn_end:${event.message.stopReason}`);
+		});
+
+		pi.on("session_before_compact", async () => {
+			state.order.push("session_before_compact");
+			return {
+				compaction: {
+					summary: "mock compact summary",
+					firstKeptEntryId: undefined,
+					tokensBefore: 123,
+					details: { modifiedFiles: [], readFiles: [] },
+				},
+			};
+		});
+
+		pi.on("session_compact", async () => {
+			state.order.push("session_compact");
+		});
+
+		pi.on("message_end", async (event) => {
+			const text = getMessageText(event.message);
+			if (event.message.role === "custom" && text.includes("Session compaction is complete")) {
+				state.order.push("continuation_message");
+			}
+			if (event.message.role === "assistant" && text.includes("resumed after compact")) {
+				state.order.push("assistant_resumed");
+				state.resumedAssistantCount++;
+			}
+		});
+	};
+}
+
+/**
+ * Lets queued extension/session work settle after a prompt or timer advance.
+ *
+ * `session.prompt()` does not wait for all extension-side follow-up work, so the
+ * regression explicitly drains microtasks around `agent.waitForIdle()`.
+ *
+ * @param activeRunner - Runner whose session should be drained
+ * @returns Nothing
+ */
+async function flushSessionWork(activeRunner: SessionRunner): Promise<void> {
+	await Promise.resolve();
+	await Promise.resolve();
+	await activeRunner.session.agent.waitForIdle();
+	await Promise.resolve();
+	await Promise.resolve();
+	await activeRunner.session.agent.waitForIdle();
+	await Promise.resolve();
+}
+
+/**
+ * Returns the first index of a recorded lifecycle step.
+ *
+ * @param order - Recorded lifecycle events
+ * @param step - Step name to locate
+ * @returns Zero-based index in the order array
+ */
+function indexOfStep(order: readonly string[], step: string): number {
+	return order.indexOf(step);
+}
+
 describe("slash-command-bridge integration", () => {
 	it("model invokes show-system-prompt and receives prompt text", async () => {
 		const toolResults: string[] = [];
@@ -44,12 +165,11 @@ describe("slash-command-bridge integration", () => {
 		await runner.run("Show me the system prompt");
 
 		expect(toolResults).toHaveLength(1);
-		// System prompt exists and is non-empty in a real session
 		expect(toolResults[0].length).toBeGreaterThan(0);
 	});
 
 	it("model invokes context and receives usage data", async () => {
-		const toolResults: Array<{ text: string; isError: boolean }> = [];
+		const toolResults: Array<{ isError: boolean; text: string }> = [];
 
 		const tracker: ExtensionFactory = (pi: ExtensionAPI): void => {
 			pi.on("tool_result", async (event) => {
@@ -75,7 +195,6 @@ describe("slash-command-bridge integration", () => {
 		await runner.run("Check context usage");
 
 		expect(toolResults).toHaveLength(1);
-		// Context usage should contain token info (may be actual data or "no data" error)
 		expect(toolResults[0].text.length).toBeGreaterThan(0);
 	});
 
@@ -108,31 +227,58 @@ describe("slash-command-bridge integration", () => {
 		expect(toolResults[0]).toContain("reboot");
 	});
 
-	it("model invokes compact successfully", async () => {
-		const toolResults: string[] = [];
-
-		const tracker: ExtensionFactory = (pi: ExtensionAPI): void => {
-			pi.on("tool_result", async (event) => {
-				if (event.toolName === "run_slash_command") {
-					const text = event.content.find((c) => c.type === "text");
-					if (text?.type === "text") toolResults.push(text.text);
-				}
-			});
+	it("model-invoked compact preserves ordered lifecycle and resumes once", async () => {
+		const state: CompactionTrackerState = {
+			order: [],
+			resumedAssistantCount: 0,
 		};
 
 		runner = await createSessionRunner({
 			streamFn: createScriptedStreamFn([
+				{ text: "warmup" },
 				{
 					toolCalls: [{ name: "run_slash_command", arguments: { command: "compact" } }],
 				},
-				{ text: "Compaction started" },
+				{ text: "finish response" },
+				{ text: "resumed after compact" },
 			]),
-			extensionFactories: [slashCommandBridge, tracker],
+			extensionFactories: [slashCommandBridge, buildCompactionTracker(state)],
+			settings: {
+				compaction: {
+					enabled: true,
+					keepRecentTokens: 1,
+					reserveTokens: 10,
+				},
+			},
 		});
 
-		await runner.run("Compact the session");
+		await runner.run("warm up the session");
+		state.order.length = 0;
+		state.resumedAssistantCount = 0;
 
-		expect(toolResults).toHaveLength(1);
-		expect(toolResults[0]).toContain("compaction will begin");
+		await runner.run("compact the session");
+		scheduler.advanceBy(200);
+		await flushSessionWork(runner);
+
+		expect(state.resumedAssistantCount).toBe(1);
+		expect(state.order.filter((step) => step === "session_before_compact")).toHaveLength(1);
+		expect(state.order.filter((step) => step === "session_compact")).toHaveLength(1);
+		expect(state.order.filter((step) => step === "assistant_resumed")).toHaveLength(1);
+
+		const toolResultIndex = indexOfStep(state.order, "tool_result");
+		const toolUseTurnEndIndex = indexOfStep(state.order, "turn_end:toolUse");
+		const finalTurnEndIndex = indexOfStep(state.order, "turn_end:stop");
+		const beforeCompactIndex = indexOfStep(state.order, "session_before_compact");
+		const compactIndex = indexOfStep(state.order, "session_compact");
+		const continuationIndex = indexOfStep(state.order, "continuation_message");
+		const resumedIndex = indexOfStep(state.order, "assistant_resumed");
+
+		expect(toolResultIndex).toBeGreaterThanOrEqual(0);
+		expect(toolUseTurnEndIndex).toBeGreaterThan(toolResultIndex);
+		expect(finalTurnEndIndex).toBeGreaterThan(toolUseTurnEndIndex);
+		expect(beforeCompactIndex).toBeGreaterThan(finalTurnEndIndex);
+		expect(compactIndex).toBeGreaterThan(beforeCompactIndex);
+		expect(continuationIndex).toBeGreaterThan(compactIndex);
+		expect(resumedIndex).toBeGreaterThan(continuationIndex);
 	});
 });

package/extensions/_shared/atomic-write.ts

@@ -3,4 +3,4 @@
  *
  * Extensions should import from here rather than reaching into `src/`.
  */
-export { atomicWriteFileSync, restoreFromBackup } from "../../src/atomic-write.js";
+export { atomicWriteFileSync, restoreFromBackup } from "../../runtime/atomic-write.js";