@oh-my-pi/pi-coding-agent 15.9.3 → 15.9.67

package/src/tools/search.ts

@@ -16,7 +16,15 @@ import type { InternalResource, ResolveContext } from "../internal-urls/types";
 import type { Theme } from "../modes/theme/theme";
 import searchDescription from "../prompts/tools/search.md" with { type: "text" };
 import { DEFAULT_MAX_COLUMN, type TruncationResult, truncateHead, truncateLine } from "../session/streaming-output";
-import { Ellipsis, fileHyperlink, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
+import {
+	Ellipsis,
+	fileHyperlink,
+	renderStatusLine,
+	renderTreeList,
+	truncateToWidth,
+	tryResolveInternalUrlSync,
+	uriHyperlink,
+} from "../tui";
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
 import type { ToolSession } from ".";
 import {
@@ -1162,6 +1170,26 @@ interface SearchRenderArgs {
 
 const COLLAPSED_TEXT_LIMIT = PREVIEW_LIMITS.COLLAPSED_LINES * 2;
 
+const SEARCH_CODE_FRAME_LINE_RE = /^\s*\*?(\d+)│/;
+
+function searchScopeMeta(details: SearchToolDetails | undefined): string | undefined {
+	if (!details?.scopePath) return undefined;
+	const label = details.searchPath ? fileHyperlink(details.searchPath, details.scopePath) : details.scopePath;
+	return `in ${label}`;
+}
+
+function linkUrlLikeSearchHeader(raw: string, styled: string): { line: string; absPath?: string } {
+	const resolvedPath = tryResolveInternalUrlSync(raw);
+	if (resolvedPath) return { line: fileHyperlink(resolvedPath, styled), absPath: resolvedPath };
+	return { line: uriHyperlink(raw, styled) };
+}
+
+function parseSearchDisplayLineNumber(line: string): number | undefined {
+	const match = SEARCH_CODE_FRAME_LINE_RE.exec(line);
+	if (!match) return undefined;
+	return Number.parseInt(match[1]!, 10);
+}
+
 export const searchToolRenderer = {
 	inline: true,
 	renderCall(args: SearchRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
@@ -1237,8 +1265,11 @@ export const searchToolRenderer = {
 				: undefined;
 
 		if (matchCount === 0) {
+			const meta = ["0 matches"];
+			const scopeMeta = searchScopeMeta(details);
+			if (scopeMeta) meta.push(scopeMeta);
 			const header = renderStatusLine(
-				{ icon: "warning", title: "Search", description: args?.pattern, meta: ["0 matches"] },
+				{ icon: "warning", title: "Search", description: args?.pattern, meta },
 				uiTheme,
 			);
 			const lines = [header, formatEmptyMessage("No matches found", uiTheme)];
@@ -1248,7 +1279,8 @@ export const searchToolRenderer = {
 
 		const summaryParts = [formatCount("match", matchCount), formatCount("file", fileCount)];
 		const meta = [...summaryParts];
-		if (details?.scopePath) meta.push(`in ${details.scopePath}`);
+		const scopeMeta = searchScopeMeta(details);
+		if (scopeMeta) meta.push(scopeMeta);
 		if (truncated) meta.push(uiTheme.fg("warning", "truncated"));
 		const description = args?.pattern ?? undefined;
 		const header = renderStatusLine(
@@ -1287,10 +1319,11 @@ export const searchToolRenderer = {
 						maxCollapsedLines: collapsedMatchLineBudget,
 						itemType: "match",
 						renderItem: group => {
-							// Track directory context within a group for ## file headers.
-							// `# foo/` is a directory header; `# foo.ts` is a root-level file
-							// from formatGroupedFiles (single-# when directory is `.`).
+							// Track directory/file context within a group so headers and code-frame
+							// lines link to the backing file, with line-specific links for matches.
 							let contextDir = searchBase ?? "";
+							const hasFileHeader = group.some(line => line.startsWith("# "));
+							let currentFilePath: string | undefined = hasFileHeader ? undefined : searchBase;
 							return group.map(line => {
 								if (line.startsWith("## ")) {
 									// Strip optional ` (suffix)` and `#hash` before resolving.
@@ -1300,6 +1333,7 @@ export const searchToolRenderer = {
 										.replace(/\s+\([^)]*\)\s*$/, "")
 										.replace(/#[0-9a-f]+$/, "");
 									const absPath = contextDir && fileName ? path.join(contextDir, fileName) : undefined;
+									currentFilePath = absPath;
 									const styled = uiTheme.fg("dim", line);
 									return absPath ? fileHyperlink(absPath, styled) : styled;
 								}
@@ -1310,22 +1344,37 @@ export const searchToolRenderer = {
 										.replace(/\s+\([^)]*\)\s*$/, "");
 									if (INTERNAL_URL_DISPLAY_RE.test(raw)) {
 										contextDir = "";
-										return uiTheme.fg("accent", line);
+										const styled = uiTheme.fg("accent", line);
+										const linked = linkUrlLikeSearchHeader(raw, styled);
+										currentFilePath = linked.absPath;
+										return linked.line;
 									}
 									const isDirectory = raw.endsWith("/");
 									const name = isDirectory ? raw.replace(/\/$/, "") : raw.replace(/#[0-9a-f]+$/, "");
 									if (isDirectory) {
-										if (searchBase) {
-											contextDir = name === "." ? searchBase : path.join(searchBase, name);
+										const absPath = searchBase
+											? name === "."
+												? searchBase
+												: path.join(searchBase, name)
+											: undefined;
+										if (absPath) {
+											contextDir = absPath;
 										}
-										return uiTheme.fg("accent", line);
+										currentFilePath = undefined;
+										const styled = uiTheme.fg("accent", line);
+										return absPath ? fileHyperlink(absPath, styled) : styled;
 									}
 									// Root-level file emitted by formatGroupedFiles when the directory is `.`.
 									const absPath = searchBase && name ? path.join(searchBase, name) : undefined;
+									currentFilePath = absPath;
 									const styled = uiTheme.fg("accent", line);
 									return absPath ? fileHyperlink(absPath, styled) : styled;
 								}
-								return uiTheme.fg("toolOutput", line);
+								const styled = uiTheme.fg("toolOutput", line);
+								const lineNumber = parseSearchDisplayLineNumber(line);
+								return currentFilePath && lineNumber !== undefined
+									? fileHyperlink(currentFilePath, styled, { line: lineNumber })
+									: styled;
 							});
 						},
 					},

package/src/tools/ssh.ts

@@ -13,11 +13,11 @@ import type { SSHHostInfo } from "../ssh/connection-manager";
 import { ensureHostInfo, getHostInfoForHost } from "../ssh/connection-manager";
 import { executeSSH } from "../ssh/ssh-executor";
 import { renderStatusLine } from "../tui";
-import { CachedOutputBlock } from "../tui/output-block";
+import { CachedOutputBlock, markFramedBlockComponent } from "../tui/output-block";
 import type { ToolSession } from ".";
 import { truncateForPrompt } from "./approval";
 import { formatStyledTruncationWarning, type OutputMeta, stripOutputNotice } from "./output-meta";
-import { replaceTabs } from "./render-utils";
+import { capPreviewLines, replaceTabs } from "./render-utils";
 import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 import { clampTimeout } from "./tool-timeouts";
@@ -244,16 +244,22 @@ export const sshToolRenderer = {
 		const header = renderStatusLine({ icon: "pending", title: "SSH", description: `[${host}]` }, uiTheme);
 		const cmdLines = formatSshCommandLines(command, uiTheme);
 		const outputBlock = new CachedOutputBlock();
-		return {
+		return markFramedBlockComponent({
 			render: (width: number): string[] =>
 				outputBlock.render(
-					{ header, state: "pending", sections: [{ lines: cmdLines }], width, animate: true },
+					{
+						header,
+						state: "pending",
+						sections: [{ lines: capPreviewLines(cmdLines, uiTheme, { expanded: _options.expanded }) }],
+						width,
+						animate: true,
+					},
 					uiTheme,
 				),
 			invalidate: () => {
 				outputBlock.invalidate();
 			},
-		};
+		});
 	},
 
 	renderResult(
@@ -273,7 +279,7 @@ export const sshToolRenderer = {
 		const textContent = result.content?.find(c => c.type === "text")?.text ?? "";
 		const outputBlock = new CachedOutputBlock();
 
-		return {
+		return markFramedBlockComponent({
 			render: (width: number): string[] => {
 				// REACTIVE: read mutable options at render time
 				const { expanded, renderContext } = options;
@@ -319,7 +325,14 @@ export const sshToolRenderer = {
 					{
 						header,
 						state: "success",
-						sections: [{ lines: cmdLines }, { label: uiTheme.fg("toolTitle", "Output"), lines: outputLines }],
+						sections: [
+							{
+								lines: options.isPartial
+									? capPreviewLines(cmdLines, uiTheme, { expanded: options.expanded })
+									: cmdLines,
+							},
+							{ label: uiTheme.fg("toolTitle", "Output"), lines: outputLines },
+						],
 						width,
 					},
 					uiTheme,
@@ -328,7 +341,7 @@ export const sshToolRenderer = {
 			invalidate: () => {
 				outputBlock.invalidate();
 			},
-		};
+		});
 	},
 	mergeCallAndResult: true,
 };

package/src/tools/write.ts

@@ -58,7 +58,7 @@ import {
 import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 
-const LOOSE_HASHLINE_HEADER_RE = /^\s*¶\S+#[^ \t\r\n]*\s*$/;
+const LOOSE_HASHLINE_HEADER_RE = /^\s*\[[^#\r\n]+#[^ \t\r\n]*\]\s*$/;
 
 let fflateModulePromise: Promise<typeof import("fflate")> | undefined;
 async function loadFflate(): Promise<typeof import("fflate")> {
@@ -109,7 +109,7 @@ function stripWriteContentWithPotentialLooseHeader(lines: string[]): { text: str
 /**
  * Strip hashline display prefixes from write content.
  *
- * Only active when hashline edit mode is enabled — the model sees `¶PATH#HASH`
+ * Only active when hashline edit mode is enabled — the model sees `[PATH#HASH]`
  * headers plus `LINE:` prefixes in read output and sometimes copies them into write content.
  */
 function stripWriteContent(session: ToolSession, content: string): { text: string; stripped: boolean } {
@@ -122,7 +122,7 @@ function stripWriteContent(session: ToolSession, content: string): { text: strin
 /**
  * Record a snapshot of the freshly-written `content` for `absolutePath`
  * so subsequent hashline edits address the new file with a current tag,
- * and return the matching `¶displayPath#TAG` header. Returns `undefined`
+ * and return the matching `[displayPath#TAG]` header. Returns `undefined`
  * when the session is not in hashline mode so callers can no-op cheaply.
  *
  * Mirrors the post-commit snapshot recording the hashline patcher performs
@@ -770,7 +770,7 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 		context?: AgentToolContext,
 	): Promise<AgentToolResult<WriteToolDetails>> {
 		return untilAborted(signal, async () => {
-			// Strip hashline display prefixes (¶PATH#HASH + LINE:) if the model copied them from read output
+			// Strip hashline display prefixes ([PATH#HASH] + LINE:) if the model copied them from read output
 			const { text: cleanContent, stripped } = stripWriteContent(this.session, content);
 			const internalRouter = InternalUrlRouter.instance();
 			if (internalRouter.canHandle(path)) {
@@ -935,11 +935,20 @@ function normalizeDisplayText(text: string): string {
 	return text.replace(/\r/g, "");
 }
 
-function formatStreamingContent(content: string, language: string | undefined, uiTheme: Theme): string {
+function formatStreamingContent(
+	content: string,
+	expanded: boolean,
+	language: string | undefined,
+	uiTheme: Theme,
+): string {
 	if (!content) return "";
 	const lines = normalizeDisplayText(content).split("\n");
 	const totalLines = lines.length;
-	const startIndex = Math.max(0, totalLines - WRITE_STREAMING_PREVIEW_LINES);
+	// Collapsed: follow the streaming edge with a bounded tail window so the box
+	// stays short enough not to strand its scrolled-off head above the viewport
+	// while the block is volatile. `Ctrl+O` (expanded) lifts the cap for a
+	// deliberate full view — matching the eval streaming preview.
+	const startIndex = expanded ? 0 : Math.max(0, totalLines - WRITE_STREAMING_PREVIEW_LINES);
 	const visibleLines = lines.slice(startIndex);
 	const hidden = startIndex;
 	const highlighted = highlightCode(visibleLines.join("\n"), language);
@@ -1005,8 +1014,8 @@ export const writeToolRenderer = {
 			return new Text(text, 0, 0);
 		}
 
-		// Show streaming preview of content (tail)
-		text += formatStreamingContent(args.content, lang, uiTheme);
+		// Show streaming preview of content — bounded tail while collapsed, full on Ctrl+O.
+		text += formatStreamingContent(args.content, Boolean(options?.expanded), lang, uiTheme);
 
 		return new Text(text, 0, 0);
 	},

package/src/tui/code-cell.ts

@@ -25,6 +25,12 @@ export interface CodeCellOptions {
 	output?: string;
 	outputMaxLines?: number;
 	codeMaxLines?: number;
+	/**
+	 * Show the LAST `codeMaxLines` rows (the live streaming edge) instead of the
+	 * first, with a "… N earlier lines" marker on top. Lets a pending preview
+	 * follow code as it is written while staying bounded. Ignored when `expanded`.
+	 */
+	codeTail?: boolean;
 	expanded?: boolean;
 	/** Animate the cell border with a sweeping segment while pending/running. */
 	animate?: boolean;
@@ -102,13 +108,22 @@ export function renderCodeCell(options: CodeCellOptions, theme: Theme): string[]
 	const normalizedCode = replaceTabs(code ?? "");
 	const rawCodeLines = sanitizeTerminalLines(normalizedCode);
 	const maxCodeLines = expanded ? rawCodeLines.length : Math.min(rawCodeLines.length, codeMaxLines);
-	const visibleCode = rawCodeLines.slice(0, maxCodeLines).join("\n");
-	const codeLines = highlightCode(visibleCode, language);
 	const hiddenCodeLines = rawCodeLines.length - maxCodeLines;
+	const tail = options.codeTail === true && !expanded && hiddenCodeLines > 0;
+	const startIndex = tail ? rawCodeLines.length - maxCodeLines : 0;
+	const visibleCode = rawCodeLines.slice(startIndex, startIndex + maxCodeLines).join("\n");
+	const codeLines = highlightCode(visibleCode, language);
 	if (hiddenCodeLines > 0) {
 		const hint = formatExpandHint(theme, expanded, hiddenCodeLines > 0);
-		const moreLine = `${formatMoreItems(hiddenCodeLines, "line")}${hint ? ` ${hint}` : ""}`;
-		codeLines.push(theme.fg("dim", moreLine));
+		if (tail) {
+			// Earlier rows scrolled above the live tail window — mark them on top so
+			// the newest streamed line stays pinned to the bottom of the box.
+			const earlier = `… ${hiddenCodeLines} earlier line${hiddenCodeLines === 1 ? "" : "s"}${hint ? ` ${hint}` : ""}`;
+			codeLines.unshift(theme.fg("dim", earlier));
+		} else {
+			const moreLine = `${formatMoreItems(hiddenCodeLines, "line")}${hint ? ` ${hint}` : ""}`;
+			codeLines.push(theme.fg("dim", moreLine));
+		}
 	}
 
 	const outputLines: string[] = [];

package/src/tui/hyperlink.ts

@@ -1,5 +1,5 @@
 /**
- * OSC 8 terminal hyperlink support for file paths.
+ * OSC 8 terminal hyperlink support for paths and URLs.
  *
  * Wraps display text in `ESC ] 8 ; id=HASH ; URI ESC \ TEXT ESC ] 8 ; ; ESC \`
  * sequences when the active terminal supports hyperlinks and the user setting
@@ -63,6 +63,46 @@ export function isHyperlinkEnabled(): boolean {
 	return TERMINAL.hyperlinks;
 }
 
+function safeHyperlinkUri(uri: string): string | undefined {
+	if (!uri || /[\x00-\x1f\x7f]/.test(uri)) return undefined;
+	return uri;
+}
+
+function wrapHyperlink(uri: string, displayText: string): string {
+	if (!isHyperlinkEnabled()) return displayText;
+	// Do not double-wrap if the text already embeds an OSC 8 sequence.
+	if (displayText.includes("\x1b]8;")) return displayText;
+	const safeUri = safeHyperlinkUri(uri);
+	if (!safeUri) return displayText;
+	const id = buildLinkId(safeUri);
+	return `${OSC}8;id=${id};${safeUri}${ST}${displayText}${OSC}8;;${ST}`;
+}
+
+/**
+ * Wrap `displayText` in an OSC 8 hyperlink pointing at `uri`.
+ *
+ * Returns `displayText` unchanged when hyperlinks are disabled, `uri` contains
+ * terminal control bytes, or `displayText` already contains an OSC 8 sequence.
+ */
+export function uriHyperlink(uri: string, displayText: string): string {
+	return wrapHyperlink(uri, displayText);
+}
+
+/**
+ * Wrap `displayText` in an OSC 8 hyperlink pointing at an HTTP(S) URL.
+ * `www.example.com` inputs are linked as `https://www.example.com`.
+ */
+export function urlHyperlink(url: string, displayText: string): string {
+	const normalized = url.match(/^www\./i) ? `https://${url}` : url;
+	try {
+		const parsed = new URL(normalized);
+		if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return displayText;
+		return wrapHyperlink(parsed.href, displayText);
+	} catch {
+		return displayText;
+	}
+}
+
 /**
  * Wrap `displayText` in an OSC 8 hyperlink pointing at the given absolute file path.
  *
@@ -78,12 +118,7 @@ export function isHyperlinkEnabled(): boolean {
  * @param opts - Optional line/col position appended as `?line=N&col=M` query params
  */
 export function fileHyperlink(absPath: string, displayText: string, opts?: { line?: number; col?: number }): string {
-	if (!isHyperlinkEnabled()) return displayText;
-	// Do not double-wrap if the text already embeds an OSC 8 sequence.
-	if (displayText.includes("\x1b]8;")) return displayText;
-	const uri = buildFileUri(absPath, opts);
-	const id = buildLinkId(uri);
-	return `${OSC}8;id=${id};${uri}${ST}${displayText}${OSC}8;;${ST}`;
+	return wrapHyperlink(buildFileUri(absPath, opts), displayText);
 }
 
 /**

package/src/tui/output-block.ts

@@ -1,6 +1,7 @@
 /**
  * Bordered output container with optional header and sections.
  */
+import type { Component } from "@oh-my-pi/pi-tui";
 import { ImageProtocol, padding, TERMINAL, visibleWidth, wrapTextWithAnsi } from "@oh-my-pi/pi-tui";
 import type { Theme } from "../modes/theme/theme";
 import { getSixelLineMask } from "../utils/sixel";
@@ -19,6 +20,19 @@ export interface OutputBlockOptions {
 	animate?: boolean;
 }
 
+const FRAMED_BLOCK_COMPONENT = Symbol("framedBlockComponent");
+
+export type FramedBlockComponent = Component & { [FRAMED_BLOCK_COMPONENT]?: true };
+
+export function markFramedBlockComponent<T extends Component>(component: T): T & FramedBlockComponent {
+	(component as T & FramedBlockComponent)[FRAMED_BLOCK_COMPONENT] = true;
+	return component as T & FramedBlockComponent;
+}
+
+export function isFramedBlockComponent(component: Component): boolean {
+	return (component as FramedBlockComponent)[FRAMED_BLOCK_COMPONENT] === true;
+}
+
 const BORDER_SHIMMER_TICK_MS = 16;
 /** Duration of one full left↔right↔left bounce of the bottom-edge segment, in
  * ms. Position is derived from the wall clock against this fixed cycle so a

package/src/web/search/index.ts

@@ -278,8 +278,8 @@ export const webSearchCustomTool: CustomTool<typeof webSearchSchema, SearchRende
 		return renderSearchCall(args, options, theme);
 	},
 
-	renderResult(result, options: RenderResultOptions, theme: Theme) {
-		return renderSearchResult(result, options, theme);
+	renderResult(result, options: RenderResultOptions, theme: Theme, args) {
+		return renderSearchResult(result, options, theme, args);
 	},
 };
 

package/src/web/search/render.ts

@@ -5,9 +5,9 @@
  */
 
 import type { Component } from "@oh-my-pi/pi-tui";
-import { Text, visibleWidth, wrapTextWithAnsi } from "@oh-my-pi/pi-tui";
+import { Markdown, Text } from "@oh-my-pi/pi-tui";
 import type { RenderResultOptions } from "../../extensibility/custom-tools/types";
-import type { Theme } from "../../modes/theme/theme";
+import { getMarkdownTheme, type Theme } from "../../modes/theme/theme";
 import {
 	formatAge,
 	formatCount,
@@ -21,13 +21,11 @@ import {
 	truncateToWidth,
 } from "../../tools/render-utils";
 import { renderStatusLine, renderTreeList } from "../../tui";
-import { CachedOutputBlock } from "../../tui/output-block";
+import { CachedOutputBlock, markFramedBlockComponent } from "../../tui/output-block";
 import { getSearchProviderLabel } from "./provider";
 import type { SearchResponse } from "./types";
 
 const MAX_COLLAPSED_ANSWER_LINES = PREVIEW_LIMITS.COLLAPSED_LINES;
-const MAX_EXPANDED_ANSWER_LINES = PREVIEW_LIMITS.EXPANDED_LINES;
-const MAX_ANSWER_LINE_LEN = TRUNCATE_LENGTHS.LINE;
 const MAX_SNIPPET_LINES = 2;
 const MAX_SNIPPET_LINE_LEN = TRUNCATE_LENGTHS.LINE;
 const MAX_COLLAPSED_ITEMS = PREVIEW_LIMITS.COLLAPSED_ITEMS;
@@ -75,7 +73,6 @@ export function renderSearchResult(
 	theme: Theme,
 	args?: {
 		query?: string;
-		allowLongAnswer?: boolean;
 		maxAnswerLines?: number;
 	},
 ): Component {
@@ -104,13 +101,6 @@ export function renderSearchResult(
 	// Get answer text
 	const answerText = typeof response.answer === "string" ? response.answer.trim() : "";
 	const contentText = answerText || rawText;
-	const answerLines = contentText
-		? contentText
-				.split("\n")
-				.filter(l => l.trim())
-				.map(l => l.trim())
-		: [];
-	const totalAnswerLines = answerLines.length;
 
 	const providerLabel = provider !== "none" ? getSearchProviderLabel(provider) : "None";
 	const queryPreview = args?.query
@@ -159,21 +149,30 @@ export function renderSearchResult(
 		metaLines.push(`${theme.fg("muted", "Queries:")} ${theme.fg("text", queryList.join("; "))}${suffix}`);
 	}
 
+	const answerMarkdown = contentText ? new Markdown(contentText, 0, 0, getMarkdownTheme()) : undefined;
 	const outputBlock = new CachedOutputBlock();
 
-	return {
+	return markFramedBlockComponent({
 		render(width: number): string[] {
 			// Read mutable state at render time
 			const { expanded } = options;
 
-			// Expanded-dependent computations
-			const answerLimit = expanded ? MAX_EXPANDED_ANSWER_LINES : MAX_COLLAPSED_ANSWER_LINES;
-			const answerPreview = contentText
-				? args?.allowLongAnswer
-					? answerLines.slice(0, args.maxAnswerLines ?? answerLines.length)
-					: getPreviewLines(contentText, answerLimit, MAX_ANSWER_LINE_LEN)
-				: [];
-			const remainingAnswer = totalAnswerLines - answerPreview.length;
+			// Answer lines: full markdown when expanded, capped markdown preview when collapsed.
+			const answerWidth = Math.max(20, width - 3);
+			const renderedAnswer = answerMarkdown ? answerMarkdown.render(answerWidth) : [];
+			let answerLines: string[];
+			if (renderedAnswer.length === 0) {
+				answerLines = [theme.fg("muted", "No answer text returned")];
+			} else if (expanded) {
+				answerLines = renderedAnswer;
+			} else {
+				const collapsedCap = args?.maxAnswerLines ?? MAX_COLLAPSED_ANSWER_LINES;
+				answerLines = renderedAnswer.slice(0, collapsedCap);
+				const remaining = renderedAnswer.length - answerLines.length;
+				if (remaining > 0) {
+					answerLines.push(theme.fg("muted", formatMoreItems(remaining, "line")));
+				}
+			}
 
 			const sourceTree = renderTreeList(
 				{
@@ -217,37 +216,6 @@ export function renderSearchResult(
 				theme,
 			);
 
-			// Build answer section
-			const answerState = sourceCount > 0 ? "success" : "warning";
-			const borderColor: "warning" | "dim" = answerState === "warning" ? "warning" : "dim";
-			const border = (t: string) => theme.fg(borderColor, t);
-			const contentPrefix = border(`${theme.boxSharp.vertical} `);
-			const contentSuffix = border(theme.boxSharp.vertical);
-			const contentWidth = Math.max(0, width - visibleWidth(contentPrefix) - visibleWidth(contentSuffix));
-			const answerTreeLines = answerPreview.length > 0 ? answerPreview : ["No answer text returned"];
-			const answerTree = renderTreeList(
-				{
-					items: answerTreeLines,
-					expanded: true,
-					maxCollapsed: answerTreeLines.length,
-					itemType: "line",
-					renderItem: (line, context) => {
-						const coloredLine =
-							line === "No answer text returned" ? theme.fg("muted", line) : theme.fg("dim", line);
-						if (!args?.allowLongAnswer) {
-							return coloredLine;
-						}
-						const prefixWidth = visibleWidth(context.continuePrefix);
-						const wrapWidth = Math.max(10, contentWidth - prefixWidth);
-						return wrapTextWithAnsi(coloredLine, wrapWidth);
-					},
-				},
-				theme,
-			);
-			if (remainingAnswer > 0) {
-				answerTree.push(theme.fg("muted", formatMoreItems(remainingAnswer, "line")));
-			}
-
 			return outputBlock.render(
 				{
 					header,
@@ -262,7 +230,7 @@ export function renderSearchResult(
 							: []),
 						{
 							label: theme.fg("toolTitle", "Answer"),
-							lines: answerTree,
+							lines: answerLines,
 						},
 						{
 							label: theme.fg("toolTitle", "Sources"),
@@ -278,7 +246,7 @@ export function renderSearchResult(
 		invalidate() {
 			outputBlock.invalidate();
 		},
-	};
+	});
 }
 
 /** Render web search call (query preview) */

package/dist/types/eval/heartbeat.d.ts

@@ -1,45 +0,0 @@
-/**
- * Keepalive for in-flight host-side eval bridge calls.
- *
- * The eval watchdog ({@link ../tools/eval IdleTimeout}) caps a cell's `timeout`
- * as a wall-clock budget on the cell's *own* work, but pauses that budget while
- * a host-side `agent()`/`parallel()` (via `runSubprocess`) or `llm()` (a single
- * completion) call is in flight. Those calls are the only thing that re-arms the
- * watchdog — and they can run for long stretches with **no** status of their own
- * (a subagent's time-to-first-token on a reasoning model, a long quiet nested
- * tool, or the entire body of a oneshot `llm()` call). Without a keepalive the
- * watchdog would mistake that delegated work for the cell stalling and abort it
- * mid-flight, killing the subagent.
- *
- * {@link withBridgeHeartbeat} bridges that gap by emitting a synthetic
- * {@link EVAL_HEARTBEAT_OP} status event immediately when the call begins and
- * then on a fixed cadence until it settles. The event rides the same
- * `emitStatus → onStatus` channel both runtimes already forward, so it re-arms
- * the watchdog without any new plumbing. The heartbeat is the *sole* signal that
- * extends the budget: consumers MUST treat it as a pure keepalive — bump the
- * watchdog and drop it (never persist or render it) — see the executor display
- * sinks and the eval tool's `onStatus` handler. Every other status event
- * (compute helpers, `log()`/`phase()`, tool results) counts against the budget.
- */
-import type { JsStatusEvent } from "./js/shared/types";
-/**
- * Synthetic status op emitted purely to keep the eval idle watchdog alive while
- * a host-side bridge call is in flight. Carries no payload.
- */
-export declare const EVAL_HEARTBEAT_OP = "heartbeat";
-/**
- * Test seam: override the heartbeat cadence so integration tests can exercise
- * the keepalive within a sub-second idle budget. Pass no value to restore the
- * production default.
- */
-export declare function setBridgeHeartbeatIntervalMs(ms?: number): void;
-/**
- * Run {@link operation}, pumping {@link EVAL_HEARTBEAT_OP} status events through
- * {@link emitStatus} — one immediately, then on a fixed cadence — until it
- * settles. The immediate beat pauses the watchdog the instant the call begins,
- * so a bridge call that starts close to the budget edge (after the cell already
- * spent most of it computing) is not aborted before the first interval tick. A
- * no-op wrapper when no `emitStatus` sink is wired (the heartbeat would reach
- * nobody).
- */
-export declare function withBridgeHeartbeat<T>(emitStatus: ((event: JsStatusEvent) => void) | undefined, operation: () => Promise<T>): Promise<T>;