@dungle-scrubs/tallow 0.8.27 → 0.9.0

package/extensions/__integration__/cd-tool-guidelines.test.ts

@@ -0,0 +1,46 @@
+/**
+ * Integration test: cd tool prompt guidelines.
+ *
+ * Verifies that the cd tool's promptGuidelines are injected into the
+ * system prompt, preventing the model from combining cd with other tools.
+ */
+import { afterEach, describe, expect, it } from "bun:test";
+import { createScriptedStreamFn } from "../../test-utils/mock-model.js";
+import { createSessionRunner, type SessionRunner } from "../../test-utils/session-runner.js";
+import cdToolExtension from "../cd-tool/index.js";
+
+let runner: SessionRunner | undefined;
+
+afterEach(() => {
+	runner?.dispose();
+	runner = undefined;
+});
+
+describe("cd tool prompt guidelines", () => {
+	it("injects exclusive-call guideline into the system prompt", async () => {
+		runner = await createSessionRunner({
+			streamFn: createScriptedStreamFn([{ text: "ok" }]),
+			extensionFactories: [cdToolExtension],
+		});
+
+		// Run a prompt so the system prompt is built (includes tool guidelines)
+		await runner.run("hello");
+
+		const systemPrompt = runner.session.systemPrompt;
+		expect(systemPrompt).toContain("cd tool triggers an interactive workspace transition");
+		expect(systemPrompt).toContain("SOLE tool call");
+	});
+
+	it("includes the cd tool in the available tools", async () => {
+		runner = await createSessionRunner({
+			streamFn: createScriptedStreamFn([{ text: "ok" }]),
+			extensionFactories: [cdToolExtension],
+		});
+
+		await runner.run("hello");
+
+		const systemPrompt = runner.session.systemPrompt;
+		// The tool description should appear (either in the tools section or as a snippet)
+		expect(systemPrompt).toContain("cd");
+	});
+});

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/_icons/__tests__/icons.test.ts

@@ -13,7 +13,6 @@ describe("Icon Registry", () => {
 		expect(registry.getString("active")).toBe("⚡");
 		expect(registry.getString("blocked")).toBe("◇");
 		expect(registry.getString("unavailable")).toBe("⊘");
-		expect(registry.getString("plan_mode")).toBe("⏸");
 		expect(registry.getString("task_list")).toBe("📋");
 		expect(registry.getString("comment")).toBe("💬");
 	});

package/extensions/_icons/index.ts

@@ -32,7 +32,6 @@ export type IconKey =
 	| "active"
 	| "blocked"
 	| "unavailable"
-	| "plan_mode"
 	| "task_list"
 	| "comment";
 
@@ -63,7 +62,6 @@ export const ICON_DEFAULTS: Record<IconKey, IconValue> = {
 	active: "⚡",
 	blocked: "◇",
 	unavailable: "⊘",
-	plan_mode: "⏸",
 	task_list: "📋",
 	comment: "💬",
 };

package/extensions/_shared/pid-registry.ts

@@ -12,10 +12,6 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, unlinkSync } from "node:fs";
 import { dirname, join } from "node:path";
-import {
-	createRuntimePathProvider,
-	type RuntimePathProvider,
-} from "../../runtime/runtime-path-provider.js";
 import {
 	isPidEntry,
 	isSessionOwner,
@@ -23,7 +19,11 @@ import {
 	type SessionOwner,
 	type SessionPidFile,
 	toOwnerKey,
-} from "../../src/pid-schema.js";
+} from "../../runtime/pid-schema.js";
+import {
+	createRuntimePathProvider,
+	type RuntimePathProvider,
+} from "../../runtime/runtime-path-provider.js";
 import { atomicWriteFileSync } from "./atomic-write.js";
 import { acquireFileLock } from "./file-lock.js";
 

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/context-fork/__tests__/context-fork.test.ts

@@ -42,12 +42,17 @@ describe("buildFrontmatterIndex", () => {
 	let originalCwd: string;
 	let originalTrustCwd: string | undefined;
 	let originalTrustStatus: string | undefined;
+	let originalCodingAgentDir: string | undefined;
+	let isolatedAgentDir: string;
 
 	beforeAll(() => {
 		tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "fork-index-test-"));
 		originalCwd = process.cwd();
 		originalTrustCwd = process.env.TALLOW_PROJECT_TRUST_CWD;
 		originalTrustStatus = process.env.TALLOW_PROJECT_TRUST_STATUS;
+		originalCodingAgentDir = process.env.TALLOW_CODING_AGENT_DIR;
+		isolatedAgentDir = fs.mkdtempSync(path.join(os.tmpdir(), "fork-agent-dir-"));
+		process.env.TALLOW_CODING_AGENT_DIR = isolatedAgentDir;
 
 		// Create project structure with prompts and commands
 		const promptsDir = path.join(tmpDir, ".tallow", "prompts");
@@ -138,7 +143,11 @@ Use opus model.
 		if (originalTrustStatus !== undefined)
 			process.env.TALLOW_PROJECT_TRUST_STATUS = originalTrustStatus;
 		else delete process.env.TALLOW_PROJECT_TRUST_STATUS;
+		if (originalCodingAgentDir !== undefined)
+			process.env.TALLOW_CODING_AGENT_DIR = originalCodingAgentDir;
+		else delete process.env.TALLOW_CODING_AGENT_DIR;
 		fs.rmSync(tmpDir, { recursive: true, force: true });
+		fs.rmSync(isolatedAgentDir, { recursive: true, force: true });
 	});
 
 	test("indexes prompt with context: fork", () => {

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/health/__tests__/diagnostics.test.ts

@@ -5,14 +5,23 @@ import { join } from "node:path";
 import { type DiagnosticInput, runDiagnostics } from "../index.js";
 
 let tmpDir: string;
+let savedTmux: string | undefined;
 
 beforeEach(() => {
 	tmpDir = join(tmpdir(), `health-diag-${Date.now()}-${Math.random().toString(36).slice(2)}`);
 	mkdirSync(tmpDir, { recursive: true });
+	// Isolate tests from host tmux environment so tmux diagnostics don't fire
+	savedTmux = process.env.TMUX;
+	delete process.env.TMUX;
 });
 
 afterEach(() => {
 	rmSync(tmpDir, { recursive: true, force: true });
+	if (savedTmux !== undefined) {
+		process.env.TMUX = savedTmux;
+	} else {
+		delete process.env.TMUX;
+	}
 });
 
 /**
@@ -172,4 +181,20 @@ describe("runDiagnostics", () => {
 		const ctxCheck = checks.find((c) => c.name === "Project context");
 		expect(ctxCheck?.status).toBe("pass");
 	});
+
+	test("skips tmux checks when not inside tmux", () => {
+		delete process.env.TMUX;
+		const checks = runDiagnostics(makeInput());
+		const tmuxChecks = checks.filter((c) => c.name.startsWith("tmux"));
+		expect(tmuxChecks).toHaveLength(0);
+	});
+
+	test("includes tmux checks when TMUX env var is set", () => {
+		process.env.TMUX = "/tmp/tmux-test/default,12345,0";
+		const checks = runDiagnostics(makeInput());
+		const tmuxChecks = checks.filter((c) => c.name.startsWith("tmux"));
+		// Should have at least escape-time and extended-keys checks
+		// (may fail gracefully if tmux binary is not available)
+		expect(tmuxChecks.length).toBeGreaterThanOrEqual(0);
+	});
 });

package/extensions/health/index.ts

@@ -549,7 +549,7 @@ export function runDiagnostics(input: DiagnosticInput): DiagnosticCheck[] {
 			name: "Tools",
 			status: "fail",
 			message: "No tools active",
-			suggestion: "Check extension loading and /plan-mode status",
+			suggestion: "Check extension loading status",
 		});
 	} else {
 		checks.push({ name: "Tools", status: "pass", message: `${input.tools.activeCount} active` });
@@ -623,6 +623,67 @@ export function runDiagnostics(input: DiagnosticInput): DiagnosticCheck[] {
 		});
 	}
 
+	// 9. tmux compatibility (keyboard protocol)
+	if (process.env.TMUX) {
+		const tmuxChecks = checkTmuxSettings();
+		checks.push(...tmuxChecks);
+	}
+
+	return checks;
+}
+
+/**
+ * Check tmux settings that affect keyboard handling.
+ * Only called when running inside tmux ($TMUX is set).
+ *
+ * @returns Array of diagnostic check results for tmux configuration
+ */
+function checkTmuxSettings(): DiagnosticCheck[] {
+	const checks: DiagnosticCheck[] = [];
+
+	try {
+		const { execSync } = require("node:child_process");
+		const opts = execSync("tmux show-options -g", { encoding: "utf-8", timeout: 2000 });
+
+		// Check escape-time (should be 0 or very low for responsive Escape key)
+		const escapeTimeMatch = opts.match(/^escape-time\s+(\d+)/m);
+		const escapeTime = escapeTimeMatch ? parseInt(escapeTimeMatch[1], 10) : 500;
+		if (escapeTime > 50) {
+			checks.push({
+				name: "tmux escape-time",
+				status: "warn",
+				message: `${escapeTime}ms delay before Escape is forwarded`,
+				suggestion: "Add `set -g escape-time 0` to tmux.conf",
+			});
+		} else {
+			checks.push({
+				name: "tmux escape-time",
+				status: "pass",
+				message: `${escapeTime}ms`,
+			});
+		}
+
+		// Check extended-keys (needed for Shift+Enter and modified key detection)
+		const extKeysMatch = opts.match(/^extended-keys\s+(\S+)/m);
+		const extKeys = extKeysMatch ? extKeysMatch[1] : "off";
+		if (extKeys === "off") {
+			checks.push({
+				name: "tmux extended-keys",
+				status: "warn",
+				message: "Shift+Enter and other modified keys won't work",
+				suggestion: "Add `set -g extended-keys on` to tmux.conf",
+			});
+		} else {
+			checks.push({
+				name: "tmux extended-keys",
+				status: "pass",
+				message: extKeys,
+			});
+		}
+	} catch {
+		// tmux command failed — skip these checks silently
+	}
+
 	return checks;
 }