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

package/src/tools/eval.ts

@@ -4,7 +4,7 @@ import { prompt } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
 import { jsBackend, pythonBackend } from "../eval";
 import type { ExecutorBackend, ExecutorBackendResult } from "../eval/backend";
-import { EVAL_HEARTBEAT_OP } from "../eval/heartbeat";
+import { EVAL_TIMEOUT_PAUSE_OP, EVAL_TIMEOUT_RESUME_OP } from "../eval/bridge-timeout";
 import { IdleTimeout } from "../eval/idle-timeout";
 import { defaultEvalSessionId } from "../eval/session-id";
 import type { EvalCellResult, EvalDisplayOutput, EvalLanguage, EvalStatusEvent, EvalToolDetails } from "../eval/types";
@@ -313,16 +313,13 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 				for (let i = 0; i < cells.length; i++) {
 					const cell = cells[i];
 					const backend = cell.resolved.backend;
-					// The per-cell `timeout` is a wall-clock budget on the cell's *own*
-					// work, but it is paused while a host-side `agent()`/`llm()` bridge
-					// call is in flight: those calls pump a heartbeat (see
-					// `withBridgeHeartbeat`) that re-arms the watchdog, so a long fanout
-					// or a slow completion runs to completion. Nothing else re-arms it —
-					// compute, stdout, `log()`/`phase()`, and ordinary tool calls all
-					// count against the budget — so a cell that is not delegating to an
-					// agent/llm is bounded by a plain wall-clock timeout. The watchdog
-					// drives `combinedSignal`; we pass no wall-clock deadline downstream
-					// so the backends never arm a competing fixed timer.
+					// The per-cell `timeout` is a budget on the cell runtime's *own*
+					// work. Host-side `agent()`/`parallel()`/`llm()` bridge calls suspend
+					// that budget entirely and restart a fresh timeout window when control
+					// returns to Python/JS. Compute, stdout, `log()`/`phase()`, and
+					// ordinary tool calls all count against the budget. The watchdog drives
+					// `combinedSignal`; we pass no wall-clock deadline downstream so the
+					// backends never arm a competing fixed timer.
 					const idleTimeoutMs = timeoutSecondsFromMs(cell.timeoutMs) * 1000;
 					const idle = new IdleTimeout(idleTimeoutMs);
 					const combinedSignal = signal
@@ -355,14 +352,12 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 								outputSink!.push(chunk);
 							},
 							onStatus: event => {
-								// Only a bridge heartbeat re-arms the watchdog: it is the
-								// keepalive `agent()`/`llm()` pump while a host-side call is
-								// in flight, so those calls effectively pause the budget. It
-								// carries no payload — bump and drop it. Every other event
-								// (compute helpers, log()/phase(), tool results) renders but
-								// counts against the plain wall-clock budget.
-								if (event.op === EVAL_HEARTBEAT_OP) {
-									idle.bump();
+								if (event.op === EVAL_TIMEOUT_PAUSE_OP) {
+									idle.pause();
+									return;
+								}
+								if (event.op === EVAL_TIMEOUT_RESUME_OP) {
+									idle.resume();
 									return;
 								}
 								cellResult.statusEvents ??= [];

package/src/tools/fetch.ts

@@ -13,8 +13,8 @@ import { type Theme, theme } from "../modes/theme/theme";
 import type { ToolSession } from "../sdk";
 import type { AgentStorage } from "../session/agent-storage";
 import { DEFAULT_MAX_BYTES, truncateHead } from "../session/streaming-output";
-import { renderStatusLine } from "../tui";
-import { CachedOutputBlock } from "../tui/output-block";
+import { renderStatusLine, urlHyperlink } from "../tui";
+import { CachedOutputBlock, markFramedBlockComponent } from "../tui/output-block";
 import { formatDimensionNote, resizeImage } from "../utils/image-resize";
 import { ensureTool } from "../utils/tools-manager";
 import { extractWithParallel, findParallelApiKey, getParallelExtractContent } from "../web/parallel";
@@ -1437,6 +1437,27 @@ function countNonEmptyLines(text: string): number {
 	return text.split("\n").filter(l => l.trim()).length;
 }
 
+function readUrlLinkTarget(input: string): string {
+	try {
+		return parseReadUrlTarget(input)?.path ?? input;
+	} catch {
+		return input;
+	}
+}
+
+function formatReadUrlDescription(input: string): string {
+	const target = readUrlLinkTarget(input);
+	const displayUrl = target.match(/^www\./i) ? `https://${target}` : target;
+	const domain = getDomain(displayUrl);
+	const urlPath = truncate(displayUrl.replace(/^https?:\/\/[^/]+/, ""), 50, "…");
+	const label = `${domain}${urlPath ? ` ${urlPath}` : ""}`.trim();
+	return urlHyperlink(target, label);
+}
+
+function formatReadUrlMetadataValue(url: string, uiTheme: Theme): string {
+	return urlHyperlink(url, uiTheme.fg("mdLinkUrl", url));
+}
+
 /** Render URL read call (URL preview) */
 export function renderReadUrlCall(
 	args: { path?: string; url?: string; raw?: boolean },
@@ -1444,9 +1465,7 @@ export function renderReadUrlCall(
 	uiTheme: Theme = theme,
 ): Component {
 	const url = args.path ?? args.url ?? "";
-	const domain = getDomain(url);
-	const path = truncate(url.replace(/^https?:\/\/[^/]+/, ""), 50, "…");
-	const description = `${domain}${path ? ` ${path}` : ""}`.trim();
+	const description = formatReadUrlDescription(url);
 	const meta: string[] = [];
 	if (args.raw) meta.push("raw");
 	const text = renderStatusLine({ icon: "pending", title: "Read", description, meta }, uiTheme);
@@ -1465,19 +1484,18 @@ export function renderReadUrlResult(
 		const rawErrorText = result.content?.find(c => c.type === "text")?.text ?? "";
 		const errorText = (rawErrorText || "No response data").replace(/^Error:\s*/, "");
 		const urlText = details?.finalUrl ?? details?.url ?? "";
-		const description = urlText ? `${getDomain(urlText)}${urlText.replace(/^https?:\/\/[^/]+/, "")}` : undefined;
+		const description = urlText ? formatReadUrlDescription(urlText) : undefined;
 		const header = renderStatusLine({ icon: "error", title: "Read", description }, uiTheme);
 		const errorLines = errorText.split("\n").map(line => uiTheme.fg("error", replaceTabs(line)));
 		const outputBlock = new CachedOutputBlock();
-		return {
+		return markFramedBlockComponent({
 			render: (width: number) =>
 				outputBlock.render({ header, state: "error", sections: [{ lines: errorLines }], width }, uiTheme),
 			invalidate: () => outputBlock.invalidate(),
-		};
+		});
 	}
 
-	const domain = getDomain(details.finalUrl);
-	const path = truncate(details.finalUrl.replace(/^https?:\/\/[^/]+/, ""), 50, "…");
+	const description = formatReadUrlDescription(details.finalUrl);
 	const hasRedirect = details.url !== details.finalUrl;
 	const hasNotes = details.notes.length > 0;
 	const truncation = details.meta?.truncation;
@@ -1487,7 +1505,7 @@ export function renderReadUrlResult(
 		{
 			icon: truncated ? "warning" : "success",
 			title: "Read",
-			description: `${domain}${path ? ` ${path}` : ""}`,
+			description,
 		},
 		uiTheme,
 	);
@@ -1505,7 +1523,9 @@ export function renderReadUrlResult(
 		`${uiTheme.fg("muted", "Method:")} ${details.method}`,
 	];
 	if (hasRedirect) {
-		metadataLines.push(`${uiTheme.fg("muted", "Final URL:")} ${uiTheme.fg("mdLinkUrl", details.finalUrl)}`);
+		metadataLines.push(
+			`${uiTheme.fg("muted", "Final URL:")} ${formatReadUrlMetadataValue(details.finalUrl, uiTheme)}`,
+		);
 	}
 	const lineLabel = `${lineCount} line${lineCount === 1 ? "" : "s"}`;
 	metadataLines.push(`${uiTheme.fg("muted", "Lines:")} ${lineLabel}`);
@@ -1522,7 +1542,7 @@ export function renderReadUrlResult(
 	let lastExpanded: boolean | undefined;
 	let contentPreviewLines: string[] | undefined;
 
-	return {
+	return markFramedBlockComponent({
 		render: (width: number) => {
 			const { expanded } = options;
 
@@ -1562,5 +1582,5 @@ export function renderReadUrlResult(
 			contentPreviewLines = undefined;
 			lastExpanded = undefined;
 		},
-	};
+	});
 }

package/src/tools/gh.ts

@@ -792,6 +792,18 @@ function repoFromRepositoryUrl(value: string | undefined): string | undefined {
 	return value.slice(REPO_API_URL_PREFIX.length);
 }
 
+function githubRepoSlugEquals(left: string | undefined, right: string): boolean {
+	if (left === undefined || left.length !== right.length) return false;
+	for (let idx = 0; idx < left.length; idx += 1) {
+		let leftCode = left.charCodeAt(idx);
+		let rightCode = right.charCodeAt(idx);
+		if (leftCode >= 65 && leftCode <= 90) leftCode += 32;
+		if (rightCode >= 65 && rightCode <= 90) rightCode += 32;
+		if (leftCode !== rightCode) return false;
+	}
+	return true;
+}
+
 function apiUserToGhUser(user: GhApiUser | null | undefined): GhUser | undefined {
 	if (!user) return undefined;
 	const login = user.login ?? undefined;
@@ -1646,7 +1658,7 @@ async function resolveGitHubRepo(
 	runRepo: string | undefined,
 	signal?: AbortSignal,
 ): Promise<string> {
-	if (repo && runRepo && repo !== runRepo) {
+	if (repo && runRepo && !githubRepoSlugEquals(repo, runRepo)) {
 		throw new ToolError("run URL repository does not match the provided repo");
 	}
 
@@ -1712,6 +1724,33 @@ export async function resolveDefaultRepoMemoized(cwd: string, signal?: AbortSign
 	return untilAborted(signal, pending);
 }
 
+/**
+ * Best-effort cached cwd → `owner/repo` resolution that swallows any failure
+ * (not a git checkout, no GitHub remote, `gh` unauthenticated, …) into
+ * `undefined`. Use where the cwd repo is a convenience fallback, not a safety
+ * check.
+ */
+async function tryResolveCurrentRepo(cwd: string, signal: AbortSignal | undefined): Promise<string | undefined> {
+	try {
+		return await resolveDefaultRepoMemoized(cwd, signal);
+	} catch {
+		return undefined;
+	}
+}
+
+/**
+ * Best-effort fresh cwd → `owner/repo` resolution for safety checks that must
+ * reflect the repository currently mounted at `cwd`, not the process-lifetime
+ * default-repo cache.
+ */
+async function tryResolveCurrentRepoFresh(cwd: string, signal: AbortSignal | undefined): Promise<string | undefined> {
+	try {
+		return await resolveGitHubRepo(cwd, undefined, undefined, signal);
+	} catch {
+		return undefined;
+	}
+}
+
 /**
  * Matches search-query qualifiers that already scope to a repository, org, or
  * user. When present, callers should avoid layering a default `repo:<current>`
@@ -1738,11 +1777,7 @@ async function resolveSearchRepoScope(
 ): Promise<string | undefined> {
 	if (repo) return repo;
 	if (query && REPO_SCOPE_QUALIFIER_PATTERN.test(query)) return undefined;
-	try {
-		return await resolveDefaultRepoMemoized(cwd, signal);
-	} catch {
-		return undefined;
-	}
+	return tryResolveCurrentRepo(cwd, signal);
 }
 
 async function resolveGitHubBranchHead(
@@ -3338,8 +3373,9 @@ async function executeRunWatch(
 	onUpdate: AgentToolUpdateCallback<GhToolDetails> | undefined,
 ): Promise<AgentToolResult<GhToolDetails>> {
 	const branchInput = normalizeOptionalString(params.branch);
+	const explicitRepo = normalizeOptionalString(params.repo);
 	const runReference = parseRunReference(params.run);
-	const repo = await resolveGitHubRepo(session.cwd, undefined, runReference.repo, signal);
+	const repo = await resolveGitHubRepo(session.cwd, explicitRepo, runReference.repo, signal);
 	const intervalSeconds = RUN_WATCH_INTERVAL_DEFAULT;
 	const graceSeconds = RUN_WATCH_GRACE_DEFAULT;
 	const tail = resolveTailLimit(params.tail);
@@ -3419,10 +3455,28 @@ async function executeRunWatch(
 		}
 	}
 
-	const branch = branchInput ?? (await requireCurrentGitBranch(session.cwd, signal));
-	const headSha = branchInput
-		? await resolveGitHubBranchHead(session.cwd, repo, branch, signal)
-		: await requireCurrentGitHead(session.cwd, signal);
+	let branch: string;
+	let headSha: string;
+	if (branchInput) {
+		branch = branchInput;
+		headSha = await resolveGitHubBranchHead(session.cwd, repo, branch, signal);
+	} else {
+		// No branch/run selector — derive the commit from the current checkout,
+		// but only when cwd actually points at `repo`. Otherwise we'd watch an
+		// unrelated commit SHA against the explicit repo and silently stream a
+		// confident wrong-repo status (issue #1949). GitHub `owner/repo` slugs
+		// are case-insensitive — `gh repo view` returns the canonical casing
+		// while callers may pass any casing — so the equality check normalizes
+		// both sides before deciding the cwd is a different repo (PR #1951).
+		const cwdRepo = await tryResolveCurrentRepoFresh(session.cwd, signal);
+		if (!githubRepoSlugEquals(cwdRepo, repo)) {
+			throw new ToolError(
+				`Cannot infer the watched commit for ${repo}: current checkout is ${cwdRepo ?? "not a GitHub repository"}. Pass \`branch\` or \`run\` to scope the watch.`,
+			);
+		}
+		branch = await requireCurrentGitBranch(session.cwd, signal);
+		headSha = await requireCurrentGitHead(session.cwd, signal);
+	}
 	let pollCount = 0;
 	let settledSuccessSignature: string | undefined;
 

package/src/tools/index.ts

@@ -23,6 +23,7 @@ import type { CustomMessage } from "../session/messages";
 import type { ToolChoiceQueue } from "../session/tool-choice-queue";
 import { TaskTool } from "../task";
 import type { AgentOutputManager } from "../task/output-manager";
+import { countToolsForAutoDiscovery, resolveEffectiveToolDiscoveryMode } from "../tool-discovery/mode";
 import type { DiscoverableTool, DiscoverableToolSearchIndex } from "../tool-discovery/tool-index";
 import type { EventBus } from "../utils/event-bus";
 import { WebSearchTool } from "../web/search";
@@ -420,14 +421,11 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		}
 	}
 	// Resolve effective tool discovery mode.
-	// tools.discoveryMode takes precedence; mcp.discoveryMode is a back-compat alias for "mcp-only".
-	const toolsDiscoveryMode = session.settings.get("tools.discoveryMode");
-	const effectiveDiscoveryMode: "off" | "mcp-only" | "all" =
-		toolsDiscoveryMode !== "off"
-			? (toolsDiscoveryMode as "off" | "mcp-only" | "all")
-			: session.settings.get("mcp.discoveryMode")
-				? "mcp-only"
-				: "off";
+	// tools.discoveryMode controls the new modes; mcp.discoveryMode remains a back-compat alias for "mcp-only".
+	const effectiveDiscoveryMode = resolveEffectiveToolDiscoveryMode(
+		session.settings,
+		countToolsForAutoDiscovery(requestedTools ?? Object.keys(BUILTIN_TOOLS)),
+	);
 	const discoveryActive = effectiveDiscoveryMode !== "off";
 
 	const allTools: Record<string, ToolFactory> = { ...BUILTIN_TOOLS, ...HIDDEN_TOOLS };

package/src/tools/read.ts

@@ -29,7 +29,7 @@ import {
 	truncateLine,
 } from "../session/streaming-output";
 import { fileHyperlink, renderCodeCell, renderMarkdownCell, renderStatusLine, tryResolveInternalUrlSync } from "../tui";
-import { CachedOutputBlock } from "../tui/output-block";
+import { CachedOutputBlock, markFramedBlockComponent } from "../tui/output-block";
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
 import { ImageInputTooLargeError, loadImageInput, MAX_IMAGE_INPUT_BYTES } from "../utils/image-loading";
 import { convertFileWithMarkit } from "../utils/markit";
@@ -2316,6 +2316,49 @@ interface ReadRenderArgs {
 	raw?: boolean;
 }
 
+const INTERNAL_URL_LIKE_RE = /^[a-z][a-z0-9+.-]*:\/\//i;
+
+function splitReadRenderPath(rawPath: string): { path: string; sel?: string } {
+	if (INTERNAL_URL_LIKE_RE.test(rawPath)) {
+		const internal = splitInternalUrlSel(rawPath);
+		if (internal.sel) return internal;
+	}
+	return splitPathAndSel(rawPath);
+}
+
+function firstReadSelectorLine(sel: string | undefined): number | undefined {
+	if (!sel) return undefined;
+	try {
+		const parsed = parseSel(sel);
+		if (parsed.kind !== "lines") return undefined;
+		return parsed.ranges[0].startLine;
+	} catch {
+		return undefined;
+	}
+}
+
+function formatReadPathLink(
+	rawPath: string,
+	options: {
+		resolvedPath?: string;
+		suffixResolution?: { from: string; to: string };
+		offset?: number;
+		fallbackLabel?: string;
+	},
+): string {
+	const split = splitReadRenderPath(rawPath);
+	const basePath = split.path || rawPath;
+	const selectorSuffix = split.sel ? `:${split.sel}` : "";
+	const plainDisplayPath = options.suffixResolution
+		? shortenPath(options.suffixResolution.to)
+		: shortenPath(basePath || options.resolvedPath || options.fallbackLabel || rawPath);
+	const target = options.resolvedPath ?? tryResolveInternalUrlSync(basePath);
+	const line = firstReadSelectorLine(split.sel) ?? options.offset;
+	const linkOptions = line !== undefined ? { line } : undefined;
+	const displayPath = target ? fileHyperlink(target, plainDisplayPath, linkOptions) : plainDisplayPath;
+	return `${displayPath}${selectorSuffix}`;
+}
+
 export const readToolRenderer = {
 	renderCall(args: ReadRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
 		if (isReadableUrlPath(args.file_path || args.path || "")) {
@@ -2323,13 +2366,10 @@ export const readToolRenderer = {
 		}
 
 		const rawPath = args.file_path || args.path || "";
-		const shortPath = shortenPath(rawPath);
-		const linkTarget = tryResolveInternalUrlSync(rawPath);
-		const filePath = linkTarget ? fileHyperlink(linkTarget, shortPath) : shortPath;
 		const offset = args.offset;
 		const limit = args.limit;
 
-		let pathDisplay = filePath || "…";
+		let pathDisplay = formatReadPathLink(rawPath, { offset, fallbackLabel: "…" }) || "…";
 		if (offset !== undefined || limit !== undefined) {
 			const startLine = offset ?? 1;
 			const endLine = limit !== undefined ? startLine + limit - 1 : "";
@@ -2363,7 +2403,7 @@ export const readToolRenderer = {
 			const rawErrorText = result.content?.find(c => c.type === "text")?.text ?? "";
 			const errorText = (rawErrorText || "Unknown error").replace(/^Error:\s*/, "");
 			const rawPath = args?.file_path || args?.path || "";
-			const filePath = shortenPath(rawPath);
+			const filePath = formatReadPathLink(rawPath, { offset: args?.offset }) || shortenPath(rawPath);
 			let title = filePath ? `Read ${filePath}` : "Read";
 			if (args?.offset !== undefined || args?.limit !== undefined) {
 				const startLine = args.offset ?? 1;
@@ -2373,11 +2413,11 @@ export const readToolRenderer = {
 			const header = renderStatusLine({ icon: "error", title }, uiTheme);
 			const errorLines = errorText.split("\n").map(line => uiTheme.fg("error", replaceTabs(line)));
 			const outputBlock = new CachedOutputBlock();
-			return {
+			return markFramedBlockComponent({
 				render: (width: number) =>
 					outputBlock.render({ header, state: "error", sections: [{ lines: errorLines }], width }, uiTheme),
 				invalidate: () => outputBlock.invalidate(),
-			};
+			});
 		}
 		const details = result.details;
 		const rawText = result.content?.find(c => c.type === "text")?.text ?? "";
@@ -2388,8 +2428,8 @@ export const readToolRenderer = {
 		const contentText = details?.displayContent?.text ?? stripOutputNotice(rawText, details?.meta);
 		const imageContent = result.content?.find(c => c.type === "image");
 		const rawPath = args?.file_path || args?.path || "";
-		const filePath = shortenPath(rawPath);
-		const lang = getLanguageFromPath(splitPathAndSel(rawPath).path);
+		const renderPath = splitReadRenderPath(rawPath);
+		const lang = getLanguageFromPath(renderPath.path);
 
 		const warningLines: string[] = [];
 		const truncation = details?.meta?.truncation;
@@ -2412,7 +2452,11 @@ export const readToolRenderer = {
 
 		if (imageContent) {
 			const suffix = details?.suffixResolution;
-			const displayPath = suffix ? shortenPath(suffix.to) : filePath || rawPath || "image";
+			const displayPath = formatReadPathLink(rawPath, {
+				resolvedPath: details?.resolvedPath,
+				suffixResolution: suffix,
+				fallbackLabel: "image",
+			});
 			const correction = suffix ? ` ${uiTheme.fg("dim", `(corrected from ${shortenPath(suffix.from)})`)}` : "";
 			const header = renderStatusLine(
 				{ icon: suffix ? "warning" : "success", title: "Read", description: `${displayPath}${correction}` },
@@ -2421,7 +2465,7 @@ export const readToolRenderer = {
 			const detailLines = contentText ? contentText.split("\n").map(line => uiTheme.fg("toolOutput", line)) : [];
 			const lines = [...detailLines, ...warningLines];
 			const outputBlock = new CachedOutputBlock();
-			return {
+			return markFramedBlockComponent({
 				render: (width: number) =>
 					outputBlock.render(
 						{
@@ -2438,17 +2482,19 @@ export const readToolRenderer = {
 						uiTheme,
 					),
 				invalidate: () => outputBlock.invalidate(),
-			};
+			});
 		}
 
 		const suffix = details?.suffixResolution;
-		const plainDisplayPath = suffix ? shortenPath(suffix.to) : filePath;
 		// resolvedPath is the absolute fs path for fs-backed reads (regular files plus
 		// local:// / memory:// / skill:// / artifact:// resources). Fall back to a sync
 		// resolver for fs-backed internal URLs so the title is clickable even before the
 		// result lands or if the handler didn't populate resolvedPath.
-		const absForLink = details?.resolvedPath ?? tryResolveInternalUrlSync(rawPath);
-		const displayPath = absForLink ? fileHyperlink(absForLink, plainDisplayPath) : plainDisplayPath;
+		const displayPath = formatReadPathLink(rawPath, {
+			resolvedPath: details?.resolvedPath,
+			suffixResolution: suffix,
+			offset: args?.offset,
+		});
 		const correction = suffix ? ` ${uiTheme.fg("dim", `(corrected from ${shortenPath(suffix.from)})`)}` : "";
 		let title = displayPath ? `Read ${displayPath}${correction}` : "Read";
 		if (args?.offset !== undefined || args?.limit !== undefined) {
@@ -2463,12 +2509,12 @@ export const readToolRenderer = {
 			const n = details.conflictCount;
 			title += ` ${uiTheme.fg("warning", `(⚠ ${n} conflict${n === 1 ? "" : "s"})`)}`;
 		}
-		const rawRequested = args?.raw === true || isRawSelector(parseSel(splitPathAndSel(rawPath).sel));
+		const rawRequested = args?.raw === true || isRawSelector(parseSel(renderPath.sel));
 		const isMarkdown = details?.contentType === "text/markdown" && !rawRequested;
 		let cachedWidth: number | undefined;
 		let cachedExpanded: boolean | undefined;
 		let cachedLines: string[] | undefined;
-		return {
+		return markFramedBlockComponent({
 			render: (width: number) => {
 				const expanded = options.expanded;
 				if (cachedLines && cachedWidth === width && cachedExpanded === expanded) return cachedLines;
@@ -2505,7 +2551,7 @@ export const readToolRenderer = {
 				cachedExpanded = undefined;
 				cachedLines = undefined;
 			},
-		};
+		});
 	},
 	mergeCallAndResult: true,
 };

package/src/tools/render-utils.ts

@@ -171,6 +171,52 @@ export function formatMoreItems(remaining: number, itemType: string): string {
 	return `… ${safeRemaining} more ${pluralize(itemType, safeRemaining)}`;
 }
 
+/**
+ * Maximum rows a tool's streaming/pending *call* preview may render before it is
+ * capped. This is intentionally conservative: the preview still sits inside a
+ * transcript that already consumed some viewport rows, and tool blocks carry
+ * extra chrome (status/header/border/"more lines"), so a "reasonable" raw code
+ * or command preview like 10-12 lines can still overflow and strand its top
+ * while the block is volatile. Keeping the live call window short avoids that
+ * across terminals without turning the transcript into an interactive scroller.
+ */
+export const CALL_PREVIEW_MAX_LINES = 6;
+
+/**
+ * Cap a pre-rendered pending/call preview to a bounded window. When truncated,
+ * show both the head and the live tail so the user can still see what the tool
+ * is currently writing while the volatile block stays short enough not to strand
+ * its top above the viewport. `Ctrl+O` widens the bounded window, but does not
+ * fully uncap live tool previews for the same reason.
+ *
+ * `prefix` (raw, e.g. a dim tree gutter) is prepended to the summary line so
+ * nested previews stay aligned.
+ */
+export function capPreviewLines(
+	lines: string[],
+	theme: Theme,
+	options: { max?: number; expanded?: boolean; prefix?: string } = {},
+): string[] {
+	const max = options.max ?? (options.expanded ? PREVIEW_LIMITS.EXPANDED_LINES : CALL_PREVIEW_MAX_LINES);
+	if (lines.length <= max) return lines;
+	if (max <= 1) {
+		const hint = formatExpandHint(theme, options.expanded, true);
+		const moreLine = `${formatMoreItems(lines.length, "line")}${hint ? ` ${hint}` : ""}`;
+		return [`${options.prefix ?? ""}${theme.fg("dim", moreLine)}`];
+	}
+	const bodyBudget = max - 1; // reserve one summary row
+	const headCount = Math.max(1, Math.ceil(bodyBudget / 2));
+	const tailCount = Math.max(1, bodyBudget - headCount);
+	const hidden = Math.max(0, lines.length - headCount - tailCount);
+	const hint = formatExpandHint(theme, options.expanded, true);
+	const moreLine = `${formatMoreItems(hidden, "line")}${hint ? ` ${hint}` : ""}`;
+	return [
+		...lines.slice(0, headCount),
+		`${options.prefix ?? ""}${theme.fg("dim", moreLine)}`,
+		...lines.slice(lines.length - tailCount),
+	];
+}
+
 export function formatMeta(meta: string[], theme: Theme): string {
 	return meta.length > 0 ? ` ${theme.fg("muted", meta.join(theme.sep.dot))}` : "";
 }

package/src/tools/search-tool-bm25.ts

@@ -6,6 +6,7 @@ import * as z from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import searchToolBm25Description from "../prompts/tools/search-tool-bm25.md" with { type: "text" };
+import { resolveEffectiveToolDiscoveryMode } from "../tool-discovery/mode";
 import {
 	buildDiscoverableToolSearchIndex,
 	type DiscoverableTool,
@@ -198,12 +199,9 @@ export class SearchToolBm25Tool implements AgentTool<typeof searchToolBm25Schema
 	constructor(private readonly session: ToolSession) {}
 
 	static createIf(session: ToolSession): SearchToolBm25Tool | null {
-		// Active when new tools.discoveryMode is non-"off" or legacy mcp.discoveryMode is true
-		const toolsDiscoveryMode = session.settings.get("tools.discoveryMode");
-		const active =
-			(toolsDiscoveryMode !== undefined && toolsDiscoveryMode !== "off") ||
-			session.settings.get("mcp.discoveryMode") === true;
-		if (!active) return null;
+		// Direct createTools() calls do not know the final MCP/extension catalog yet, so
+		// auto mode is activated later by createAgentSession after the full registry exists.
+		if (resolveEffectiveToolDiscoveryMode(session.settings, 0) === "off") return null;
 		return supportsToolDiscoveryExecution(session) ? new SearchToolBm25Tool(session) : null;
 	}