gsd-pi 2.67.0-dev.1cd1e0f → 2.67.0-dev.2367d7e

package/packages/pi-coding-agent/src/core/contextual-tips.test.ts

@@ -0,0 +1,259 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { ContextualTips } from "./contextual-tips.js";
+
+const baseCtx = {
+	input: "hello world",
+	isStreaming: false,
+	thinkingLevel: "off" as string,
+	contextPercent: undefined as number | undefined,
+};
+
+describe("ContextualTips", () => {
+	describe("shell-command-prefix tip", () => {
+		it("fires for bare shell commands", () => {
+			const tips = new ContextualTips();
+			const result = tips.evaluate({ ...baseCtx, input: "ls -la" });
+			assert.ok(result);
+			assert.ok(result.includes("looks like a shell command"));
+			assert.ok(result.includes("!"));
+		});
+
+		it("fires for various known commands", () => {
+			for (const cmd of ["pwd", "cd src", "cat file.txt", "grep foo bar", "git status", "npm install", "docker ps"]) {
+				const tips = new ContextualTips();
+				const result = tips.evaluate({ ...baseCtx, input: cmd });
+				assert.ok(result, `Expected tip for "${cmd}"`);
+				assert.ok(result.includes("looks like a shell command"));
+			}
+		});
+
+		it("does not fire for commands already prefixed with !", () => {
+			const tips = new ContextualTips();
+			const result = tips.evaluate({ ...baseCtx, input: "!ls -la" });
+			assert.equal(result, null);
+		});
+
+		it("does not fire for commands prefixed with !!", () => {
+			const tips = new ContextualTips();
+			const result = tips.evaluate({ ...baseCtx, input: "!!ls -la" });
+			assert.equal(result, null);
+		});
+
+		it("does not fire for slash commands", () => {
+			const tips = new ContextualTips();
+			const result = tips.evaluate({ ...baseCtx, input: "/clear" });
+			assert.equal(result, null);
+		});
+
+		it("does not fire for unknown commands", () => {
+			const tips = new ContextualTips();
+			const result = tips.evaluate({ ...baseCtx, input: "please help me fix this bug" });
+			assert.equal(result, null);
+		});
+
+		it("does not fire for very long inputs", () => {
+			const tips = new ContextualTips();
+			const longInput = "ls " + "a".repeat(200);
+			const result = tips.evaluate({ ...baseCtx, input: longInput });
+			assert.equal(result, null);
+		});
+
+		it("respects maxShows (2)", () => {
+			const tips = new ContextualTips();
+			tips.evaluate({ ...baseCtx, input: "ls" });
+			tips.evaluate({ ...baseCtx, input: "pwd" });
+			const third = tips.evaluate({ ...baseCtx, input: "cat foo" });
+			assert.equal(third, null);
+		});
+	});
+
+	describe("large-paste tip", () => {
+		it("fires for large inputs", () => {
+			const tips = new ContextualTips();
+			const largeInput = "a".repeat(2500);
+			const result = tips.evaluate({ ...baseCtx, input: largeInput });
+			assert.ok(result);
+			assert.ok(result.includes("Large inputs"));
+		});
+
+		it("does not fire for normal-length inputs", () => {
+			const tips = new ContextualTips();
+			const result = tips.evaluate({ ...baseCtx, input: "fix the login bug" });
+			assert.equal(result, null);
+		});
+
+		it("does not fire for large bash commands", () => {
+			const tips = new ContextualTips();
+			const result = tips.evaluate({ ...baseCtx, input: "!" + "a".repeat(2500) });
+			assert.equal(result, null);
+		});
+
+		it("respects maxShows (2)", () => {
+			const tips = new ContextualTips();
+			const large = "x".repeat(3000);
+			tips.evaluate({ ...baseCtx, input: large });
+			tips.evaluate({ ...baseCtx, input: large });
+			const third = tips.evaluate({ ...baseCtx, input: large });
+			assert.equal(third, null);
+		});
+	});
+
+	describe("thinking-level-high tip", () => {
+		it("fires for short inputs with high thinking", () => {
+			const tips = new ContextualTips();
+			const result = tips.evaluate({ ...baseCtx, input: "what is 2+2?", thinkingLevel: "high" });
+			assert.ok(result);
+			assert.ok(result.includes("Thinking is set to high"));
+		});
+
+		it("fires for xhigh thinking", () => {
+			const tips = new ContextualTips();
+			const result = tips.evaluate({ ...baseCtx, input: "what time is it?", thinkingLevel: "xhigh" });
+			assert.ok(result);
+			assert.ok(result.includes("Thinking is set to xhigh"));
+		});
+
+		it("does not fire for low/medium thinking", () => {
+			const tips = new ContextualTips();
+			const result = tips.evaluate({ ...baseCtx, input: "what is 2+2?", thinkingLevel: "medium" });
+			assert.equal(result, null);
+		});
+
+		it("does not fire for long inputs", () => {
+			const tips = new ContextualTips();
+			const longInput = "Please help me refactor this entire authentication module to use JWT tokens instead of session cookies. " +
+				"I need to update the middleware, the login handler, and the user model.";
+			const result = tips.evaluate({ ...baseCtx, input: longInput, thinkingLevel: "high" });
+			assert.equal(result, null);
+		});
+
+		it("does not fire for slash commands", () => {
+			const tips = new ContextualTips();
+			const result = tips.evaluate({ ...baseCtx, input: "/model", thinkingLevel: "high" });
+			assert.equal(result, null);
+		});
+
+		it("respects maxShows (1)", () => {
+			const tips = new ContextualTips();
+			tips.evaluate({ ...baseCtx, input: "hi", thinkingLevel: "high" });
+			const second = tips.evaluate({ ...baseCtx, input: "hello", thinkingLevel: "high" });
+			assert.equal(second, null);
+		});
+	});
+
+	describe("double-bang-reminder tip", () => {
+		it("fires after 3+ included bash commands", () => {
+			const tips = new ContextualTips();
+			tips.recordBashIncluded();
+			tips.recordBashIncluded();
+			tips.recordBashIncluded();
+			const result = tips.evaluate({ ...baseCtx, input: "!ls" });
+			assert.ok(result);
+			assert.ok(result.includes("!!"));
+		});
+
+		it("does not fire with fewer than 3 included commands", () => {
+			const tips = new ContextualTips();
+			tips.recordBashIncluded();
+			tips.recordBashIncluded();
+			const result = tips.evaluate({ ...baseCtx, input: "!ls" });
+			assert.equal(result, null);
+		});
+
+		it("does not fire for !! commands", () => {
+			const tips = new ContextualTips();
+			tips.recordBashIncluded();
+			tips.recordBashIncluded();
+			tips.recordBashIncluded();
+			const result = tips.evaluate({ ...baseCtx, input: "!!ls" });
+			assert.equal(result, null);
+		});
+
+		it("respects maxShows (2)", () => {
+			const tips = new ContextualTips();
+			for (let i = 0; i < 5; i++) tips.recordBashIncluded();
+			tips.evaluate({ ...baseCtx, input: "!ls" });
+			tips.evaluate({ ...baseCtx, input: "!pwd" });
+			const third = tips.evaluate({ ...baseCtx, input: "!cat foo" });
+			assert.equal(third, null);
+		});
+	});
+
+	describe("compaction-nudge tip", () => {
+		it("fires when context is >= 70%", () => {
+			const tips = new ContextualTips();
+			const result = tips.evaluate({ ...baseCtx, input: "fix the bug", contextPercent: 75 });
+			assert.ok(result);
+			assert.ok(result.includes("/compact"));
+		});
+
+		it("does not fire when context is < 70%", () => {
+			const tips = new ContextualTips();
+			const result = tips.evaluate({ ...baseCtx, input: "fix the bug", contextPercent: 50 });
+			assert.equal(result, null);
+		});
+
+		it("does not fire when contextPercent is undefined", () => {
+			const tips = new ContextualTips();
+			const result = tips.evaluate({ ...baseCtx, input: "fix the bug", contextPercent: undefined });
+			assert.equal(result, null);
+		});
+
+		it("does not fire for slash commands", () => {
+			const tips = new ContextualTips();
+			const result = tips.evaluate({ ...baseCtx, input: "/model", contextPercent: 90 });
+			assert.equal(result, null);
+		});
+
+		it("respects maxShows (1)", () => {
+			const tips = new ContextualTips();
+			tips.evaluate({ ...baseCtx, input: "hello", contextPercent: 80 });
+			const second = tips.evaluate({ ...baseCtx, input: "world", contextPercent: 85 });
+			assert.equal(second, null);
+		});
+	});
+
+	describe("reset", () => {
+		it("resets all show counters", () => {
+			const tips = new ContextualTips();
+			// Exhaust shell-command-prefix tip
+			tips.evaluate({ ...baseCtx, input: "ls" });
+			tips.evaluate({ ...baseCtx, input: "pwd" });
+			assert.equal(tips.evaluate({ ...baseCtx, input: "cat foo" }), null);
+
+			tips.reset();
+
+			// Should fire again after reset
+			const result = tips.evaluate({ ...baseCtx, input: "ls" });
+			assert.ok(result);
+			assert.ok(result.includes("looks like a shell command"));
+		});
+
+		it("resets bash included count", () => {
+			const tips = new ContextualTips();
+			for (let i = 0; i < 5; i++) tips.recordBashIncluded();
+			assert.equal(tips.bashIncludedCount, 5);
+
+			tips.reset();
+			assert.equal(tips.bashIncludedCount, 0);
+		});
+	});
+
+	describe("priority — first match wins", () => {
+		it("shell-command-prefix takes priority over compaction nudge", () => {
+			const tips = new ContextualTips();
+			const result = tips.evaluate({ ...baseCtx, input: "ls", contextPercent: 80 });
+			assert.ok(result);
+			assert.ok(result.includes("looks like a shell command"));
+		});
+
+		it("large-paste takes priority over compaction nudge", () => {
+			const tips = new ContextualTips();
+			const largeInput = "x".repeat(3000);
+			const result = tips.evaluate({ ...baseCtx, input: largeInput, contextPercent: 80 });
+			assert.ok(result);
+			assert.ok(result.includes("Large inputs"));
+		});
+	});
+});

package/packages/pi-coding-agent/src/core/contextual-tips.ts

@@ -0,0 +1,232 @@
+/**
+ * Contextual tips system — shows non-intrusive, session-scoped hints
+ * when user behavior suggests they'd benefit from knowing a feature.
+ *
+ * Each tip fires at most `maxShows` times per session. Tips are
+ * evaluated in order; the first match wins per input event.
+ */
+
+// ─── Tip definitions ─────────────────────────────────────────────────────────
+
+export interface TipContext {
+	/** The raw input text the user submitted */
+	input: string;
+	/** Whether the agent is currently streaming */
+	isStreaming: boolean;
+	/** Current thinking level (e.g. "off", "low", "high", "xhigh") */
+	thinkingLevel?: string;
+	/** Number of `!` (included) bash commands run this session */
+	bashIncludedCount: number;
+	/** Approximate context usage percentage (0–100), if known */
+	contextPercent?: number;
+}
+
+export interface Tip {
+	id: string;
+	/** Maximum times this tip is shown per session */
+	maxShows: number;
+	/** Returns the tip message if the tip should fire, or null to skip */
+	evaluate: (ctx: TipContext) => string | null;
+}
+
+// Shell commands that obviously run locally and don't need the LLM.
+// Intentionally conservative — these are unambiguous filesystem/info commands.
+const LOCAL_SHELL_COMMANDS = new Set([
+	"ls",
+	"ll",
+	"la",
+	"pwd",
+	"cd",
+	"dir",
+	"cat",
+	"head",
+	"tail",
+	"wc",
+	"file",
+	"which",
+	"whoami",
+	"echo",
+	"date",
+	"tree",
+	"find",
+	"grep",
+	"rg",
+	"clear",
+	"env",
+	"df",
+	"du",
+	"uname",
+	"hostname",
+	"mkdir",
+	"rm",
+	"cp",
+	"mv",
+	"touch",
+	"chmod",
+	"less",
+	"more",
+	"sort",
+	"uniq",
+	"sed",
+	"awk",
+	"curl",
+	"wget",
+	"tar",
+	"zip",
+	"unzip",
+	"git",
+	"docker",
+	"npm",
+	"npx",
+	"yarn",
+	"pnpm",
+	"node",
+	"python",
+	"python3",
+	"pip",
+	"pip3",
+	"make",
+	"cargo",
+	"go",
+	"ruby",
+	"brew",
+]);
+
+/**
+ * Extract the first token from input, ignoring leading whitespace.
+ * Returns lowercase for case-insensitive matching.
+ */
+function firstToken(input: string): string {
+	const trimmed = input.trimStart();
+	const spaceIdx = trimmed.search(/\s/);
+	const token = spaceIdx === -1 ? trimmed : trimmed.slice(0, spaceIdx);
+	return token.toLowerCase();
+}
+
+/**
+ * Check if input looks like a bare shell command (no !, //, or slash prefix).
+ */
+function looksLikeShellCommand(input: string): boolean {
+	const trimmed = input.trimStart();
+	// Already prefixed — user knows what they're doing
+	if (trimmed.startsWith("!") || trimmed.startsWith("/")) return false;
+	// Multi-line or very long inputs are probably prompts
+	if (trimmed.includes("\n") || trimmed.length > 120) return false;
+	return LOCAL_SHELL_COMMANDS.has(firstToken(trimmed));
+}
+
+const TIPS: Tip[] = [
+	// 1. Shell command reminder
+	{
+		id: "shell-command-prefix",
+		maxShows: 2,
+		evaluate(ctx) {
+			if (!looksLikeShellCommand(ctx.input)) return null;
+			const cmd = firstToken(ctx.input);
+			return `Tip: "${cmd}" looks like a shell command. Prefix with ! to run locally, or !! to run without using tokens.`;
+		},
+	},
+
+	// 2. Large paste warning
+	{
+		id: "large-paste",
+		maxShows: 2,
+		evaluate(ctx) {
+			if (ctx.input.length < 2000) return null;
+			// Slash commands and bash prefixes are intentional
+			if (ctx.input.trimStart().startsWith("/") || ctx.input.trimStart().startsWith("!")) return null;
+			return "Tip: Large inputs consume many tokens. Consider saving to a file and asking the agent to read it.";
+		},
+	},
+
+	// 3. Thinking level awareness
+	{
+		id: "thinking-level-high",
+		maxShows: 1,
+		evaluate(ctx) {
+			const level = ctx.thinkingLevel?.toLowerCase();
+			if (level !== "high" && level !== "xhigh") return null;
+			// Only fire for short, simple-looking inputs (likely simple questions)
+			const trimmed = ctx.input.trim();
+			if (trimmed.length > 80 || trimmed.includes("\n")) return null;
+			// Don't fire on slash or bash commands
+			if (trimmed.startsWith("/") || trimmed.startsWith("!")) return null;
+			return `Tip: Thinking is set to ${level}. Use Ctrl+T to lower it for simple questions — saves tokens.`;
+		},
+	},
+
+	// 4. Double-bang reminder
+	{
+		id: "double-bang-reminder",
+		maxShows: 2,
+		evaluate(ctx) {
+			// Fire after user has run 3+ included (!) bash commands
+			if (ctx.bashIncludedCount < 3) return null;
+			// Only trigger on a ! command (not !!)
+			const trimmed = ctx.input.trimStart();
+			if (!trimmed.startsWith("!") || trimmed.startsWith("!!")) return null;
+			return "Tip: Use !! instead of ! to keep command output out of agent context and save tokens.";
+		},
+	},
+
+	// 5. Compaction nudge
+	{
+		id: "compaction-nudge",
+		maxShows: 1,
+		evaluate(ctx) {
+			if (ctx.contextPercent === undefined || ctx.contextPercent < 70) return null;
+			// Don't nag on slash/bash
+			const trimmed = ctx.input.trimStart();
+			if (trimmed.startsWith("/") || trimmed.startsWith("!")) return null;
+			return "Tip: Context is getting full. Use /compact to summarize the conversation and free up space.";
+		},
+	},
+];
+
+// ─── Session-scoped tracker ──────────────────────────────────────────────────
+
+export class ContextualTips {
+	/** Map of tip ID → number of times shown this session */
+	private showCounts = new Map<string, number>();
+	/** Track ! bash commands for double-bang reminder */
+	private _bashIncludedCount = 0;
+
+	/** Increment the bash-included counter. Call when user runs ! (not !!) command. */
+	recordBashIncluded(): void {
+		this._bashIncludedCount++;
+	}
+
+	get bashIncludedCount(): number {
+		return this._bashIncludedCount;
+	}
+
+	/**
+	 * Evaluate all tips against the current input context.
+	 * Returns the first matching tip message, or null if none apply.
+	 */
+	evaluate(ctx: Omit<TipContext, "bashIncludedCount">): string | null {
+		const fullCtx: TipContext = {
+			...ctx,
+			bashIncludedCount: this._bashIncludedCount,
+		};
+
+		for (const tip of TIPS) {
+			const shown = this.showCounts.get(tip.id) ?? 0;
+			if (shown >= tip.maxShows) continue;
+
+			const message = tip.evaluate(fullCtx);
+			if (message) {
+				this.showCounts.set(tip.id, shown + 1);
+				return message;
+			}
+		}
+
+		return null;
+	}
+
+	/** Reset all counters (e.g. on new session). */
+	reset(): void {
+		this.showCounts.clear();
+		this._bashIncludedCount = 0;
+	}
+}

package/packages/pi-coding-agent/src/core/index.ts

@@ -66,3 +66,5 @@ export {
 	type TurnStartEvent,
 	wrapToolsWithExtensions,
 } from "./extensions/index.js";
+
+export { ContextualTips, type TipContext } from "./contextual-tips.js";

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

@@ -0,0 +1,54 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import stripAnsi from "strip-ansi";
+import { ToolExecutionComponent } from "../tool-execution.js";
+import { initTheme } from "../../theme/theme.js";
+
+initTheme("dark", false);
+
+function renderTool(
+	toolName: string,
+	args: Record<string, unknown>,
+	result?: {
+		content: Array<{ type: string; text?: string }>;
+		isError: boolean;
+		details?: Record<string, unknown>;
+	},
+): string {
+	const component = new ToolExecutionComponent(
+		toolName,
+		args,
+		{},
+		undefined,
+		{ requestRender() {} } as any,
+	);
+	component.setExpanded(true);
+	if (result) component.updateResult(result);
+	return stripAnsi(component.render(120).join("\n"));
+}
+
+describe("ToolExecutionComponent", () => {
+	test("renders capitalized Claude Code Bash tool names with bash output instead of generic args JSON", () => {
+		const rendered = renderTool(
+			"Bash",
+			{ command: "pwd" },
+			{ content: [{ type: "text", text: "/tmp/gsd-pr-fix" }], isError: false },
+		);
+
+		assert.match(rendered, /\$ pwd/);
+		assert.match(rendered, /\/tmp\/gsd-pr-fix/);
+		assert.doesNotMatch(rendered, /^\{\s*\}$/m);
+	});
+
+	test("renders capitalized Claude Code Read tool names with read output", () => {
+		const rendered = renderTool(
+			"Read",
+			{ path: "/tmp/demo.txt" },
+			{ content: [{ type: "text", text: "hello\nworld" }], isError: false },
+		);
+
+		assert.match(rendered, /read .*demo\.txt/);
+		assert.match(rendered, /hello/);
+		assert.match(rendered, /world/);
+	});
+});

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

@@ -97,6 +97,10 @@ export class ToolExecutionComponent extends Container {
 	// When true, this component intentionally renders no lines
 	private hideComponent = false;
 
+	private get normalizedToolName(): string {
+		return typeof this.toolName === "string" ? this.toolName.toLowerCase() : "";
+	}
+
 	constructor(
 		toolName: string,
 		args: any,
@@ -121,7 +125,7 @@ export class ToolExecutionComponent extends Container {
 
 		// Use contentBox for bash (visual truncation) or custom tools with custom renderers
 		// Use contentText for built-in tools (including overrides without custom renderers)
-		if (toolName === "bash" || (toolDefinition && !this.shouldUseBuiltInRenderer())) {
+		if (this.normalizedToolName === "bash" || (toolDefinition && !this.shouldUseBuiltInRenderer())) {
 			this.addChild(this.contentBox);
 		} else {
 			this.addChild(this.contentText);
@@ -136,7 +140,8 @@ export class ToolExecutionComponent extends Container {
 	 * or the toolDefinition doesn't provide custom renderers.
 	 */
 	private shouldUseBuiltInRenderer(): boolean {
-		const isBuiltInName = this.toolName in allTools;
+		const normalizedToolName = this.normalizedToolName;
+		const isBuiltInName = normalizedToolName in allTools;
 		const hasCustomRenderers = this.toolDefinition?.renderCall || this.toolDefinition?.renderResult;
 		return isBuiltInName && !hasCustomRenderers;
 	}
@@ -152,7 +157,7 @@ export class ToolExecutionComponent extends Container {
 
 	updateArgs(args: any): void {
 		this.args = args;
-		if (this.toolName === "write" && this.isPartial) {
+		if (this.normalizedToolName === "write" && this.isPartial) {
 			this.updateWriteHighlightCacheIncremental();
 		}
 		this.updateDisplay();
@@ -308,7 +313,7 @@ export class ToolExecutionComponent extends Container {
 	): void {
 		this.result = result;
 		this.isPartial = isPartial;
-		if (this.toolName === "write" && !isPartial) {
+		if (this.normalizedToolName === "write" && !isPartial) {
 			const rawPath = str(this.args?.file_path ?? this.args?.path);
 			const fileContent = str(this.args?.content);
 			if (rawPath !== null && fileContent !== null) {
@@ -387,7 +392,7 @@ export class ToolExecutionComponent extends Container {
 
 		// Use built-in rendering for built-in tools (or overrides without custom renderers)
 		if (useBuiltInRenderer) {
-			if (this.toolName === "bash") {
+			if (this.normalizedToolName === "bash") {
 				// Bash uses Box with visual line truncation
 				this.contentBox.setBgFn(bgFn);
 				this.contentBox.clear();
@@ -629,8 +634,9 @@ export class ToolExecutionComponent extends Container {
 	private formatToolExecution(): string {
 		let text = "";
 		const invalidArg = theme.fg("error", "[invalid arg]");
+		const normalizedToolName = this.normalizedToolName;
 
-		if (this.toolName === "read") {
+		if (normalizedToolName === "read") {
 			const rawPath = str(this.args?.file_path ?? this.args?.path);
 			const path = rawPath !== null ? shortenPath(rawPath) : null;
 			const offset = this.args?.offset;
@@ -692,7 +698,7 @@ export class ToolExecutionComponent extends Container {
 					}
 				}
 			}
-		} else if (this.toolName === "write") {
+		} else if (normalizedToolName === "write") {
 			const rawPath = str(this.args?.file_path ?? this.args?.path);
 			const fileContent = str(this.args?.content);
 			const path = rawPath !== null ? shortenPath(rawPath) : null;
@@ -751,7 +757,7 @@ export class ToolExecutionComponent extends Container {
 					text += `\n\n${theme.fg("error", errorText)}`;
 				}
 			}
-		} else if (this.toolName === "edit") {
+		} else if (normalizedToolName === "edit") {
 			const rawPath = str(this.args?.file_path ?? this.args?.path);
 			const path = rawPath !== null ? shortenPath(rawPath) : null;
 
@@ -787,7 +793,7 @@ export class ToolExecutionComponent extends Container {
 					text += `\n\n${renderDiff(this.editDiffPreview.diff, { filePath: rawPath ?? undefined })}`;
 				}
 			}
-		} else if (this.toolName === "ls") {
+		} else if (normalizedToolName === "ls") {
 			const rawPath = str(this.args?.path);
 			const path = rawPath !== null ? shortenPath(rawPath || ".") : null;
 			const limit = this.args?.limit;
@@ -824,7 +830,7 @@ export class ToolExecutionComponent extends Container {
 					text += `\n${theme.fg("warning", `[Truncated: ${warnings.join(", ")}]`)}`;
 				}
 			}
-		} else if (this.toolName === "find") {
+		} else if (normalizedToolName === "find") {
 			const pattern = str(this.args?.pattern);
 			const rawPath = str(this.args?.path);
 			const path = rawPath !== null ? shortenPath(rawPath || ".") : null;
@@ -866,7 +872,7 @@ export class ToolExecutionComponent extends Container {
 					text += `\n${theme.fg("warning", `[Truncated: ${warnings.join(", ")}]`)}`;
 				}
 			}
-		} else if (this.toolName === "grep") {
+		} else if (normalizedToolName === "grep") {
 			const pattern = str(this.args?.pattern);
 			const rawPath = str(this.args?.path);
 			const path = rawPath !== null ? shortenPath(rawPath || ".") : null;
@@ -916,7 +922,7 @@ export class ToolExecutionComponent extends Container {
 					text += `\n${theme.fg("warning", `[Truncated: ${warnings.join(", ")}]`)}`;
 				}
 			}
-		} else if (this.toolName === "web_search") {
+		} else if (normalizedToolName === "web_search") {
 			// Server-side Anthropic web search
 			text = theme.fg("toolTitle", theme.bold("web search"));
 

package/packages/pi-coding-agent/src/modes/interactive/controllers/chat-controller.ts

@@ -121,6 +121,27 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
 			if (host.streamingComponent && event.message.role === "assistant") {
 				host.streamingMessage = event.message;
 				host.streamingComponent.updateContent(host.streamingMessage);
+
+				// When the stream adapter signals a completed tool call with an
+				// external result (from Claude Code SDK), update the pending
+				// ToolExecutionComponent immediately so output is visible in
+				// real-time instead of waiting for the session to end.
+				const innerEvent = event.assistantMessageEvent;
+				if (innerEvent.type === "toolcall_end" && innerEvent.toolCall) {
+					const tc = innerEvent.toolCall as any;
+					const externalResult = tc.externalResult;
+					if (externalResult) {
+						const component = host.pendingTools.get(tc.id);
+						if (component) {
+							component.updateResult({
+								content: externalResult.content ?? [{ type: "text", text: "" }],
+								details: externalResult.details ?? {},
+								isError: externalResult.isError ?? false,
+							});
+						}
+					}
+				}
+
 				const contentBlocks = host.streamingMessage.content;
 				for (let i = lastProcessedContentIndex; i < contentBlocks.length; i++) {
 					const content = contentBlocks[i];