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

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,13 +110,127 @@ 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 compact read rows with target metadata", () => {
+		const rendered = renderToolCollapsed(
+			"read",
+			{ path: "src/Inspector.tsx" },
+			{
+				content: [{ type: "text", text: "source" }],
+				isError: false,
+				details: {
+					target: {
+						kind: "file",
+						action: "read",
+						inputPath: "src/Inspector.tsx",
+						resolvedPath: "/tmp/project/src/Inspector.tsx",
+						range: { start: 4, end: 12 },
+					},
+				},
+			},
+		);
+
+		assert.match(rendered, /read .*src\/Inspector\.tsx:4-12/);
+		assert.doesNotMatch(rendered, /source/);
+	});
+
+	test("renders compact edit rows with target metadata", () => {
+		const rendered = renderToolCollapsed(
+			"edit",
+			{ path: "src/Inspector.tsx" },
+			{
+				content: [{ type: "text", text: "Updated src/Inspector.tsx" }],
+				isError: false,
+				details: {
+					target: {
+						kind: "file",
+						action: "edit",
+						inputPath: "src/Inspector.tsx",
+						resolvedPath: "/tmp/project/src/Inspector.tsx",
+						line: 42,
+					},
+				},
+			},
+		);
+
+		assert.match(rendered, /edit .*src\/Inspector\.tsx:42/);
+		assert.doesNotMatch(rendered, /Updated src\/Inspector\.tsx/);
+	});
+
+	test("renders compact write rows with target metadata", () => {
+		const rendered = renderToolCollapsed(
+			"write",
+			{ path: "src/output.ts", content: "ok" },
+			{
+				content: [{ type: "text", text: "Successfully wrote 2 bytes to src/output.ts" }],
+				isError: false,
+				details: {
+					target: {
+						kind: "file",
+						action: "write",
+						inputPath: "src/output.ts",
+						resolvedPath: "/tmp/project/src/output.ts",
+					},
+				},
+			},
+		);
+
+		assert.match(rendered, /write .*src\/output\.ts/);
+		assert.doesNotMatch(rendered, /Successfully wrote/);
+	});
+
+	test("renders compact bash rows with command preview", () => {
+		const rendered = renderToolCollapsed(
+			"bash",
+			{ command: "npm run typecheck -- --watch false" },
+			{ content: [{ type: "text", text: "ok" }], isError: false, details: { cwd: "/tmp/project" } },
+		);
+
+		assert.match(rendered, /bash npm run typecheck -- --watch false/);
+		assert.doesNotMatch(rendered, /\bok\b/);
+	});
+
+	test("keeps failed tools expanded and error visible", () => {
+		const rendered = renderToolCollapsed(
+			"edit",
+			{ path: "src/Inspector.tsx" },
+			{
+				content: [{ type: "text", text: "Could not find target text" }],
+				isError: true,
+				details: {
+					target: {
+						kind: "file",
+						action: "edit",
+						inputPath: "src/Inspector.tsx",
+						resolvedPath: "/tmp/project/src/Inspector.tsx",
+					},
+				},
+			},
+		);
+
+		assert.match(rendered, /Could not find target text/);
+		assert.match(rendered, /edit/);
 	});
 
 	test("renders phase-based summaries for rolled-up tool executions", () => {
 		const phases: ToolExecutionPhase[] = [
 			{ label: "Setup / shell", count: 6, durationMs: 12 },
-			{ label: "Context reads", count: 4, durationMs: 6 },
+			{
+				label: "Context reads",
+				count: 4,
+				durationMs: 6,
+				actionLabel: "read",
+				targets: ["/tmp/project/src/a.ts", "/tmp/project/src/b.ts"],
+			},
+			{
+				label: "File changes",
+				count: 3,
+				durationMs: 5,
+				actionLabel: "edit",
+				targets: ["/tmp/project/src/Inspector.tsx:42", "/tmp/project/src/CompareView.tsx:8"],
+			},
 			{ label: "Requirement writes", count: 4, durationMs: 4 },
 			{ label: "Memory lookups", count: 4, durationMs: 4 },
 			{ label: "Finalization", count: 1, durationMs: 1 },
@@ -121,7 +238,10 @@ describe("ToolExecutionComponent", () => {
 		const rendered = stripAnsi(new ToolPhaseSummaryComponent(phases).render(120).join("\n"));
 
 		assert.match(rendered, /Setup \/ shell 6 actions\s+success · 12ms/);
-		assert.match(rendered, /Context reads 4 actions\s+success · 6ms/);
+		assert.match(rendered, /Context reads · 2 files\s+success · 6ms/);
+		assert.match(rendered, /src\/a\.ts/);
+		assert.match(rendered, /File changes · 2 files, 3 edits\s+success · 5ms/);
+		assert.match(rendered, /src\/Inspector\.tsx:42/);
 		assert.match(rendered, /Requirement writes 4 actions\s+success · 4ms/);
 		assert.match(rendered, /Memory lookups 4 actions\s+success · 4ms/);
 		assert.match(rendered, /Finalization 1 action\s+success · 1ms/);
@@ -143,7 +263,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 +326,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 +364,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 +372,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
 			? ""

package/packages/pi-coding-agent/src/modes/interactive/components/tool-card-cleanup-and-success-runtime.test.ts

@@ -1,3 +1,4 @@
+// GSD2 TUI Tests - Runtime coverage for tool-card cleanup and success notification rendering.
 // Runtime regression tests for the post-compaction tool-card cleanup and the
 // green-bordered success-notification rendering. Replaces the source-grep
 // `src/tests/tui-running-and-success-box.test.ts` that was deleted in #4875
@@ -74,7 +75,7 @@ function makeMockTUI(): MockTui {
 // ─── Bug 1: tool cards stuck in "Running" after compaction ──────────────
 
 describe("ToolExecutionComponent post-compaction cleanup", () => {
-	it("renders 'Running' status while the tool call has no result", () => {
+	it("renders 'running' status while the tool call has no result", () => {
 		// Baseline: a freshly-constructed component (mid-stream) must show
 		// the running badge — this is the state we need to flip OUT of when
 		// compaction removes the result message.
@@ -88,12 +89,12 @@ describe("ToolExecutionComponent post-compaction cleanup", () => {
 		);
 		const rendered = c.render(60).map(stripAnsi).join("\n");
 		assert.ok(
-			rendered.includes("Running"),
-			"freshly constructed component should render 'Running' badge",
+			rendered.includes("running"),
+			"freshly constructed component should render 'running' badge",
 		);
 	});
 
-	it("markHistoricalNoResult flips a stuck tool card OUT of 'Running'", () => {
+	it("markHistoricalNoResult flips a stuck tool card OUT of 'running'", () => {
 		// Real bug: after session-history replay (post-compaction or session
 		// switch), tool calls without matching tool_result messages stay in
 		// isPartial = true forever. markHistoricalNoResult must produce a
@@ -111,13 +112,13 @@ describe("ToolExecutionComponent post-compaction cleanup", () => {
 
 		const rendered = c.render(60).map(stripAnsi).join("\n");
 		assert.ok(
-			!rendered.includes("Running"),
-			"after markHistoricalNoResult, the tool card must NOT render 'Running' — got:\n" +
+			!rendered.includes("running"),
+			"after markHistoricalNoResult, the tool card must NOT render 'running' -- got:\n" +
 				rendered,
 		);
 		assert.ok(
-			rendered.includes("Done"),
-			"flipped card should render 'Done' status (no-result success)",
+			rendered.includes("success"),
+			"flipped card should render 'success' status (no-result success)",
 		);
 	});
 
@@ -145,7 +146,7 @@ describe("ToolExecutionComponent post-compaction cleanup", () => {
 		);
 
 		const before = c.render(60).map(stripAnsi).join("\n");
-		assert.ok(before.includes("Done"), "after complete(), card shows 'Done'");
+		assert.ok(before.includes("success"), "after complete(), card shows 'success'");
 
 		c.markHistoricalNoResult(); // must early-return
 		const after = c.render(60).map(stripAnsi).join("\n");

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

@@ -107,13 +107,14 @@ function renderToolFrame(
 
 	const borderColor = opts.tone === "error" ? "toolError" : opts.tone === "pending" ? "toolRunning" : "toolSuccess";
 	const topColor = borderColor;
-	const labelColor = opts.tone === "error" ? "toolError" : "surfaceTitle";
+	const labelColor = opts.tone === "error" ? "toolError" : opts.tone === "pending" ? "toolRunning" : "toolSuccess";
 	const statusColor = opts.tone === "error" ? "toolError" : opts.tone === "pending" ? "toolRunning" : "toolSuccess";
-	const leftStyled = theme.fg(labelColor, theme.bold(`• ${opts.label}`));
+	const leftStyled = theme.fg(labelColor, theme.bold(opts.label));
 	const rightStyled = theme.fg(statusColor, opts.status);
-	const gap = Math.max(1, outerWidth - visibleWidth(leftStyled) - visibleWidth(rightStyled));
+	const titleWidth = Math.max(1, outerWidth - 4);
+	const gap = Math.max(1, titleWidth - visibleWidth(leftStyled) - visibleWidth(rightStyled));
 	const headerRow = `${leftStyled}${" ".repeat(gap)}${rightStyled}`;
-	const headerPad = Math.max(0, outerWidth - visibleWidth(headerRow));
+	const headerPad = Math.max(0, titleWidth - visibleWidth(headerRow));
 
 	const sourceLines = trimOuterBlankLines(contentLines);
 	const bodyLines = (sourceLines.length > 0 ? sourceLines : [""]).map((line) => {
@@ -122,12 +123,33 @@ function renderToolFrame(
 	});
 
 	return style()
-		.border("rule")
+		.border("rounded")
 		.borderColor((line) => theme.fg(line.startsWith("─") ? topColor : borderColor, line))
 		.title(headerRow + " ".repeat(headerPad))
 		.render(bodyLines, outerWidth);
 }
 
+function renderCollapsedToolRow(
+	label: string,
+	status: string,
+	width: number,
+	tone: Extract<ToolFrameTone, "success">,
+): string[] {
+	const outerWidth = Math.max(20, width);
+	const contentWidth = Math.max(1, outerWidth - 2);
+	const statusColor = tone === "success" ? "toolSuccess" : "toolMuted";
+	const labelStyled = theme.fg(statusColor, label);
+	const statusStyled = theme.fg(statusColor, status);
+	const labelWidth = Math.max(1, contentWidth - visibleWidth(statusStyled) - 1);
+	const clippedLabel = truncateToWidth(labelStyled, labelWidth, "");
+	const gap = Math.max(1, contentWidth - visibleWidth(clippedLabel) - visibleWidth(statusStyled));
+	const line = `${clippedLabel}${" ".repeat(gap)}${statusStyled}`;
+	return style()
+		.border("minimal")
+		.borderColor((text) => theme.fg(statusColor, text))
+		.render([line], outerWidth);
+}
+
 const COMPACT_ARG_VALUE_LIMIT = 60;
 const GENERIC_OUTPUT_PREVIEW_LINES = 10;
 const GENERIC_ARGS_JSON_PREVIEW_LINES = 10;
@@ -136,6 +158,22 @@ export type ToolExecutionPhase = {
 	label: string;
 	count: number;
 	durationMs: number;
+	targets?: string[];
+	actionLabel?: string;
+};
+
+type ToolTargetMetadata = {
+	kind?: string;
+	action?: string;
+	inputPath?: string;
+	resolvedPath?: string;
+	pattern?: string;
+	glob?: string;
+	line?: number;
+	range?: {
+		start?: number;
+		end?: number;
+	};
 };
 
 function formatElapsed(ms: number): string {
@@ -143,6 +181,104 @@ function formatElapsed(ms: number): string {
 	return `${Math.max(1, Math.round(ms / 1000))}s`;
 }
 
+function formatCommandPreview(command: string): string {
+	return truncateToWidth(command.replace(/\s+/g, " ").trim(), 64, "");
+}
+
+function appendLineOrRange(displayPath: string | undefined, target: ToolTargetMetadata): string | undefined {
+	if (!displayPath) return undefined;
+	if (typeof target.line === "number" && Number.isFinite(target.line)) {
+		return `${displayPath}:${target.line}`;
+	}
+	const start = target.range?.start;
+	if (typeof start === "number" && Number.isFinite(start)) {
+		const end = target.range?.end;
+		const suffix =
+			typeof end === "number" && Number.isFinite(end) && end !== start
+				? `${start}-${end}`
+				: `${start}`;
+		return `${displayPath}:${suffix}`;
+	}
+	return displayPath;
+}
+
+function formatToolTarget(target: ToolTargetMetadata): string | undefined {
+	const path = target.resolvedPath || target.inputPath;
+	const displayPath = path ? shortenPath(path) : undefined;
+	if (target.kind === "search") {
+		const searchTarget = displayPath ?? target.inputPath ?? ".";
+		const label = target.pattern ? `${target.pattern} in ${searchTarget}` : searchTarget;
+		return target.glob ? `${label} (${target.glob})` : label;
+	}
+	return appendLineOrRange(displayPath, target);
+}
+
+function formatArgsPathTarget(path: string | null, args: Record<string, unknown>): string | undefined {
+	if (!path) return undefined;
+	const start = typeof args.offset === "number" ? args.offset : undefined;
+	const limit = typeof args.limit === "number" ? args.limit : undefined;
+	const range =
+		start !== undefined || limit !== undefined
+			? {
+					start: start ?? 1,
+					end: limit !== undefined ? (start ?? 1) + Math.max(0, limit - 1) : undefined,
+				}
+			: undefined;
+	return appendLineOrRange(shortenPath(path), { range });
+}
+
+function stripLineSuffix(target: string): string {
+	return target.replace(/:\d+(?:-\d+)?$/, "");
+}
+
+function uniqueTargets(targets: string[] | undefined): string[] {
+	const seen = new Set<string>();
+	const unique: string[] = [];
+	for (const target of targets ?? []) {
+		if (!target || seen.has(target)) continue;
+		seen.add(target);
+		unique.push(target);
+	}
+	return unique;
+}
+
+function summarizePhaseLabel(phase: ToolExecutionPhase): string {
+	const phaseTargets = uniqueTargets(phase.targets);
+	const baseTargets = uniqueTargets(phaseTargets.map(stripLineSuffix));
+	if (phase.label === "File changes" && baseTargets.length > 0) {
+		const fileWord = baseTargets.length === 1 ? "file" : "files";
+		const actionWord =
+			phase.actionLabel === "write"
+				? phase.count === 1
+					? "write"
+					: "writes"
+				: phase.actionLabel === undefined
+					? phase.count === 1
+						? "action"
+						: "actions"
+					: phase.count === 1
+						? "edit"
+						: "edits";
+		return `${phase.label} · ${baseTargets.length} ${fileWord}, ${phase.count} ${actionWord}`;
+	}
+	if (phase.label === "Context reads" && baseTargets.length > 0) {
+		const fileWord = baseTargets.length === 1 ? "file" : "files";
+		return `${phase.label} · ${baseTargets.length} ${fileWord}`;
+	}
+	if (phase.label === "Setup / shell" && phaseTargets.length > 0) {
+		return `${phase.label} · ${phase.count} ${phase.count === 1 ? "command" : "commands"}`;
+	}
+	return `${phase.label} ${phase.count} ${phase.count === 1 ? "action" : "actions"}`;
+}
+
+function summarizePhaseTargets(phase: ToolExecutionPhase, width: number): string | undefined {
+	const phaseTargets = uniqueTargets(phase.targets);
+	if (phaseTargets.length === 0) return undefined;
+	const shown = phaseTargets.slice(0, 3);
+	const suffix = phaseTargets.length > shown.length ? ` +${phaseTargets.length - shown.length} more` : "";
+	return truncateToWidth(shown.join(" · ") + suffix, width, "");
+}
+
 /**
  * Format tool args for the generic-renderer fallback. Produces a one-line
  * `k=v, k=v` summary when every value is a primitive that fits inline; falls
@@ -559,18 +695,13 @@ export class ToolExecutionComponent extends Container {
 		const frameTone: ToolFrameTone =
 			this.result?.isError ? "error" : this.isPartial || !this.result ? "pending" : "success";
 		const elapsed = formatElapsed((this.endedAt ?? Date.now()) - this.startedAt);
-		const frameStatus = `${this.isPartial || !this.result ? "Running" : this.result.isError ? "Error" : "Done"} · ${elapsed}`;
+		const frameStatus = `${this.isPartial || !this.result ? "running" : this.result.isError ? "failed" : "success"} · ${elapsed}`;
 		const parsed = parseMcpToolName(this.toolName);
 		const frameLabel = parsed
-			? `Tool ${parsed.server}·${parsed.tool}`
-			: `Tool ${prettifyToolName(this.toolName, this.toolDefinition?.label) || "unknown"}`;
+			? `${parsed.server}·${parsed.tool}`
+			: prettifyToolName(this.toolName, this.toolDefinition?.label) || "unknown";
 		if (this.shouldRenderCompactSuccess()) {
-			const availableWidth = Math.max(1, frameWidth - 2);
-			const summaryWidth = Math.max(1, availableWidth - visibleWidth(frameStatus) - 1);
-			const summary = truncateToWidth(this.getCompactSummary(frameLabel), summaryWidth, "");
-			const gap = Math.max(1, availableWidth - visibleWidth(summary) - visibleWidth(frameStatus));
-			const line = `${theme.fg("toolSuccess", summary)}${" ".repeat(gap)}${theme.fg("toolSuccess", frameStatus)}`;
-			return ["", ...style().border("minimal").borderColor((text) => theme.fg("toolSuccess", text)).render([line], frameWidth)];
+			return ["", ...renderCollapsedToolRow(this.getCompactSummary(frameLabel), frameStatus, frameWidth, "success")];
 		}
 		const lines = super.render(contentWidth);
 		const framed = renderToolFrame(lines, frameWidth, {
@@ -584,17 +715,20 @@ export class ToolExecutionComponent extends Container {
 	private shouldRenderCompactSuccess(): boolean {
 		if (this.expanded || this.isPartial || !this.result || this.result.isError) return false;
 		const hasImages = this.result.content?.some((block) => block.type === "image") ?? false;
-		return !hasImages && this.getTextOutput().trim().length === 0;
+		return !hasImages;
 	}
 
 	getRollupPhase(): ToolExecutionPhase | null {
 		if (!this.shouldRenderCompactSuccess()) return null;
 		const label = this.getPhaseLabel();
 		const endedAt = this.endedAt ?? Date.now();
+		const target = this.getCompactTarget();
 		return {
 			label,
 			count: 1,
 			durationMs: Math.max(0, endedAt - this.startedAt),
+			targets: target ? [target] : undefined,
+			actionLabel: this.getCompactAction(),
 		};
 	}
 
@@ -615,7 +749,52 @@ export class ToolExecutionComponent extends Container {
 	}
 
 	private getCompactSummary(frameLabel: string): string {
-		return `${frameLabel} Completed`;
+		if (this.normalizedToolName === "bash") {
+			const command = str(this.args?.command);
+			return command ? `bash ${formatCommandPreview(command)}` : frameLabel;
+		}
+		const target = this.getCompactTarget();
+		return target ? `${this.getCompactAction()} ${target}` : frameLabel;
+	}
+
+	private getCompactAction(): string {
+		const target = this.getTargetMetadata();
+		if (target?.action) return target.action === "list" ? "ls" : target.action;
+		return this.normalizedToolName;
+	}
+
+	private getTargetMetadata(): ToolTargetMetadata | undefined {
+		const target = this.result?.details?.target;
+		return target && typeof target === "object" ? target : undefined;
+	}
+
+	private getCompactTarget(): string | undefined {
+		const metadata = this.getTargetMetadata();
+		const metadataTarget = metadata ? formatToolTarget(metadata) : undefined;
+		if (metadataTarget) return metadataTarget;
+
+		const path = str(this.args?.file_path ?? this.args?.path);
+		if (path === null) return undefined;
+		if (this.normalizedToolName === "read" || this.normalizedToolName === "hashline_read") {
+			return formatArgsPathTarget(path, this.args);
+		}
+		if (this.normalizedToolName === "write" || this.normalizedToolName === "edit") {
+			return path ? shortenPath(path) : undefined;
+		}
+		if (this.normalizedToolName === "ls") {
+			return shortenPath(path || ".");
+		}
+		if (this.normalizedToolName === "find") {
+			const pattern = str(this.args?.pattern);
+			return pattern ? `${pattern} in ${shortenPath(path || ".")}` : shortenPath(path || ".");
+		}
+		if (this.normalizedToolName === "grep") {
+			const pattern = str(this.args?.pattern);
+			const glob = str(this.args?.glob);
+			const label = pattern ? `${pattern} in ${shortenPath(path || ".")}` : shortenPath(path || ".");
+			return glob ? `${label} (${glob})` : label;
+		}
+		return undefined;
 	}
 
 	private updateDisplay(): void {
@@ -845,6 +1024,10 @@ export class ToolExecutionComponent extends Container {
 			// Truncation warnings
 			const truncation = this.result.details?.truncation;
 			const fullOutputPath = this.result.details?.fullOutputPath;
+			const cwd = this.result.details?.cwd;
+			if (this.expanded && typeof cwd === "string" && cwd.length > 0) {
+				this.contentBox.addChild(new Text(`\n${theme.fg("muted", `cwd ${shortenPath(cwd)}`)}`, 0, 0));
+			}
 			if (truncation?.truncated || fullOutputPath) {
 				const warnings: string[] = [];
 				if (fullOutputPath) {
@@ -1271,16 +1454,22 @@ export class ToolPhaseSummaryComponent extends Container {
 		super();
 	}
 
+	getPhases(): ToolExecutionPhase[] {
+		return this.phases.map((phase) => ({ ...phase, targets: phase.targets ? [...phase.targets] : undefined }));
+	}
+
 	override render(width: number): string[] {
 		const frameWidth = Math.max(20, width);
-		const rows = this.phases.map((phase) => {
-			const left = `${phase.label} ${phase.count} ${phase.count === 1 ? "action" : "actions"}`;
+		const rows = this.phases.flatMap((phase) => {
+			const left = summarizePhaseLabel(phase);
 			const right = `success · ${formatElapsed(phase.durationMs)}`;
 			const contentWidth = Math.max(1, frameWidth - 2);
 			const leftWidth = Math.max(1, contentWidth - visibleWidth(right) - 1);
 			const leftText = truncateToWidth(left, leftWidth, "");
 			const gap = Math.max(1, contentWidth - visibleWidth(leftText) - visibleWidth(right));
-			return `${theme.fg("toolSuccess", leftText)}${" ".repeat(gap)}${theme.fg("toolSuccess", right)}`;
+			const summaryRow = `${theme.fg("toolSuccess", leftText)}${" ".repeat(gap)}${theme.fg("toolSuccess", right)}`;
+			const targetRow = summarizePhaseTargets(phase, contentWidth);
+			return targetRow ? [summaryRow, theme.fg("muted", targetRow)] : [summaryRow];
 		});
 
 		return ["", ...style().border("minimal").borderColor((text) => theme.fg("toolSuccess", text)).render(rows, frameWidth)];