@dungle-scrubs/tallow 0.8.26 → 0.8.28

package/extensions/__integration__/welcome-screen.test.ts

@@ -0,0 +1,240 @@
+/**
+ * E2E integration test for the welcome-screen extension.
+ *
+ * Boots a real tallow session with the bundled welcome-screen extension,
+ * binds extensions with a mock UI, and verifies:
+ * - setHeader IS called on fresh sessions
+ * - The rendered output contains the ASCII logo and version
+ * - setHeader is NOT called on resumed sessions with conversation history
+ */
+import { afterEach, describe, expect, it } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { visibleWidth } from "@mariozechner/pi-tui";
+import { TALLOW_VERSION } from "../../src/config.js";
+import { createTallowSession, type TallowSession } from "../../src/sdk.js";
+import { withExclusiveTallowHome } from "../../test-utils/tallow-home-env.js";
+import welcomeScreenExtension from "../welcome-screen/index.js";
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+/** Lines the ASCII logo must contain (stripped of ANSI). */
+const LOGO_FRAGMENTS = ["▐████████████▌", "████", "▐█▌"];
+
+// biome-ignore lint/suspicious/noControlCharactersInRegex: ANSI escape stripping requires matching \x1b
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+
+/** Strip ANSI escape sequences for content assertions. */
+function stripAnsi(s: string): string {
+	return s.replace(ANSI_RE, "");
+}
+
+/**
+ * Create a session with only the welcome-screen extension loaded.
+ *
+ * @param cwd - Working directory for the session
+ * @returns TallowSession promise
+ */
+function createWelcomeSession(cwd: string): Promise<TallowSession> {
+	return withExclusiveTallowHome(cwd, () =>
+		createTallowSession({
+			cwd,
+			provider: "anthropic",
+			apiKey: "test-key",
+			session: { type: "memory" },
+			noBundledExtensions: true,
+			noBundledSkills: true,
+			extensionFactories: [welcomeScreenExtension],
+		})
+	);
+}
+
+/**
+ * Build a mock UI context that captures setHeader calls.
+ *
+ * @returns Object with the UI context and captured state
+ */
+function createCapturingUI(): {
+	uiContext: Record<string, unknown>;
+	capture: {
+		setHeaderCalled: boolean;
+		headerFactory: ((tui: unknown, theme: unknown) => { render(w: number): string[] }) | null;
+	};
+} {
+	const capture = {
+		setHeaderCalled: false,
+		headerFactory: null as
+			| ((tui: unknown, theme: unknown) => { render(w: number): string[] })
+			| null,
+	};
+
+	const uiContext: Record<string, unknown> = {
+		notify: () => {},
+		confirm: async () => true,
+		input: async () => null,
+		select: async () => null,
+		custom: async () => null,
+		setWorkingMessage: () => {},
+		setHeader: (factory: typeof capture.headerFactory) => {
+			capture.setHeaderCalled = true;
+			capture.headerFactory = factory;
+		},
+		setFooter: () => {},
+		setToolsExpanded: () => {},
+		setEditorComponent: () => {},
+		addTerminalInputListener: () => () => {},
+		setStatus: () => {},
+		setWidget: () => {},
+		setTitle: () => {},
+		pasteToEditor: () => {},
+		setEditorText: () => {},
+		getEditorText: () => "",
+		editor: async () => undefined,
+		hasUI: true,
+	};
+	return { uiContext, capture };
+}
+
+let tmpDir: string | undefined;
+let session: TallowSession | undefined;
+
+afterEach(() => {
+	if (tmpDir) {
+		try {
+			rmSync(tmpDir, { recursive: true, force: true });
+		} catch {
+			// best-effort
+		}
+		tmpDir = undefined;
+	}
+	session = undefined;
+});
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe("welcome-screen E2E", () => {
+	it("calls setHeader with the ASCII logo on a fresh session", async () => {
+		tmpDir = mkdtempSync(join(tmpdir(), "tallow-welcome-e2e-"));
+		session = await createWelcomeSession(tmpDir);
+
+		const { uiContext, capture } = createCapturingUI();
+		await session.session.bindExtensions({ uiContext });
+
+		// ── setHeader must have been invoked ──
+		expect(capture.setHeaderCalled).toBe(true);
+		expect(capture.headerFactory).not.toBeNull();
+
+		// ── Render the header and validate content ──
+		const component = capture.headerFactory?.(null, null);
+		expect(component).toBeDefined();
+		expect(typeof component?.render).toBe("function");
+
+		const lines = component?.render(80) ?? [];
+		const plainLines = lines.map(stripAnsi);
+		const joined = plainLines.join("\n");
+
+		// Logo fragments must be present
+		for (const frag of LOGO_FRAGMENTS) {
+			expect(joined).toContain(frag);
+		}
+
+		// Version string must be present
+		expect(joined).toContain(`tallow v${TALLOW_VERSION}`);
+	}, 30_000);
+
+	it("renders lines centered within the given width", async () => {
+		tmpDir = mkdtempSync(join(tmpdir(), "tallow-welcome-e2e-"));
+		session = await createWelcomeSession(tmpDir);
+
+		const { uiContext, capture } = createCapturingUI();
+		await session.session.bindExtensions({ uiContext });
+
+		const component = capture.headerFactory?.(null, null);
+		expect(component).toBeDefined();
+
+		const width = 120;
+		const lines = component?.render(width) ?? [];
+
+		// Every line should fit within the width
+		for (const line of lines) {
+			expect(visibleWidth(line)).toBeLessThanOrEqual(width);
+		}
+
+		// Logo lines should be approximately centered (left padding > 0)
+		const logoLine = lines[0]; // first line = logo top bar
+		const leading = logoLine.length - logoLine.trimStart().length;
+		expect(leading).toBeGreaterThan(0);
+	}, 30_000);
+
+	it("does NOT call setHeader on a resumed session with conversation entries", async () => {
+		tmpDir = mkdtempSync(join(tmpdir(), "tallow-welcome-e2e-"));
+		session = await createWelcomeSession(tmpDir);
+
+		// Inject conversation entries to simulate a resumed session
+		const sm = session.session.sessionManager;
+		sm.appendMessage({
+			role: "user",
+			content: [{ type: "text", text: "hello" }],
+		});
+		sm.appendMessage({
+			role: "assistant",
+			content: [{ type: "text", text: "hi" }],
+		});
+
+		const { uiContext, capture } = createCapturingUI();
+		await session.session.bindExtensions({ uiContext });
+
+		// setHeader must NOT be called for resumed sessions
+		expect(capture.setHeaderCalled).toBe(false);
+	}, 30_000);
+
+	it("does NOT skip fresh sessions that only have metadata entries", async () => {
+		tmpDir = mkdtempSync(join(tmpdir(), "tallow-welcome-e2e-"));
+		session = await createWelcomeSession(tmpDir);
+
+		// Verify metadata entries exist but don't prevent the welcome screen
+		const entries = session.session.sessionManager.getEntries();
+		const metadataOnly = entries.every(
+			(e) => !("role" in e) || !["user", "assistant"].includes(String(e.role))
+		);
+		expect(metadataOnly).toBe(true);
+		expect(entries.length).toBeGreaterThan(0); // model_change, thinking_level_change
+
+		const { uiContext, capture } = createCapturingUI();
+		await session.session.bindExtensions({ uiContext });
+
+		// setHeader MUST be called even though metadata entries exist
+		expect(capture.setHeaderCalled).toBe(true);
+	}, 30_000);
+
+	it("defaults quietStartup to true so resource listing is suppressed", async () => {
+		tmpDir = mkdtempSync(join(tmpdir(), "tallow-welcome-e2e-"));
+		session = await createWelcomeSession(tmpDir);
+
+		// The settingsManager should have quietStartup=true by default,
+		// which suppresses the keybinding hints and [Context]/[Skills] listing.
+		const quiet = session.session.settingsManager.getQuietStartup();
+		expect(quiet).toBe(true);
+	}, 30_000);
+
+	it("respects explicit quietStartup=false override", async () => {
+		tmpDir = mkdtempSync(join(tmpdir(), "tallow-welcome-e2e-"));
+		session = await withExclusiveTallowHome(tmpDir, () =>
+			createTallowSession({
+				cwd: tmpDir ?? tmpdir(),
+				provider: "anthropic",
+				apiKey: "test-key",
+				session: { type: "memory" },
+				noBundledExtensions: true,
+				noBundledSkills: true,
+				extensionFactories: [welcomeScreenExtension],
+				settings: { quietStartup: false },
+			})
+		);
+
+		// User explicitly opted out — resource listing should be visible
+		const quiet = session.session.settingsManager.getQuietStartup();
+		expect(quiet).toBe(false);
+	}, 30_000);
+});

package/extensions/_shared/lazy-init.ts

@@ -7,6 +7,9 @@ const STARTUP_TIMING_ENV = "TALLOW_STARTUP_TIMING";
 /** String values that disable startup timing when set in the env var. */
 const DISABLED_TIMING_VALUES = new Set(["0", "false", "off", "no"]);
 
+/** Maximum backoff delay in milliseconds regardless of failure count. */
+const MAX_BACKOFF_MS = 30_000;
+
 /** Initialization outcome used in timing metadata. */
 type LazyInitStatus = "ok" | "error";
 
@@ -22,9 +25,21 @@ export interface LazyInitializerOptions<TContext> {
 	readonly name: string;
 	/** One-time async initializer invoked on first use. */
 	readonly initialize: (input: LazyInitInput<TContext>) => Promise<void>;
+	/**
+	 * Maximum number of consecutive failures before the initializer is permanently
+	 * failed. Once exhausted, `ensureInitialized()` rejects immediately without
+	 * attempting initialization again. Defaults to 3.
+	 */
+	readonly maxRetries?: number;
+	/**
+	 * Base delay in milliseconds used for exponential backoff between retries.
+	 * When a retry is attempted, the remaining portion of `retryBackoffMs * 2^(failureCount - 1)`
+	 * (capped at 30 seconds) is waited before running `initialize`. Defaults to 1000.
+	 */
+	readonly retryBackoffMs?: number;
 }
 
-/** One-time lazy initializer with in-flight dedupe. */
+/** One-time lazy initializer with in-flight dedupe and circuit-breaker. */
 export interface LazyInitializer<TContext> {
 	/**
 	 * Run initialization if needed.
@@ -32,7 +47,9 @@ export interface LazyInitializer<TContext> {
 	 * - First caller executes initialize().
 	 * - Concurrent callers await the same in-flight promise.
 	 * - After success, all callers resolve immediately.
-	 * - After failure, future callers retry.
+	 * - After failure, future callers retry (respecting backoff).
+	 * - After `maxRetries` consecutive failures, rejects immediately with the last
+	 *   error and makes no further attempts until `reset()` is called.
 	 *
 	 * @param input - Trigger + context payload for initialization
 	 * @returns Promise resolved when initialization is complete
@@ -40,6 +57,8 @@ export interface LazyInitializer<TContext> {
 	ensureInitialized(input: LazyInitInput<TContext>): Promise<void>;
 	/**
 	 * Reset completion state so the next ensureInitialized() call reruns init.
+	 * Also resets the consecutive failure counter, the backoff clock, and any
+	 * permanent failure state, allowing retries to begin again from scratch.
 	 * Does not cancel an in-flight initialization.
 	 *
 	 * @returns Nothing
@@ -51,6 +70,14 @@ export interface LazyInitializer<TContext> {
 	 * @returns True when initialized
 	 */
 	isInitialized(): boolean;
+	/**
+	 * Check whether the initializer has permanently failed after exhausting all
+	 * retries. When true, `ensureInitialized()` rejects immediately without making
+	 * any further initialization attempts. Call `reset()` to clear this state.
+	 *
+	 * @returns True when permanently failed
+	 */
+	isPermanentlyFailed(): boolean;
 }
 
 /**
@@ -122,7 +149,13 @@ function emitLazyInitTiming(
 }
 
 /**
- * Create a race-safe lazy initializer with one-time execution semantics.
+ * Create a race-safe lazy initializer with one-time execution semantics,
+ * exponential backoff between retries, and a circuit-breaker that permanently
+ * fails after `maxRetries` consecutive failures.
+ *
+ * Each call to `ensureInitialized` is a single attempt. On failure the promise
+ * rejects immediately, but the next caller will wait out the remaining backoff
+ * window before running `initialize` again.
  *
  * @param options - Initializer configuration
  * @returns Lazy initializer controller
@@ -130,18 +163,58 @@ function emitLazyInitTiming(
 export function createLazyInitializer<TContext>(
 	options: LazyInitializerOptions<TContext>
 ): LazyInitializer<TContext> {
+	const maxRetries = options.maxRetries ?? 3;
+	const retryBackoffMs = options.retryBackoffMs ?? 1000;
+
 	let initialized = false;
 	let inFlight: Promise<void> | null = null;
+	let failureCount = 0;
+	let permanentError: Error | null = null;
+	/** Timestamp (via performance.now) of the most recent failure, or null. */
+	let lastFailureTimeMs: number | null = null;
 
+	/**
+	 * Compute how many milliseconds remain in the current backoff window.
+	 * Returns 0 when no backoff is needed (first call or backoff already elapsed).
+	 *
+	 * @returns Remaining backoff delay in milliseconds
+	 */
+	const remainingBackoffMs = (): number => {
+		if (failureCount === 0 || lastFailureTimeMs === null) return 0;
+		const totalBackoff = Math.min(retryBackoffMs * 2 ** (failureCount - 1), MAX_BACKOFF_MS);
+		const elapsed = performance.now() - lastFailureTimeMs;
+		return Math.max(0, totalBackoff - elapsed);
+	};
+
+	/**
+	 * Execute one initialization attempt. Waits out any remaining backoff from
+	 * the previous failure before calling `initialize`. Timing is measured over
+	 * the `initialize` call only (backoff wait is excluded). On success, resets
+	 * the failure counter. On failure, increments it and sets `permanentError`
+	 * once `maxRetries` is exhausted.
+	 *
+	 * @param input - Trigger + context payload
+	 * @returns Promise that resolves on success or rejects with a normalized Error
+	 */
 	const runInitialization = async (input: LazyInitInput<TContext>): Promise<void> => {
+		// Wait out remaining backoff from the previous failure before attempting.
+		const backoff = remainingBackoffMs();
+		if (backoff > 0) {
+			await new Promise<void>((resolve) => setTimeout(resolve, backoff));
+		}
+
 		const startedAtMs = performance.now();
 		try {
 			await options.initialize(input);
 			initialized = true;
+			failureCount = 0;
+			lastFailureTimeMs = null;
 			emitLazyInitTiming(options.name, input.trigger, performance.now() - startedAtMs, "ok");
 		} catch (error) {
 			const normalized = toError(error);
 			initialized = false;
+			failureCount++;
+			lastFailureTimeMs = performance.now();
 			emitLazyInitTiming(
 				options.name,
 				input.trigger,
@@ -149,12 +222,18 @@ export function createLazyInitializer<TContext>(
 				"error",
 				normalized
 			);
+			if (failureCount >= maxRetries) {
+				permanentError = normalized;
+			}
 			throw normalized;
 		}
 	};
 
 	return {
 		ensureInitialized(input: LazyInitInput<TContext>): Promise<void> {
+			if (permanentError) {
+				return Promise.reject(permanentError);
+			}
 			if (initialized) {
 				return Promise.resolve();
 			}
@@ -169,9 +248,15 @@ export function createLazyInitializer<TContext>(
 		},
 		reset(): void {
 			initialized = false;
+			failureCount = 0;
+			permanentError = null;
+			lastFailureTimeMs = null;
 		},
 		isInitialized(): boolean {
 			return initialized;
 		},
+		isPermanentlyFailed(): boolean {
+			return permanentError !== null;
+		},
 	};
 }

package/extensions/_shared/pid-registry.ts

@@ -12,6 +12,14 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, unlinkSync } from "node:fs";
 import { dirname, join } from "node:path";
+import {
+	isPidEntry,
+	isSessionOwner,
+	type PidEntry,
+	type SessionOwner,
+	type SessionPidFile,
+	toOwnerKey,
+} from "../../runtime/pid-schema.js";
 import {
 	createRuntimePathProvider,
 	type RuntimePathProvider,
@@ -19,31 +27,6 @@ import {
 import { atomicWriteFileSync } from "./atomic-write.js";
 import { acquireFileLock } from "./file-lock.js";
 
-// ─── Types (mirror src/pid-manager.ts) ──────────────────────────────────────
-
-/** Session owner identity used for per-session PID files. */
-interface SessionOwner {
-	pid: number;
-	startedAt?: string;
-}
-
-/** A single tracked child process entry. */
-interface PidEntry {
-	pid: number;
-	command: string;
-	ownerPid?: number;
-	ownerStartedAt?: string;
-	processStartedAt?: string;
-	startedAt: number;
-}
-
-/** On-disk session PID file schema (version 2). */
-interface SessionPidFile {
-	version: 2;
-	owner: SessionOwner;
-	entries: PidEntry[];
-}
-
 // ─── Owner/session path helpers ─────────────────────────────────────────────
 
 /** Cached owner identity for this process. */
@@ -89,21 +72,6 @@ function getSessionPidDir(): string {
 	return pidRegistryPathProvider.getSessionPidDir();
 }
 
-/**
- * Convert owner metadata into a filesystem-safe key.
- *
- * @param owner - Session owner identity
- * @returns Filename-safe owner key
- */
-function toOwnerKey(owner: SessionOwner): string {
-	const startedAtSlug = (owner.startedAt ?? "unknown")
-		.replace(/[^A-Za-z0-9._-]+/g, "-")
-		.replace(/-+/g, "-")
-		.replace(/^-+|-+$/g, "");
-	const normalizedStartedAt = startedAtSlug.length > 0 ? startedAtSlug : "unknown";
-	return `${owner.pid}-${normalizedStartedAt}`;
-}
-
 /**
  * Resolve the current session PID file path.
  *
@@ -150,48 +118,6 @@ function getCurrentOwnerIdentity(): SessionOwner {
 
 // ─── Validation ──────────────────────────────────────────────────────────────
 
-/**
- * Check whether a value matches the session-owner schema.
- *
- * @param value - Unknown JSON value to validate
- * @returns True when value is a valid session owner
- */
-function isSessionOwner(value: unknown): value is SessionOwner {
-	if (!value || typeof value !== "object") return false;
-	const candidate = value as Record<string, unknown>;
-	if (typeof candidate.pid !== "number") return false;
-	if (candidate.startedAt != null && typeof candidate.startedAt !== "string") {
-		return false;
-	}
-	return true;
-}
-
-/**
- * Check whether a value matches the PID entry schema.
- *
- * Supports legacy entries without owner/process identity metadata.
- *
- * @param value - Unknown JSON value to validate
- * @returns True when the value is a supported PID entry
- */
-function isPidEntry(value: unknown): value is PidEntry {
-	if (!value || typeof value !== "object") return false;
-	const candidate = value as Record<string, unknown>;
-	if (typeof candidate.pid !== "number") return false;
-	if (typeof candidate.command !== "string") return false;
-	if (typeof candidate.startedAt !== "number") return false;
-	if (candidate.ownerPid != null && typeof candidate.ownerPid !== "number") {
-		return false;
-	}
-	if (candidate.ownerStartedAt != null && typeof candidate.ownerStartedAt !== "string") {
-		return false;
-	}
-	if (candidate.processStartedAt != null && typeof candidate.processStartedAt !== "string") {
-		return false;
-	}
-	return true;
-}
-
 /**
  * Validate and normalize raw session PID file JSON.
  *

package/extensions/background-task-tool/index.ts

@@ -1076,7 +1076,7 @@ export default function backgroundTasksExtension(pi: ExtensionAPI): void {
 
 						if (!expanded && truncated) {
 							lines.push(
-								formatPresentationText(theme, "hint", keyHint("expandTools", "to show more"))
+								formatPresentationText(theme, "hint", keyHint("app.tools.expand", "to show more"))
 							);
 						}
 					} else {

package/extensions/cd-tool/index.ts

@@ -283,7 +283,10 @@ export default function (pi: ExtensionAPI): void {
 		name: "cd",
 		label: "cd",
 		description:
-			"Request an interactive workspace transition to another directory. Requires explicit user approval and restarts the turn in the new workspace.",
+			"Request an interactive workspace transition to another directory. Requires explicit user approval and restarts the turn in the new workspace. IMPORTANT: cd must be the ONLY tool call in your response — never combine it with other tools (edit, bash, write, etc.). The transition restarts the turn and discards sibling tool results.",
+		promptGuidelines: [
+			"The cd tool triggers an interactive workspace transition that restarts the current turn. When you need to cd, emit it as the SOLE tool call in your response — do not pair it with edit, bash, write, read, or any other tool. Sibling tool calls will race against the transition and their results will be lost when the turn restarts.",
+		],
 		parameters: Type.Object({
 			path: Type.String({
 				description: "Directory path to open via the interactive workspace transition flow",

package/extensions/cheatsheet/__tests__/cheatsheet.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, test } from "bun:test";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import cheatsheet from "../index.js";
+
+describe("cheatsheet extension", () => {
+	function collectRegistrations() {
+		const commands: Array<{ name: string; description: string }> = [];
+		const pi = {
+			registerCommand: (name: string, opts: { description: string }) => {
+				commands.push({ name, description: opts.description });
+			},
+			registerMessageRenderer: () => {},
+			registerShortcut: () => {},
+			on: () => {},
+		} as unknown as ExtensionAPI;
+
+		cheatsheet(pi);
+		return { commands };
+	}
+
+	test("registers /cheatsheet command", () => {
+		const { commands } = collectRegistrations();
+		expect(commands.some((c) => c.name === "cheatsheet")).toBe(true);
+	});
+
+	test("registers /keys alias", () => {
+		const { commands } = collectRegistrations();
+		expect(commands.some((c) => c.name === "keys")).toBe(true);
+	});
+
+	test("registers /keymap alias", () => {
+		const { commands } = collectRegistrations();
+		expect(commands.some((c) => c.name === "keymap")).toBe(true);
+	});
+
+	test("registers /keybindings alias", () => {
+		const { commands } = collectRegistrations();
+		expect(commands.some((c) => c.name === "keybindings")).toBe(true);
+	});
+
+	test("all aliases have descriptions", () => {
+		const { commands } = collectRegistrations();
+		for (const cmd of commands) {
+			expect(cmd.description.length).toBeGreaterThan(0);
+		}
+	});
+});

package/extensions/clear/__tests__/clear.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, mock, test } from "bun:test";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import registerClear from "../index.js";
+
+describe("clear extension", () => {
+	test("registers /clear command", () => {
+		const commands: Array<{ name: string; description: string }> = [];
+		const pi = {
+			registerCommand: (name: string, opts: { description: string }) => {
+				commands.push({ name, description: opts.description });
+			},
+		} as unknown as ExtensionAPI;
+
+		registerClear(pi);
+
+		expect(commands).toHaveLength(1);
+		expect(commands[0].name).toBe("clear");
+		expect(commands[0].description).toContain("new session");
+	});
+
+	test("handler calls ctx.newSession()", async () => {
+		let handler: ((args: string, ctx: unknown) => Promise<void>) | undefined;
+		const pi = {
+			registerCommand: (
+				_name: string,
+				opts: { handler: (args: string, ctx: unknown) => Promise<void> }
+			) => {
+				handler = opts.handler;
+			},
+		} as unknown as ExtensionAPI;
+
+		registerClear(pi);
+
+		const newSession = mock(() => Promise.resolve());
+		await handler!("", { newSession });
+		expect(newSession).toHaveBeenCalledTimes(1);
+	});
+});

package/extensions/edit-tool-enhanced/index.ts

@@ -93,6 +93,7 @@ export default function editLive(pi: ExtensionAPI): void {
 		label: baseEditTool.label,
 		description: baseEditTool.description,
 		parameters: baseEditTool.parameters,
+		prepareArguments: baseEditTool.prepareArguments,
 
 		renderCall(args, theme) {
 			const path = args.path ?? "file";
@@ -109,7 +110,8 @@ export default function editLive(pi: ExtensionAPI): void {
 			const filePath = params.path ?? "file";
 			const effectiveCwd = ctx?.cwd ?? process.cwd();
 			const scopedEditTool = createEditTool(effectiveCwd);
-			const result = await scopedEditTool.execute(toolCallId, params, signal, onUpdate);
+			const prepared = scopedEditTool.prepareArguments?.(params) ?? params;
+			const result = await scopedEditTool.execute(toolCallId, prepared, signal, onUpdate);
 			const details = result.details as EditToolDetails | undefined;
 			const diff = details?.diff ?? "";
 			const absoluteFilename = path.isAbsolute(filePath)

package/extensions/git-status/__tests__/git-status.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, test } from "bun:test";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import gitStatus from "../index.js";
+
+describe("git-status extension", () => {
+	test("registers session_start, tool_result, and session_shutdown handlers", () => {
+		const events: string[] = [];
+		const pi = {
+			on: (event: string) => {
+				events.push(event);
+			},
+		} as unknown as ExtensionAPI;
+
+		gitStatus(pi);
+		expect(events).toContain("session_start");
+		expect(events).toContain("tool_result");
+		expect(events).toContain("session_shutdown");
+	});
+
+	test("does not register any commands", () => {
+		const commands: string[] = [];
+		const pi = {
+			on: () => {},
+			registerCommand: (name: string) => {
+				commands.push(name);
+			},
+		} as unknown as ExtensionAPI;
+
+		gitStatus(pi);
+		expect(commands).toHaveLength(0);
+	});
+});