gsd-pi 2.80.0-dev.8b3a59f5c → 2.80.0-dev.b2a374d5b

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

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

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

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

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

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

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

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

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

@@ -235,6 +235,7 @@ export class ExtensionRunner {
 	private getContextUsageFn: () => ContextUsage | undefined = () => undefined;
 	private compactFn: (options?: CompactOptions) => void = () => {};
 	private getSystemPromptFn: () => string = () => "";
+	private setCompactionThresholdOverrideFn: (percent: number | undefined) => void = () => {};
 	private newSessionHandler: NewSessionHandler = async () => {
 		throw new Error("Command context not yet bound: newSession is unavailable during early lifecycle");
 	};
@@ -428,6 +429,7 @@ export class ExtensionRunner {
 		this.getContextUsageFn = contextActions.getContextUsage;
 		this.compactFn = contextActions.compact;
 		this.getSystemPromptFn = contextActions.getSystemPrompt;
+		this.setCompactionThresholdOverrideFn = contextActions.setCompactionThresholdOverride;
 
 		// Flush provider registrations queued during extension loading
 		for (const { name, config } of this.runtime.pendingProviderRegistrations) {
@@ -714,9 +716,23 @@ export class ExtensionRunner {
 			getContextUsage: () => this.getContextUsageFn(),
 			compact: (options) => this.compactFn(options),
 			getSystemPrompt: () => this.getSystemPromptFn(),
+			setCompactionThresholdOverride: (percent) => this.setCompactionThresholdOverrideFn(percent),
 		};
 	}
 
+	private createEventContext(eventType: string): ExtensionContext {
+		return {
+			...this.createContext(),
+			shutdown: () => {
+				throw new Error(`Extension event '${eventType}' cannot request TUI shutdown`);
+			},
+		};
+	}
+
+	private isShutdownGuardedEvent(eventType: string): boolean {
+		return eventType === "agent_end" || eventType === "stop" || eventType === "session_end";
+	}
+
 	createCommandContext(): ExtensionCommandContext {
 		return {
 			...this.createContext(),
@@ -757,7 +773,9 @@ export class ExtensionRunner {
 		getEvent: () => unknown,
 		processResult: (handlerResult: unknown, extensionPath: string) => { done: boolean },
 	): Promise<void> {
-		const ctx = this.createContext();
+		const ctx = this.isShutdownGuardedEvent(eventType)
+			? this.createEventContext(eventType)
+			: this.createContext();
 
 		for (const ext of this.extensions) {
 			const handlers = ext.handlers.get(eventType);

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

@@ -289,6 +289,12 @@ export interface ExtensionContext {
 	compact(options?: CompactOptions): void;
 	/** Get the current effective system prompt. */
 	getSystemPrompt(): string;
+	/**
+	 * Set or clear an in-memory compaction threshold-percent override (0 < value < 1).
+	 * Pass `undefined` to clear. The override is not persisted; host integrations
+	 * are expected to re-apply on each session_start.
+	 */
+	setCompactionThresholdOverride(percent: number | undefined): void;
 }
 
 /**
@@ -1741,6 +1747,7 @@ export interface ExtensionContextActions {
 	getContextUsage: () => ContextUsage | undefined;
 	compact: (options?: CompactOptions) => void;
 	getSystemPrompt: () => string;
+	setCompactionThresholdOverride: (percent: number | undefined) => void;
 }
 
 /**

package/packages/pi-coding-agent/src/core/settings-manager.ts

@@ -15,6 +15,13 @@ export interface CompactionSettings {
 	enabled?: boolean; // default: true
 	reserveTokens?: number; // default: 16384
 	keepRecentTokens?: number; // default: 20000
+	/**
+	 * Optional percent-of-context-window trigger (0 < value < 1). When set,
+	 * compaction fires at `contextWindow * thresholdPercent` and overrides
+	 * `reserveTokens`. Typically set as a runtime override by host integrations
+	 * (see `setCompactionThresholdOverride`) and not persisted by users directly.
+	 */
+	thresholdPercent?: number;
 }
 
 export interface BranchSummarySettings {
@@ -812,11 +819,42 @@ export class SettingsManager {
 		return this.settings.compaction?.keepRecentTokens ?? COMPACTION_KEEP_RECENT_TOKENS;
 	}
 
-	getCompactionSettings(): { enabled: boolean; reserveTokens: number; keepRecentTokens: number } {
+	getCompactionThresholdPercent(): number | undefined {
+		return this.settings.compaction?.thresholdPercent;
+	}
+
+	/**
+	 * Set or clear an in-memory compaction threshold-percent override.
+	 *
+	 * Applied to `this.settings` only; never persisted to disk. Pass `undefined`
+	 * to clear a previously set override (necessary for idempotent re-sync from
+	 * host integrations whose preference may have been removed).
+	 *
+	 * Direct mutation is used instead of `applyOverrides()` because deep-merge
+	 * semantics skip `undefined` values, which would prevent clearing.
+	 */
+	setCompactionThresholdOverride(percent: number | undefined): void {
+		if (!this.settings.compaction) {
+			this.settings.compaction = {};
+		}
+		if (percent === undefined) {
+			delete this.settings.compaction.thresholdPercent;
+		} else {
+			this.settings.compaction.thresholdPercent = percent;
+		}
+	}
+
+	getCompactionSettings(): {
+		enabled: boolean;
+		reserveTokens: number;
+		keepRecentTokens: number;
+		thresholdPercent?: number;
+	} {
 		return {
 			enabled: this.getCompactionEnabled(),
 			reserveTokens: this.getCompactionReserveTokens(),
 			keepRecentTokens: this.getCompactionKeepRecentTokens(),
+			thresholdPercent: this.getCompactionThresholdPercent(),
 		};
 	}
 

package/packages/pi-coding-agent/src/modes/interactive/components/__tests__/chat-frame-compaction-tone.test.ts

@@ -1,3 +1,4 @@
+// GSD2 TUI Tests - Chat frame card visual contract coverage.
 import { test, describe } from "node:test";
 import assert from "node:assert/strict";
 import stripAnsi from "strip-ansi";
@@ -8,12 +9,12 @@ initTheme("dark", false);
 
 // Regression tests for the "compaction" tone added to renderChatFrame.
 // The compaction notice shares the same visual frame as user / assistant
-// messages (top rule, `• label` header, `│ ` body prefix) but uses the
+// messages (top rule, label header, `│ ` body prefix) but uses the
 // purple `customMessageLabel` color key so it is visually distinct from
 // conversation turns.
 
 describe("renderChatFrame — compaction tone", () => {
-	test("produces a top rule, `• compaction` header row, and a │ body margin", () => {
+	test("produces a top rule, compaction header row, and a │ body margin", () => {
 		const lines = renderChatFrame(
 			["Compacted from 1,224,262 tokens (ctrl+o to expand)"],
 			60,
@@ -33,11 +34,12 @@ describe("renderChatFrame — compaction tone", () => {
 		// Top rule is a solid horizontal bar
 		assert.match(plain[0], /^─+$/, "first line should be the solid top rule");
 
-		// Header row contains `• compaction`
+		// Header row contains `compaction`
 		assert.ok(
-			plain[1].includes("• compaction"),
-			`expected header to contain "• compaction", got ${JSON.stringify(plain[1])}`,
+			plain[1].includes("compaction"),
+			`expected header to contain "compaction", got ${JSON.stringify(plain[1])}`,
 		);
+		assert.ok(!plain[1].includes("•"), `header should not render a bullet prefix, got ${JSON.stringify(plain[1])}`);
 
 		// Body line(s) start with `│ `
 		assert.ok(

package/packages/pi-coding-agent/src/modes/interactive/components/__tests__/tool-execution.test.ts

@@ -51,24 +51,26 @@ function renderToolCollapsed(
 }
 
 describe("ToolExecutionComponent", () => {
-	test("renders framed header with Running status while tool is partial", () => {
+	test("renders framed header with running status while tool is partial", () => {
 		const rendered = renderToolCollapsed("mcp__demo__do_thing", { ok: true });
 
-		assert.match(rendered, /Tool demo\u00b7do_thing/);
-		assert.match(rendered, /Running/);
-		assert.match(rendered, /Running · \d+(ms|s)/);
+		assert.match(rendered, /demo\u00b7do_thing/);
+		assert.doesNotMatch(rendered, /Tool demo\u00b7do_thing/);
+		assert.match(rendered, /running/);
+		assert.match(rendered, /running · \d+(ms|s)/);
 	});
 
-	test("renders framed header with Error status for failed tool result", () => {
+	test("renders framed header with failed status for failed tool result", () => {
 		const rendered = renderTool(
 			"mcp__demo__do_thing",
 			{ ok: true },
 			{ content: [{ type: "text", text: "boom" }], isError: true },
 		);
 
-		assert.match(rendered, /Tool demo\u00b7do_thing/);
-		assert.match(rendered, /Error/);
-		assert.match(rendered, /Error · \d+(ms|s)/);
+		assert.match(rendered, /demo\u00b7do_thing/);
+		assert.doesNotMatch(rendered, /Tool demo\u00b7do_thing/);
+		assert.match(rendered, /failed/);
+		assert.match(rendered, /failed · \d+(ms|s)/);
 		assert.match(rendered, /boom/);
 	});
 
@@ -79,8 +81,9 @@ describe("ToolExecutionComponent", () => {
 			{ content: [], isError: false },
 		);
 
-		assert.match(rendered, /Done · \d+(ms|s)/);
-		assert.match(rendered, /Completed/);
+		assert.match(rendered, /success · \d+(ms|s)/);
+		assert.match(rendered, /demo\u00b7noop/);
+		assert.doesNotMatch(rendered, /Completed/);
 		assert.doesNotMatch(rendered, /ok=true/);
 	});
 
@@ -97,7 +100,7 @@ describe("ToolExecutionComponent", () => {
 		assert.deepEqual(component.getRollupPhase()?.label, "Requirement writes");
 	});
 
-	test("does not expose phase metadata for output-bearing tools", () => {
+	test("exposes phase metadata for collapsed output-bearing generic tools", () => {
 		const component = new ToolExecutionComponent(
 			"mcp__demo__do_thing",
 			{ ok: true },
@@ -107,7 +110,7 @@ describe("ToolExecutionComponent", () => {
 		);
 		component.updateResult({ content: [{ type: "text", text: "important output" }], isError: false });
 
-		assert.equal(component.getRollupPhase(), null);
+		assert.deepEqual(component.getRollupPhase()?.label, "Other tool actions");
 	});
 
 	test("renders phase-based summaries for rolled-up tool executions", () => {
@@ -143,7 +146,7 @@ describe("ToolExecutionComponent", () => {
 			},
 		);
 
-		assert.match(rendered, /Error/);
+		assert.match(rendered, /failed/);
 		assert.match(rendered, /custom saw error/);
 		assert.doesNotMatch(rendered, /custom saw success/);
 	});
@@ -206,14 +209,16 @@ describe("ToolExecutionComponent", () => {
 			{ label: "Complete Slice" },
 		);
 
-		assert.match(rendered, /Tool Complete Slice/);
+		assert.match(rendered, /Complete Slice/);
+		assert.doesNotMatch(rendered, /Tool Complete Slice/);
 		assert.doesNotMatch(rendered, /gsd_slice_complete/);
 	});
 
 	test("frame header strips gsd_ prefix and title-cases when no label is registered", () => {
 		const rendered = renderToolCollapsed("gsd_requirement_update", { id: "R005" });
 
-		assert.match(rendered, /Tool Requirement Update/);
+		assert.match(rendered, /Requirement Update/);
+		assert.doesNotMatch(rendered, /Tool Requirement Update/);
 		assert.doesNotMatch(rendered, /gsd_requirement_update/);
 	});
 
@@ -242,7 +247,7 @@ describe("ToolExecutionComponent", () => {
 		assert.doesNotMatch(rendered, /…/);
 	});
 
-	test("generic fallback truncates long output when collapsed", () => {
+	test("generic fallback collapses successful output rows until expanded", () => {
 		const longOutput = Array.from({ length: 25 }, (_, i) => `line ${i + 1}`).join("\n");
 		const rendered = renderToolCollapsed(
 			"mcp__demo__do_thing",
@@ -250,10 +255,10 @@ describe("ToolExecutionComponent", () => {
 			{ content: [{ type: "text", text: longOutput }], isError: false },
 		);
 
-		assert.match(rendered, /line 1\b/);
-		assert.match(rendered, /line 10\b/);
-		assert.doesNotMatch(rendered, /line 20\b/);
-		assert.match(rendered, /\(15 more lines/);
+		assert.match(rendered, /demo\u00b7do_thing/);
+		assert.match(rendered, /success · \d+(ms|s)/);
+		assert.doesNotMatch(rendered, /line 1\b/);
+		assert.doesNotMatch(rendered, /\(15 more lines/);
 	});
 
 	test("generic fallback falls back to truncated JSON for complex args", () => {

package/packages/pi-coding-agent/src/modes/interactive/components/adaptive-layout.ts

@@ -126,8 +126,8 @@ export class AdaptiveLayoutComponent implements Component {
 
 	private frame(lines: string[], width: number, title: string, rightTitle: string, accent: ThemeColor): string[] {
 		return style()
-			.border("rounded")
-			.density("comfortable")
+			.border("rule")
+			.density("compact")
 			.toneColor((text) => theme.fg("surfaceMuted", text))
 			.borderColor((text) => theme.fg("surfaceBorder", text))
 			.title(theme.fg("surfaceTitle", title))

package/packages/pi-coding-agent/src/modes/interactive/components/assistant-message.ts

@@ -1,3 +1,4 @@
+// GSD2 TUI - Assistant message card renderer for interactive terminal sessions.
 import type { AssistantMessage } from "@gsd/pi-ai";
 import { Container, Markdown, type MarkdownTheme, Spacer, Text } from "@gsd/pi-tui";
 import { getMarkdownTheme, theme } from "../theme/theme.js";

package/packages/pi-coding-agent/src/modes/interactive/components/chat-frame.ts

@@ -1,3 +1,4 @@
+// GSD2 TUI - Shared chat frame renderer for assistant, user, and system cards.
 import { style, truncateToWidth, visibleWidth } from "@gsd/pi-tui";
 import { theme } from "../theme/theme.js";
 import { formatTimestamp, type TimestampFormat } from "./timestamp.js";
@@ -34,7 +35,7 @@ export function renderChatFrame(
 				: "borderAccent";
 	const borderMuted = isPurple ? "customMessageLabel" : "borderMuted";
 	const border = (s: string) => theme.fg(borderColor, s);
-	const leftRaw = `• ${opts.label}`;
+	const leftRaw = opts.label;
 	const rightRaw =
 		opts.showTimestamp === false || !opts.timestamp
 			? ""