@oh-my-pi/pi-coding-agent 16.1.22 → 16.2.0

package/src/edit/renderer.ts

@@ -2,7 +2,7 @@
  * Edit tool renderer and LSP batching helpers.
  */
 
-import { HL_FILE_PREFIX, HL_FILE_SUFFIX } from "@oh-my-pi/hashline";
+import { HL_FILE_PREFIX, HL_FILE_SUFFIX, HL_MOVE_KEYWORD, HL_REM_KEYWORD } from "@oh-my-pi/hashline";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { sliceWithWidth, visibleWidth, wrapTextWithAnsi } from "@oh-my-pi/pi-tui";
 import { sanitizeText } from "@oh-my-pi/pi-utils";
@@ -28,7 +28,15 @@ import {
 	shortenPath,
 	truncateDiffByHunk,
 } from "../tools/render-utils";
-import { fileHyperlink, framedBlock, Hasher, type RenderCache, renderStatusLine, truncateToWidth } from "../tui";
+import {
+	fileHyperlink,
+	framedBlock,
+	Hasher,
+	type RenderCache,
+	renderStatusLine,
+	truncateToWidth,
+	WidthAwareText,
+} from "../tui";
 import type { EditMode } from "../utils/edit-mode";
 import type { DiffError, DiffResult } from "./diff";
 import { type ApplyPatchEntry, expandApplyPatchToEntries, expandApplyPatchToPreviewEntries } from "./modes/apply-patch";
@@ -62,6 +70,8 @@ export interface EditToolPerFileResult {
 	oldText?: string;
 	/** Source-of-truth content after the edit; `undefined` for delete operations. */
 	newText?: string;
+	/** Pre-move source path; set only when the edit moved/renamed the file. The header renders `sourcePath → path`. */
+	sourcePath?: string;
 }
 
 export interface EditToolDetails {
@@ -85,6 +95,8 @@ export interface EditToolDetails {
 	oldText?: string;
 	/** Source-of-truth content after the edit; `undefined` for delete operations. */
 	newText?: string;
+	/** Pre-move source path; set only when the edit moved/renamed the file. The header renders `sourcePath → path`. */
+	sourcePath?: string;
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -119,8 +131,16 @@ type EditRenderEntry = {
 	op?: Operation;
 };
 
+interface HashlineInputEntry {
+	path: string;
+	op?: Operation;
+	rename?: string;
+	/** A SWAP/DEL/INS line-editing op precedes the file op — keeps a move framed. */
+	hasLineEdits?: boolean;
+}
+
 interface HashlineInputRenderSummary {
-	entries: Array<{ path: string }>;
+	entries: HashlineInputEntry[];
 }
 
 interface ApplyPatchRenderSummary {
@@ -293,9 +313,10 @@ function renderEditHeader(
 		linkPath?: string;
 		statsSuffix?: string;
 		extraSuffix?: string;
+		title?: string;
 	},
 ): string {
-	const title = getOperationTitle(options.op);
+	const title = options.title ?? getOperationTitle(options.op);
 	const descriptionOptions: EditPathDisplayOptions = {
 		rename: options.rename,
 		firstChangedLine: options.firstChangedLine,
@@ -327,6 +348,51 @@ function renderEditHeader(
 	return buildHeader(fitted.description);
 }
 
+/**
+ * Inline status row for delete / move-only edits — they carry no diff, so they
+ * render as a single line instead of an empty framed container. The completed
+ * result uses the eraser/move glyph; a still-streaming call uses the shared
+ * pending hourglass like every other tool.
+ */
+function renderInlineEditRow(
+	uiTheme: Theme,
+	opts: { op?: Operation; rename?: string; rawPath: string; linkPath?: string; pending: boolean },
+): Component {
+	const isDelete = opts.op === "delete";
+	return new WidthAwareText(
+		width =>
+			renderEditHeader(width, uiTheme, {
+				icon: opts.pending ? "pending" : undefined,
+				iconOverride: opts.pending
+					? undefined
+					: uiTheme.styledSymbol(isDelete ? "tool.delete" : "tool.move", "accent"),
+				op: opts.op,
+				title: isDelete ? "Delete" : "Move",
+				rawPath: opts.rawPath,
+				rename: opts.rename,
+				linkPath: opts.linkPath,
+			}),
+		0,
+		0,
+	);
+}
+
+/**
+ * Whether a streaming edit call carries any payload worth boxing (a diff
+ * preview, replacement text, or a non-empty edits array). Used to keep a
+ * move-with-edits framed while a payload-less move/delete folds to an inline
+ * row — gated on args, not the async preview, so it can't flash inline before
+ * the diff arrives.
+ */
+function hasEditCallPayload(args: EditRenderArgs, renderContext: EditRenderContext | undefined): boolean {
+	const multi = renderContext?.perFileDiffPreview;
+	if (multi && multi.length > 1 && multi.some(p => p.diff || p.error)) return true;
+	if (args.previewDiff || args.diff || args.newText || args.patch) return true;
+	if (Array.isArray(args.edits) && args.edits.length > 0) return true;
+	if (renderContext?.editStreamingFallback) return true;
+	return false;
+}
+
 function renderPlainTextPreview(text: string, uiTheme: Theme, _filePath?: string): string {
 	const previewLines = sanitizeText(text).split("\n");
 	let preview = "\n\n";
@@ -491,15 +557,39 @@ function parseHashlineInputPreviewHeader(line: string): string | null {
 	return previewPath.length > 0 ? previewPath : null;
 }
 
-function getHashlineInputPaths(input: string): string[] {
+// Line-editing op headers (SWAP/DEL/INS family), distinct from the file-level
+// REM/MV ops. Body rows are always `+TEXT`, so this only matches real headers.
+const HL_LINE_OP_HEADER = /^(?:SWAP|DEL|INS)\b/;
+
+/**
+ * Walk a (possibly mid-stream) hashline payload into per-section descriptors:
+ * the target path plus any file-level op (`REM` → delete, `MV dest` → rename)
+ * and whether a line edit precedes it. Tolerant of partial input so the call
+ * preview can label a delete/move before the payload finishes streaming.
+ */
+function getHashlineInputSections(input: string): HashlineInputEntry[] {
 	const stripped = input.startsWith("\uFEFF") ? input.slice(1) : input;
-	const paths: string[] = [];
+	const entries: HashlineInputEntry[] = [];
+	let current: HashlineInputEntry | undefined;
 	for (const rawLine of stripped.split("\n")) {
 		const line = rawLine.replace(/\r$/, "");
-		const path = parseHashlineInputPreviewHeader(line);
-		if (path) paths.push(path);
+		const headerPath = parseHashlineInputPreviewHeader(line);
+		if (headerPath) {
+			current = { path: headerPath };
+			entries.push(current);
+			continue;
+		}
+		if (!current) continue;
+		const trimmed = line.trim();
+		if (trimmed === HL_REM_KEYWORD) {
+			current.op = "delete";
+		} else if (trimmed.startsWith(`${HL_MOVE_KEYWORD} `)) {
+			current.rename = normalizeHashlineInputPreviewPath(trimmed.slice(HL_MOVE_KEYWORD.length + 1));
+		} else if (HL_LINE_OP_HEADER.test(trimmed)) {
+			current.hasLineEdits = true;
+		}
 	}
-	return paths;
+	return entries;
 }
 
 function getHashlineInputRenderSummary(
@@ -509,7 +599,7 @@ function getHashlineInputRenderSummary(
 	if (editMode !== "hashline" || typeof args.input !== "string") {
 		return undefined;
 	}
-	return { entries: getHashlineInputPaths(args.input).map(path => ({ path })) };
+	return { entries: getHashlineInputSections(args.input) };
 }
 
 function getApplyPatchRenderSummary(
@@ -627,12 +717,24 @@ export const editToolRenderer = {
 			firstHashlineInputEntry?.path ||
 			firstApplyPatchEntry?.path ||
 			"";
-		const rename = editArgs.rename || firstEdit?.rename || firstEdit?.move || firstApplyPatchEntry?.rename;
-		const op = editArgs.op || firstEdit?.op || firstApplyPatchEntry?.op;
+		const rename =
+			editArgs.rename ||
+			firstEdit?.rename ||
+			firstEdit?.move ||
+			firstApplyPatchEntry?.rename ||
+			firstHashlineInputEntry?.rename;
+		const op = editArgs.op || firstEdit?.op || firstApplyPatchEntry?.op || firstHashlineInputEntry?.op;
 		let fileCount = hashlineInputSummary?.entries.length ?? applyPatchSummary?.entries.length ?? 0;
 		if (Array.isArray(editArgs.edits)) {
 			fileCount = countEditFiles(editArgs.edits);
 		}
+		// Delete / payload-less move calls render as an inline pending row (no
+		// empty framed container), mirroring the completed result but with the
+		// shared hourglass instead of the eraser/move glyph.
+		const hasPayload = hasEditCallPayload(editArgs, renderContext) || Boolean(firstHashlineInputEntry?.hasLineEdits);
+		if (fileCount <= 1 && !applyPatchSummary?.error && (op === "delete" || (rename !== undefined && !hasPayload))) {
+			return renderInlineEditRow(uiTheme, { op, rename, rawPath, pending: true });
+		}
 		const callPreviewCaches: RenderedStringCache[] = [];
 		return framedBlock(uiTheme, width => {
 			// No status icon on the head row: it's the head of the framed block,
@@ -702,7 +804,9 @@ function renderSingleFileResult(
 	const firstEdit = args?.edits?.[0];
 	const hashlineInputSummary = getHashlineInputRenderSummary(args ?? {}, options.renderContext?.editMode);
 	const firstHashlineInputEntry = hashlineInputSummary?.entries[0];
+	const moveSource = details && "sourcePath" in details ? details.sourcePath : undefined;
 	const rawPath =
+		moveSource ||
 		args?.file_path ||
 		args?.path ||
 		filePathFromEditEntry(firstEdit?.path) ||
@@ -719,12 +823,26 @@ function renderSingleFileResult(
 			(result.content?.find(c => c.type === "text")?.text ?? "")
 		: "";
 
+	// Delete and move-only results carry no diff to box. Per design these render
+	// as an inline status row (eraser / move glyph) rather than an empty framed
+	// container. Errors, no-ops, creates, move-with-edits, and anything with
+	// diagnostics keep the framed block below.
+	if (!isError && !details?.diff && !details?.diagnostics && (op === "delete" || rename)) {
+		const linkPath = details && "path" in details ? details.path : undefined;
+		return renderInlineEditRow(uiTheme, { op, rename, rawPath, linkPath, pending: false });
+	}
+
 	let diffSectionRenderDiffFn: ((t: string, o?: { filePath?: string }) => string) | undefined;
 	const diffSectionCache = createRenderedStringCache();
 
 	return framedBlock(uiTheme, width => {
 		const { expanded, renderContext } = options;
-		const editDiffPreview = renderContext?.editDiffPreview;
+		// A finalized result is authoritative: its `details` describe exactly
+		// what happened. The shared streaming `editDiffPreview` is a call-phase
+		// artifact (in a batch it reflects only the first file), so consulting it
+		// for an empty-diff delete/move/no-op result mislabels the card. Fall
+		// back to the preview only when no details exist yet.
+		const editDiffPreview = details ? undefined : renderContext?.editDiffPreview;
 		const renderDiffFn = renderContext?.renderDiff ?? plainDiffRender;
 
 		if (diffSectionRenderDiffFn !== renderDiffFn) {
@@ -756,6 +874,15 @@ function renderSingleFileResult(
 			if (errorText) body = uiTheme.fg("error", replaceTabs(errorText));
 		} else if (details?.diff) {
 			body = renderDiffSection(details.diff, rawPath, expanded, uiTheme, renderDiffFn, diffSectionCache);
+		} else if (details) {
+			// Authoritative result with no textual diff: a delete, a move-only
+			// rename, or a genuine no-op. The header already names the op
+			// (Delete / `src → dst`); only a true no-op needs an explanatory
+			// body so an empty card isn't mistaken for a stalled edit.
+			if (op !== "delete" && op !== "create" && !rename) {
+				const noChangePath = linkPath ? shortenPath(linkPath) : rawPath ? shortenPath(rawPath) : "";
+				body = uiTheme.fg("dim", `No changes were made${noChangePath ? ` to ${noChangePath}` : ""}.`);
+			}
 		} else if (editDiffPreview) {
 			if ("error" in editDiffPreview) body = uiTheme.fg("error", replaceTabs(editDiffPreview.error));
 			else if (editDiffPreview.diff)

package/src/eval/__tests__/agent-bridge.test.ts

@@ -3,7 +3,11 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { TempDir } from "@oh-my-pi/pi-utils";
 import { Settings } from "../../config/settings";
+import { AgentProtocolHandler } from "../../internal-urls/agent-protocol";
+import { resetRegisteredArtifactDirsForTests } from "../../internal-urls/registry-helpers";
 import type { PlanModeState } from "../../plan-mode/state";
+import { AgentRegistry } from "../../registry/agent-registry";
+import type { AgentSession } from "../../session/agent-session";
 import * as taskDiscovery from "../../task/discovery";
 import type { ExecutorOptions } from "../../task/executor";
 import * as taskExecutor from "../../task/executor";
@@ -154,6 +158,8 @@ function spyConcurrencyBarrier(limit: number): { maxInFlight: () => number } {
 describe("runEvalAgent", () => {
 	afterEach(() => {
 		vi.restoreAllMocks();
+		AgentRegistry.resetGlobalForTests();
+		resetRegisteredArtifactDirsForTests();
 	});
 
 	it("resolves the default task agent and agent overrides", async () => {
@@ -246,6 +252,62 @@ describe("runEvalAgent", () => {
 		const options = runSpy.mock.calls[0]?.[0];
 		if (!options) throw new Error("runSubprocess was not called");
 		expect(options.enableLsp).toBe(false);
+		expect(options.keepAlive).toBe(false);
+	});
+
+	it("registers temp artifact dirs for in-memory handle results so agent URLs resolve", async () => {
+		mockAgents();
+		vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => {
+			if (!options.artifactsDir) throw new Error("artifactsDir missing");
+			await fs.mkdir(options.artifactsDir, { recursive: true });
+			await fs.writeFile(path.join(options.artifactsDir, `${options.id}.md`), "recoverable output");
+			return singleResult(options, { output: "recoverable output" });
+		});
+
+		const result = await runEvalAgent({ prompt: "hello", handle: true }, { session: makeSession() });
+		const resource = await new AgentProtocolHandler().resolve(new URL(`agent://${result.details.id}`) as never);
+
+		expect(resource.content).toBe("recoverable output");
+	});
+
+	it("unregisters eval subagents through the bridge cleanup path", async () => {
+		AgentRegistry.resetGlobalForTests();
+		mockAgents();
+		let disposed = false;
+		const cleanupSession = {
+			dispose: async () => {
+				disposed = true;
+			},
+		} as unknown as AgentSession;
+		vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => {
+			AgentRegistry.global().register({
+				id: options.id,
+				displayName: options.id,
+				kind: "sub",
+				session: cleanupSession,
+				status: "idle",
+			});
+			await taskExecutor.finalizeSubagentLifecycle({
+				id: options.id,
+				session: cleanupSession,
+				aborted: false,
+				keepAlive: options.keepAlive !== false,
+				isolated: options.worktree !== undefined,
+				agentIdleTtlMs: 0,
+				reviveSession: null,
+			});
+			return singleResult(options);
+		});
+
+		await runEvalAgent({ prompt: "hello", label: "Cleanup" }, { session: makeSession() });
+
+		expect(disposed).toBe(true);
+		expect(AgentRegistry.global().get("Cleanup")).toBeUndefined();
+		expect(
+			AgentRegistry.global()
+				.listVisibleTo("Main")
+				.map(ref => ref.id),
+		).not.toContain("Cleanup");
 	});
 
 	it("maps successful and failed subagent results", async () => {
@@ -1096,6 +1158,45 @@ describe("runEvalAgent isolation", () => {
 		await fs.rm(path.dirname(persistedPath!), { recursive: true, force: true });
 	});
 
+	it("throws schema calls when nested patch application reports a warning", async () => {
+		mockAgents();
+		mockIsolationContext();
+		const nestedPatch = "diff --git a/file b/file\n";
+		vi.spyOn(isolationRunner, "runIsolatedSubprocess").mockImplementation(async opts =>
+			singleResult(opts.baseOptions, {
+				output: JSON.stringify({ status: "ok" }),
+				patchPath: `/artifacts/${opts.agentId}.patch`,
+				nestedPatches: [{ relativePath: "sub/nested", patch: nestedPatch }],
+			}),
+		);
+		vi.spyOn(isolationRunner, "mergeIsolatedChanges").mockResolvedValue({
+			summary: "\n\nApplied patches: yes",
+			changesApplied: true,
+			hadAnyChanges: true,
+			mergedBranchForNestedPatches: false,
+		});
+		vi.spyOn(isolationRunner, "applyEligibleNestedPatches").mockResolvedValue(
+			"\n\n<system-notification>Some nested repository patches failed to apply.</system-notification>",
+		);
+
+		await expect(
+			runEvalAgent(
+				{
+					prompt: "structured",
+					isolated: true,
+					schema: {
+						type: "object",
+						properties: { status: { type: "string" } },
+						required: ["status"],
+					},
+				},
+				{ session: isolatedSession() },
+			),
+		).rejects.toThrow(
+			/nested patch apply failed.*Some nested repository patches failed to apply.*nested-0-sub_nested\.patch/s,
+		);
+	});
+
 	it("skips the merge phase when apply=false and surfaces the patch artifact instead", async () => {
 		mockAgents();
 		mockIsolationContext();

package/src/eval/__tests__/julia-prelude.test.ts

@@ -45,4 +45,22 @@ nothing
 		expect(result.output).toContain("META=alpha:true");
 		expect(result.output).toContain("MULTI=2:alpha:json");
 	}, 30_000);
+
+	it("surfaces the exception type and message in the error output, not just stack frames", async () => {
+		using tempDir = TempDir.createSync("@omp-eval-julia-error-");
+		const result = await executeJulia(`println("="^8)\nmissing_var_xyz + 1`, {
+			cwd: tempDir.path(),
+			sessionId: `julia-prelude-error:${crypto.randomUUID()}`,
+			kernelOwnerId: OWNER_ID,
+			reset: true,
+		});
+
+		// The rendered error must carry the actual exception, not only the
+		// runner-internal backtrace frames (regression: traceback-only output
+		// hid `ename`/`evalue`).
+		expect(result.output).toContain("UndefVarError");
+		expect(result.output).toContain("missing_var_xyz");
+		// Frames are still present alongside the message.
+		expect(result.output).toContain("top-level scope");
+	}, 30_000);
 });

package/src/eval/agent-bridge.ts

@@ -8,6 +8,7 @@ import { prompt, Snowflake } from "@oh-my-pi/pi-utils";
 import { type } from "arktype";
 import { resolveAgentModelPatterns } from "../config/model-resolver";
 import type { LocalProtocolOptions } from "../internal-urls";
+import { registerArtifactsDir } from "../internal-urls/registry-helpers";
 import { MCPManager } from "../mcp/manager";
 import subagentUserPromptTemplate from "../prompts/system/subagent-user-prompt.md" with { type: "text" };
 import { MAIN_AGENT_ID } from "../registry/agent-registry";
@@ -189,6 +190,7 @@ function getOutputManager(session: ToolSession): AgentOutputManager {
 interface ArtifactPaths {
 	sessionFile: string | null;
 	artifactsDir: string;
+	unregisterArtifactsDir?: () => void;
 	/**
 	 * True when `artifactsDir` was created off the session path (no session
 	 * file). Caller is then free to `rm -rf` it once all isolated patch
@@ -203,7 +205,8 @@ async function getArtifacts(session: ToolSession): Promise<ArtifactPaths> {
 	const tempArtifactsDir = sessionArtifactsDir === null;
 	const artifactsDir = sessionArtifactsDir ?? path.join(os.tmpdir(), `omp-eval-agent-${Snowflake.next()}`);
 	await fs.mkdir(artifactsDir, { recursive: true });
-	return { sessionFile, artifactsDir, tempArtifactsDir };
+	const unregisterArtifactsDir = tempArtifactsDir ? registerArtifactsDir(artifactsDir) : undefined;
+	return { sessionFile, artifactsDir, unregisterArtifactsDir, tempArtifactsDir };
 }
 
 /**
@@ -229,6 +232,10 @@ async function persistNestedPatches(
 	return written;
 }
 
+function plainIsolationSummary(summary: string): string {
+	return summary.replace(/<\/?system-notification>/g, "").trim();
+}
+
 function emitProgressStatus(emitStatus: ((event: JsStatusEvent) => void) | undefined, progress: AgentProgress): void {
 	if (!emitStatus) return;
 	const preview = (progress.assignment ?? progress.task ?? "").split("\n")[0]?.slice(0, 120);
@@ -324,7 +331,7 @@ export async function runEvalAgent(args: unknown, options: EvalAgentBridgeOption
 	};
 	const parentArtifactManager = options.session.getArtifactManager?.() ?? undefined;
 	const mcpManager = options.session.mcpManager ?? MCPManager.instance();
-	const { sessionFile, artifactsDir, tempArtifactsDir } = await getArtifacts(options.session);
+	const { sessionFile, artifactsDir, unregisterArtifactsDir, tempArtifactsDir } = await getArtifacts(options.session);
 	const outputManager = getOutputManager(options.session);
 	const id = await outputManager.allocate(outputIdBase(parsed.label, agentName));
 	const assignment = parsed.prompt.trim();
@@ -385,6 +392,7 @@ export async function runEvalAgent(args: unknown, options: EvalAgentBridgeOption
 		// must not be killed by `task.maxRuntimeMs`. Force the limit off
 		// regardless of the inherited session setting.
 		maxRuntimeMs: 0,
+		keepAlive: false,
 		mcpManager,
 		contextFiles,
 		skills: availableSkills,
@@ -494,7 +502,7 @@ export async function runEvalAgent(args: unknown, options: EvalAgentBridgeOption
 					);
 				}
 
-				mergeSummary += await applyEligibleNestedPatches({
+				const nestedSummary = await applyEligibleNestedPatches({
 					result,
 					repoRoot: isolationContext.repoRoot,
 					mergeMode,
@@ -502,6 +510,20 @@ export async function runEvalAgent(args: unknown, options: EvalAgentBridgeOption
 					mergedBranchForNestedPatches: outcome.mergedBranchForNestedPatches,
 					commitMessage: buildCommitMessage(),
 				});
+				mergeSummary += nestedSummary;
+				if (structured && nestedSummary.trim()) {
+					const recoveryParts: string[] = [];
+					if (result.nestedPatches?.length) {
+						const nestedPaths = await persistNestedPatches(artifactsDir, result.id, result.nestedPatches);
+						recoveryParts.push(
+							`Captured nested repository patches (${result.nestedPatches.length}) preserved at: ${nestedPaths.join(", ")}.`,
+						);
+					}
+					const recoveryHint = recoveryParts.length > 0 ? ` ${recoveryParts.join(" ")}` : "";
+					throw new ToolError(
+						`agent() isolated nested patch apply failed for ${result.id}: ${plainIsolationSummary(nestedSummary)}${recoveryHint}`,
+					);
+				}
 			} else if (result.branchName) {
 				mergeSummary = `\n\nIsolation: changes captured on branch \`${result.branchName}\` (apply=false). Not merged.`;
 			} else if (result.patchPath) {
@@ -526,6 +548,7 @@ export async function runEvalAgent(args: unknown, options: EvalAgentBridgeOption
 		const shouldCleanupTempArtifacts = tempArtifactsDir && !parsed.handle && (!isIsolated || changesApplied === true);
 		if (shouldCleanupTempArtifacts) {
 			await fs.rm(artifactsDir, { recursive: true, force: true });
+			unregisterArtifactsDir?.();
 		}
 
 		options.session.recordEvalSubagentUsage?.(result.usage?.output ?? 0);

package/src/eval/jl/runner.jl

@@ -522,7 +522,13 @@ function emit_error(rid, err, bt)
     end
     err_str = String(take!(io))
     
-    tb = String[]
+    # Seed the traceback with the rendered exception text so the array is a
+    # self-contained error display, matching the Python and Ruby runners. The
+    # host shows `traceback` verbatim when present and only falls back to
+    # `ename: evalue` when it is empty, so a frames-only traceback would hide
+    # the real error. Julia's `showerror` output already embeds the exception
+    # type for nearly every error and mirrors what the REPL prints after `ERROR: `.
+    tb = isempty(err_str) ? String[] : String[err_str]
     for frame in stacktrace(bt)
         file = string(frame.file)
         line = frame.line

package/src/eval/js/tool-bridge.ts

@@ -88,9 +88,9 @@ function summarizeToolResult(
 				path: record.path,
 				count: details.matchCount ?? undefined,
 			});
-		case "find":
+		case "glob":
 			return withError({
-				op: "find",
+				op: "glob",
 				pattern: record.pattern,
 				count: details.fileCount ?? undefined,
 				matches: Array.isArray(details.files) ? details.files.slice(0, 20) : undefined,

package/src/export/html/index.ts

@@ -9,7 +9,7 @@ import { SessionManager } from "../../session/session-manager";
 import templateCss from "./template.css" with { type: "text" };
 import templateHtml from "./template.html" with { type: "text" };
 import templateJs from "./template.js" with { type: "text" };
-// Pre-built React tool renderers: built by `bun --cwd=packages/collab-web run build:tool-views`,
+// Pre-built React tool renderers: built by `gen:tool-views` (`bun run gen:tool-views`),
 // run automatically by root `prepare` on install and by `prepack` at publish.
 import toolViewsJs from "./tool-views.generated.js" with { type: "text" };
 import { webExportThemeVars } from "./web-palette";

package/src/export/html/template.js

@@ -433,10 +433,12 @@
             const cmd = rawCmd.replace(/[\n\t]/g, ' ').trim().slice(0, 50);
             return `[bash: ${cmd}${rawCmd.length > 50 ? '...' : ''}]`;
           }
+          case 'search':
           case 'grep':
             return `[grep: /${args.pattern || ''}/ in ${shortenPath(String((args.paths || [args.path || '.']).join(', ')))}]`;
           case 'find':
-            return `[find: ${shortenPath(String((args.paths || [args.pattern || '.']).join(', ')))}]`;
+          case 'glob':
+            return `[glob: ${shortenPath(String((args.paths || [args.pattern || '.']).join(', ')))}]`;
           case 'ls':
             return `[ls: ${shortenPath(String(args.path || '.'))}]`;
           default: {