@oh-my-pi/pi-coding-agent 15.3.1 → 15.4.1

package/src/task/render.ts

@@ -639,7 +639,8 @@ function renderAgentProgress(
 			}
 		}
 
-		for (const [toolName, dataArray] of Object.entries(progress.extractedToolData)) {
+		for (const toolName in progress.extractedToolData) {
+			const dataArray = progress.extractedToolData[toolName];
 			// Handle report_finding with tree formatting
 			if (toolName === "report_finding") {
 				const findings = normalizeReportFindings(dataArray);
@@ -649,6 +650,11 @@ function renderAgentProgress(
 				continue;
 			}
 
+			// Nested `task` data has its own dedicated tree renderer below that
+			// also merges in the in-flight snapshot — skip the generic inline
+			// path so we don't render twice.
+			if (toolName === "task") continue;
+
 			const handler = subprocessToolRegistry.getHandler(toolName);
 			if (handler?.renderInline) {
 				const displayCount = expanded ? (dataArray as unknown[]).length : 3;
@@ -671,6 +677,20 @@ function renderAgentProgress(
 		}
 	}
 
+	// Nested `task` tree: completed sub-calls from `extractedToolData.task` plus
+	// the in-flight snapshot (if any). Surfacing this in the live view means
+	// the user sees deep-tree progress without waiting for this agent to finish
+	// its own turn.
+	const completedTaskCalls = (progress.extractedToolData?.task as TaskToolDetails[] | undefined) ?? [];
+	const inflight = progress.inflightTaskDetails;
+	if (completedTaskCalls.length > 0 || inflight) {
+		const snapshots = inflight ? [...completedTaskCalls, inflight] : completedTaskCalls;
+		const nestedLines = renderNestedTaskTree(snapshots, expanded, theme, spinnerFrame);
+		for (const line of nestedLines) {
+			lines.push(`${continuePrefix}${line}`);
+		}
+	}
+
 	// Expanded view: recent output and tools
 	if (expanded && progress.status === "running") {
 		const output = progress.recentOutput.join("\n");
@@ -1067,6 +1087,38 @@ function renderNestedTaskResults(detailsList: TaskToolDetails[], expanded: boole
 	return lines;
 }
 
+/**
+ * Render a list of `TaskToolDetails` snapshots — completed (`results[]`) or
+ * in-flight (`progress[]`) — as an interleaved tree. Used by the live progress
+ * view to surface nested subagent activity while this agent is still running.
+ */
+function renderNestedTaskTree(
+	detailsList: TaskToolDetails[],
+	expanded: boolean,
+	theme: Theme,
+	spinnerFrame?: number,
+): string[] {
+	const lines: string[] = [];
+	for (const details of detailsList) {
+		const hasResults = Boolean(details.results && details.results.length > 0);
+		if (hasResults) {
+			details.results.forEach((result, index) => {
+				const isLast = index === details.results.length - 1;
+				lines.push(...renderAgentResult(result, isLast, expanded, theme));
+			});
+			continue;
+		}
+		const inflight = details.progress;
+		if (inflight && inflight.length > 0) {
+			inflight.forEach((prog, index) => {
+				const isLast = index === inflight.length - 1;
+				lines.push(...renderAgentProgress(prog, isLast, expanded, theme, spinnerFrame));
+			});
+		}
+	}
+	return lines;
+}
+
 subprocessToolRegistry.register<TaskToolDetails>("task", {
 	extractData: event => {
 		const details = event.result?.details;

package/src/task/types.ts

@@ -236,6 +236,14 @@ export interface AgentProgress {
 		attempt: number;
 		errorMessage: string;
 	};
+	/**
+	 * Snapshot of the most recent `task` tool call's in-flight `TaskToolDetails`,
+	 * captured from `tool_execution_update`. Lets the parent UI surface live
+	 * nested-subagent progress while this agent is still inside its own `task`
+	 * call. Cleared when the call ends — finalized data lives in
+	 * `extractedToolData.task` after that.
+	 */
+	inflightTaskDetails?: TaskToolDetails;
 }
 
 /** Result from a single agent execution */

package/src/tool-discovery/tool-index.ts

@@ -44,47 +44,6 @@ export interface DiscoverableToolSearchResult {
 	score: number;
 }
 
-// ─── Legacy MCP-typed aliases (back-compat) ──────────────────────────────────
-
-/** @deprecated Use DiscoverableTool with source === "mcp" */
-export type DiscoverableMCPTool = Pick<
-	DiscoverableTool,
-	"name" | "label" | "schemaKeys" | "serverName" | "mcpToolName"
-> & { description: string };
-
-/** @deprecated Use DiscoverableToolServerSummary */
-export type DiscoverableMCPToolServerSummary = DiscoverableToolServerSummary;
-
-/** @deprecated Use DiscoverableToolSummary */
-export type DiscoverableMCPToolSummary = DiscoverableToolSummary;
-
-/** Tool object stored on legacy MCP index documents. Carries both legacy `description` and the
- *  generic `summary`/`source` so the legacy index is structurally assignable to
- *  DiscoverableToolSearchIndex (search functions read termFrequencies, not the tool fields). */
-export type DiscoverableMCPSearchTool = DiscoverableTool & { description: string };
-
-/** @deprecated Use DiscoverableToolSearchDocument */
-export interface DiscoverableMCPSearchDocument {
-	tool: DiscoverableMCPSearchTool;
-	termFrequencies: Map<string, number>;
-	length: number;
-}
-
-/** @deprecated Use DiscoverableToolSearchIndex.
- *  Documents on this index expose `tool.description` (legacy MCP shape) while still being
- *  searchable via `searchDiscoverableTools`. */
-export interface DiscoverableMCPSearchIndex {
-	documents: DiscoverableMCPSearchDocument[];
-	averageLength: number;
-	documentFrequencies: Map<string, number>;
-}
-
-/** @deprecated Use DiscoverableToolSearchResult */
-export interface DiscoverableMCPSearchResult {
-	tool: DiscoverableMCPSearchTool;
-	score: number;
-}
-
 // ─── BM25 Constants ───────────────────────────────────────────────────────────
 
 const BM25_K1 = 1.2;
@@ -295,96 +254,3 @@ export function searchDiscoverableTools(
 		.sort((left, right) => right.score - left.score || left.tool.name.localeCompare(right.tool.name))
 		.slice(0, limit);
 }
-
-// ─── Legacy MCP-specific shims (back-compat wrappers) ────────────────────────
-
-/** @deprecated Use getDiscoverableTool */
-export function getDiscoverableMCPTool(tool: AgentTool): DiscoverableMCPTool | null {
-	if (!isMCPToolName(tool.name)) return null;
-	const toolRecord = tool as AgentTool & {
-		label?: string;
-		description?: string;
-		mcpServerName?: string;
-		mcpToolName?: string;
-		parameters?: unknown;
-	};
-	return {
-		name: tool.name,
-		label: typeof toolRecord.label === "string" ? toolRecord.label : tool.name,
-		description: typeof toolRecord.description === "string" ? toolRecord.description : "",
-		serverName: typeof toolRecord.mcpServerName === "string" ? toolRecord.mcpServerName : undefined,
-		mcpToolName: typeof toolRecord.mcpToolName === "string" ? toolRecord.mcpToolName : undefined,
-		schemaKeys: getSchemaPropertyKeys(toolRecord.parameters),
-	};
-}
-
-/** @deprecated Use collectDiscoverableTools with source filter */
-export function collectDiscoverableMCPTools(tools: Iterable<AgentTool>): DiscoverableMCPTool[] {
-	const discoverable: DiscoverableMCPTool[] = [];
-	for (const tool of tools) {
-		const metadata = getDiscoverableMCPTool(tool);
-		if (metadata) {
-			discoverable.push(metadata);
-		}
-	}
-	return discoverable;
-}
-
-/** @deprecated Use selectDiscoverableToolNamesByServer */
-export function selectDiscoverableMCPToolNamesByServer(
-	tools: Iterable<DiscoverableMCPTool>,
-	serverNames: ReadonlySet<string>,
-): string[] {
-	if (serverNames.size === 0) return [];
-	return Array.from(tools)
-		.filter(tool => tool.serverName !== undefined && serverNames.has(tool.serverName))
-		.map(tool => tool.name);
-}
-
-/** @deprecated Use summarizeDiscoverableTools */
-export function summarizeDiscoverableMCPTools(tools: DiscoverableMCPTool[]): DiscoverableMCPToolSummary {
-	const serverToolCounts = new Map<string, number>();
-	for (const tool of tools) {
-		if (!tool.serverName) continue;
-		serverToolCounts.set(tool.serverName, (serverToolCounts.get(tool.serverName) ?? 0) + 1);
-	}
-	const servers = Array.from(serverToolCounts.entries())
-		.sort(([left], [right]) => left.localeCompare(right))
-		.map(([name, toolCount]) => ({ name, toolCount }));
-	return {
-		servers,
-		toolCount: tools.length,
-	};
-}
-
-/** @deprecated Use buildDiscoverableToolSearchIndex.
- *  Builds an index whose documents preserve the legacy `description` field on each tool while
- *  also carrying the generic `summary` (set from `description`) so the index remains usable
- *  with `searchDiscoverableTools`. */
-export function buildDiscoverableMCPSearchIndex(tools: Iterable<DiscoverableMCPTool>): DiscoverableMCPSearchIndex {
-	const adapted: DiscoverableMCPSearchTool[] = Array.from(tools).map(t => ({
-		name: t.name,
-		label: t.label,
-		description: t.description,
-		summary: t.description,
-		source: "mcp" as DiscoverableToolSource,
-		serverName: t.serverName,
-		mcpToolName: t.mcpToolName,
-		schemaKeys: t.schemaKeys,
-	}));
-	const generic = buildDiscoverableToolSearchIndex(adapted);
-	// Documents reference `adapted` tools (with `description`), so the cast is sound.
-	return generic as unknown as DiscoverableMCPSearchIndex;
-}
-
-/** @deprecated Use searchDiscoverableTools */
-export function searchDiscoverableMCPTools(
-	index: DiscoverableMCPSearchIndex | DiscoverableToolSearchIndex,
-	query: string,
-	limit: number,
-): DiscoverableMCPSearchResult[] {
-	return searchDiscoverableTools(index as DiscoverableToolSearchIndex, query, limit) as DiscoverableMCPSearchResult[];
-}
-
-/** @deprecated Use formatDiscoverableToolServerSummary */
-export const formatDiscoverableMCPToolServerSummary = formatDiscoverableToolServerSummary;

package/src/tools/ast-edit.ts

@@ -6,7 +6,7 @@ import { Text } from "@oh-my-pi/pi-tui";
 import { $envpos, prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import { computeLineHash, HL_BODY_SEP } from "../hashline/hash";
+import { computeFileHash, formatHashlineHeader } from "../hashline/hash";
 import type { Theme } from "../modes/theme/theme";
 import astEditDescription from "../prompts/tools/ast-edit.md" with { type: "text" };
 import { Ellipsis, fileHyperlink, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
@@ -257,12 +257,26 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 			}
 
 			const useHashLines = resolveFileDisplayMode(this.session).hashLines;
+			const hashContexts = new Map<string, { fileHash: string }>();
+			if (useHashLines) {
+				for (const relativePath of fileList) {
+					const absolutePath = path.resolve(this.session.cwd, relativePath);
+					try {
+						const fullText = await Bun.file(absolutePath).text();
+						const fileHash = computeFileHash(fullText);
+						hashContexts.set(relativePath, { fileHash });
+					} catch {
+						// Best-effort: if a file disappears between ast-edit and rendering, emit plain line output.
+					}
+				}
+			}
 			const outputLines: string[] = [];
 			const displayLines: string[] = [];
 			const renderChangesForFile = (relativePath: string): { model: string[]; display: string[] } => {
 				const modelOut: string[] = [];
 				const displayOut: string[] = [];
 				const fileChanges = changesByFile.get(relativePath) ?? [];
+				const hashContext = hashContexts.get(relativePath);
 				const lineNumberWidth = fileChanges.reduce(
 					(width, change) => Math.max(width, String(change.startLine).length),
 					0,
@@ -272,13 +286,9 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 					const afterFirstLine = change.after.split("\n", 1)[0] ?? "";
 					const beforeLine = beforeFirstLine.slice(0, 120);
 					const afterLine = afterFirstLine.slice(0, 120);
-					const beforeRef = useHashLines
-						? `${change.startLine}${computeLineHash(change.startLine, beforeFirstLine)}`
-						: `${change.startLine}:${change.startColumn}`;
-					const afterRef = useHashLines
-						? `${change.startLine}${computeLineHash(change.startLine, afterFirstLine)}`
-						: `${change.startLine}:${change.startColumn}`;
-					const lineSeparator = useHashLines ? HL_BODY_SEP : " ";
+					const beforeRef = hashContext ? `${change.startLine}` : `${change.startLine}:${change.startColumn}`;
+					const afterRef = hashContext ? `${change.startLine}` : `${change.startLine}:${change.startColumn}`;
+					const lineSeparator = hashContext ? ":" : " ";
 					modelOut.push(`-${beforeRef}${lineSeparator}${beforeLine}`);
 					modelOut.push(`+${afterRef}${lineSeparator}${afterLine}`);
 					displayOut.push(formatCodeFrameLine("-", change.startLine, beforeLine, lineNumberWidth));
@@ -291,10 +301,13 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 				const grouped = formatGroupedFiles(fileList, relativePath => {
 					const rendered = renderChangesForFile(relativePath);
 					const count = fileReplacementCounts.get(relativePath) ?? 0;
+					const hashContext = hashContexts.get(relativePath);
+					const hashSuffix = hashContext ? `#${hashContext.fileHash}` : "";
 					return {
-						headerSuffix: ` (${formatCount("replacement", count)})`,
+						headerSuffix: `${hashSuffix} (${formatCount("replacement", count)})`,
 						modelLines: rendered.model,
 						displayLines: rendered.display,
+						skip: rendered.model.length === 0,
 					};
 				});
 				outputLines.push(...grouped.model);
@@ -302,6 +315,15 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 			} else {
 				for (const relativePath of fileList) {
 					const rendered = renderChangesForFile(relativePath);
+					if (rendered.model.length === 0) continue;
+					if (outputLines.length > 0) {
+						outputLines.push("");
+						displayLines.push("");
+					}
+					const hashContext = hashContexts.get(relativePath);
+					if (hashContext) {
+						outputLines.push(formatHashlineHeader(relativePath, hashContext.fileHash));
+					}
 					outputLines.push(...rendered.model);
 					displayLines.push(...rendered.display);
 				}
@@ -499,11 +521,12 @@ export const astEditToolRenderer = {
 							let contextDir = searchBase ?? "";
 							return group.map(line => {
 								if (line.startsWith("## ")) {
-									// Strip ` (3 replacements)` suffix attached by formatGroupedFiles.
+									// Strip ` (3 replacements)` and `#hash` suffixes from formatGroupedFiles.
 									const fileName = line
 										.slice(3)
 										.trimEnd()
-										.replace(/\s+\([^)]*\)\s*$/, "");
+										.replace(/\s+\([^)]*\)\s*$/, "")
+										.replace(/#[0-9a-f]+$/, "");
 									const absPath = contextDir && fileName ? path.join(contextDir, fileName) : undefined;
 									const styled = uiTheme.fg("dim", line);
 									return absPath ? fileHyperlink(absPath, styled) : styled;
@@ -514,14 +537,14 @@ export const astEditToolRenderer = {
 										.trimEnd()
 										.replace(/\s+\([^)]*\)\s*$/, "");
 									const isDirectory = raw.endsWith("/");
-									const name = raw.replace(/\/$/, "");
+									const name = isDirectory ? raw.replace(/\/$/, "") : raw.replace(/#[0-9a-f]+$/, "");
 									if (isDirectory) {
 										if (searchBase) {
 											contextDir = name === "." ? searchBase : path.join(searchBase, name);
 										}
 										return uiTheme.fg("accent", line);
 									}
-									// Root-level file with optional suffix, e.g. `# foo.ts (3 replacements)`.
+									// Root-level file with optional `#hash` and ` (3 replacements)` suffixes.
 									const absPath = searchBase && name ? path.join(searchBase, name) : undefined;
 									const styled = uiTheme.fg("accent", line);
 									return absPath ? fileHyperlink(absPath, styled) : styled;

package/src/tools/ast-grep.ts

@@ -5,7 +5,9 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
+import { getFileReadCache } from "../edit/file-read-cache";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import { computeFileHash, formatHashlineHeader } from "../hashline/hash";
 import type { Theme } from "../modes/theme/theme";
 import astGrepDescription from "../prompts/tools/ast-grep.md" with { type: "text" };
 import { Ellipsis, fileHyperlink, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
@@ -216,25 +218,43 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 			}
 
 			const useHashLines = resolveFileDisplayMode(this.session).hashLines;
+			const hashContexts = new Map<string, { absolutePath: string; fileHash: string }>();
+			if (useHashLines) {
+				for (const relativePath of fileList) {
+					const absolutePath = path.resolve(this.session.cwd, relativePath);
+					try {
+						const fullText = await Bun.file(absolutePath).text();
+						const fileHash = computeFileHash(fullText);
+						hashContexts.set(relativePath, { absolutePath, fileHash });
+					} catch {
+						// Best-effort: if a file disappears between ast-grep and rendering, emit plain line output.
+					}
+				}
+			}
 			const outputLines: string[] = [];
 			const displayLines: string[] = [];
 			const renderMatchesForFile = (relativePath: string): { model: string[]; display: string[] } => {
 				const modelOut: string[] = [];
 				const displayOut: string[] = [];
 				const fileMatches = matchesByFile.get(relativePath) ?? [];
+				const hashContext = hashContexts.get(relativePath);
 				const lineNumberWidth = fileMatches.reduce((width, match) => {
 					const lineCount = match.text.split("\n").length;
 					const endLine = match.startLine + lineCount - 1;
 					return Math.max(width, String(match.startLine).length, String(endLine).length);
 				}, 0);
+				const cacheEntries: Array<readonly [number, string]> = [];
 				for (const match of fileMatches) {
 					const matchLines = match.text.split("\n");
 					for (let index = 0; index < matchLines.length; index++) {
 						const lineNumber = match.startLine + index;
 						const isMatch = index === 0;
 						const line = matchLines[index] ?? "";
-						modelOut.push(formatMatchLine(lineNumber, line, isMatch, { useHashLines }));
+						modelOut.push(
+							formatMatchLine(lineNumber, line, isMatch, { useHashLines: hashContext !== undefined }),
+						);
 						displayOut.push(formatCodeFrameLine(isMatch ? "*" : " ", lineNumber, line, lineNumberWidth));
+						cacheEntries.push([lineNumber, line] as const);
 					}
 					if (match.metaVariables && Object.keys(match.metaVariables).length > 0) {
 						const serializedMeta = Object.entries(match.metaVariables)
@@ -246,19 +266,39 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 					}
 					fileMatchCounts.set(relativePath, (fileMatchCounts.get(relativePath) ?? 0) + 1);
 				}
+				if (hashContext && cacheEntries.length > 0) {
+					getFileReadCache(this.session).recordSparse(hashContext.absolutePath, cacheEntries, {
+						fileHash: hashContext.fileHash,
+					});
+				}
 				return { model: modelOut, display: displayOut };
 			};
 
 			if (isDirectory) {
 				const grouped = formatGroupedFiles(fileList, relativePath => {
 					const rendered = renderMatchesForFile(relativePath);
-					return { modelLines: rendered.model, displayLines: rendered.display };
+					const hashContext = hashContexts.get(relativePath);
+					return {
+						modelLines: rendered.model,
+						displayLines: rendered.display,
+						headerSuffix: hashContext ? `#${hashContext.fileHash}` : "",
+						skip: rendered.model.length === 0,
+					};
 				});
 				outputLines.push(...grouped.model);
 				displayLines.push(...grouped.display);
 			} else {
 				for (const relativePath of fileList) {
 					const rendered = renderMatchesForFile(relativePath);
+					if (rendered.model.length === 0) continue;
+					if (outputLines.length > 0) {
+						outputLines.push("");
+						displayLines.push("");
+					}
+					const hashContext = hashContexts.get(relativePath);
+					if (hashContext) {
+						outputLines.push(formatHashlineHeader(relativePath, hashContext.fileHash));
+					}
 					outputLines.push(...rendered.model);
 					displayLines.push(...rendered.display);
 				}
@@ -385,7 +425,8 @@ export const astGrepToolRenderer = {
 									const fileName = line
 										.slice(3)
 										.trimEnd()
-										.replace(/\s+\([^)]*\)\s*$/, "");
+										.replace(/\s+\([^)]*\)\s*$/, "")
+										.replace(/#[0-9a-f]+$/, "");
 									const absPath = contextDir && fileName ? path.join(contextDir, fileName) : undefined;
 									const styled = uiTheme.fg("dim", line);
 									return absPath ? fileHyperlink(absPath, styled) : styled;
@@ -396,7 +437,7 @@ export const astGrepToolRenderer = {
 										.trimEnd()
 										.replace(/\s+\([^)]*\)\s*$/, "");
 									const isDirectory = raw.endsWith("/");
-									const name = raw.replace(/\/$/, "");
+									const name = isDirectory ? raw.replace(/\/$/, "") : raw.replace(/#[0-9a-f]+$/, "");
 									if (isDirectory) {
 										if (searchBase) {
 											contextDir = name === "." ? searchBase : path.join(searchBase, name);

package/src/tools/browser/tab-worker.ts

@@ -575,8 +575,10 @@ export class WorkerCore {
 			if (signal.aborted) onCancel();
 			else signal.addEventListener("abort", onCancel, { once: true });
 			try {
+				const hooks = this.#hooksForActiveRun();
+				if (!hooks) throw new ToolError("Browser runtime started without an active run");
 				const returnValue = await Promise.race([
-					runtime.run(msg.code, `browser-run-${msg.id}.js`),
+					runtime.run(msg.code, `browser-run-${msg.id}.js`, hooks, { runId: msg.id, cwd: msg.session.cwd }),
 					cancelRejection,
 				]);
 				await this.#postReadyInfo();
@@ -601,7 +603,6 @@ export class WorkerCore {
 		this.#runtime = new JsRuntime({
 			initialCwd: session.cwd,
 			sessionId: `browser-tab-${this.#targetId ?? "unknown"}`,
-			getHooks: () => this.#hooksForActiveRun(),
 		});
 		return this.#runtime;
 	}

package/src/tools/eval.ts

@@ -6,6 +6,7 @@ import { prompt } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
 import { jsBackend, pythonBackend } from "../eval";
 import type { ExecutorBackend } from "../eval/backend";
+import { defaultEvalSessionId } from "../eval/session-id";
 import type { EvalCellResult, EvalDisplayOutput, EvalLanguage, EvalStatusEvent, EvalToolDetails } from "../eval/types";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { truncateToVisualLines } from "../modes/components/visual-truncate";
@@ -347,7 +348,7 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 						pushUpdate();
 					},
 				});
-				const sessionId = sessionFile ? `session:${sessionFile}:cwd:${session.cwd}` : `cwd:${session.cwd}`;
+				const sessionId = session.getEvalSessionId?.() ?? defaultEvalSessionId(session);
 
 				for (let i = 0; i < cells.length; i++) {
 					const cell = cells[i];

package/src/tools/fetch.ts

@@ -10,6 +10,7 @@ import type { Settings } from "../config/settings";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 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";
@@ -542,7 +543,8 @@ async function renderHtmlToText(
 	html: string,
 	timeout: number,
 	settings: Settings,
-	userSignal?: AbortSignal,
+	userSignal: AbortSignal | undefined,
+	storage: AgentStorage | null,
 ): Promise<{ content: string; ok: boolean; method: string }> {
 	const signal = ptree.combineSignals(userSignal, timeout * 1000);
 	const execOptions = {
@@ -554,14 +556,18 @@ async function renderHtmlToText(
 	};
 
 	// Try Parallel extract first when credentials are configured
-	if (settings.get("providers.parallelFetch") && (await findParallelApiKey())) {
+	if (settings.get("providers.parallelFetch") && findParallelApiKey(storage)) {
 		try {
-			const parallelResult = await extractWithParallel([url], {
-				objective: "Extract the main content",
-				excerpts: true,
-				fullContent: false,
-				signal,
-			});
+			const parallelResult = await extractWithParallel(
+				[url],
+				{
+					objective: "Extract the main content",
+					excerpts: true,
+					fullContent: false,
+					signal,
+				},
+				storage,
+			);
 			const firstDocument = parallelResult.results[0];
 			if (firstDocument) {
 				const content = getParallelExtractContent(firstDocument);
@@ -682,13 +688,14 @@ type FetchRenderResult = RenderResult & {
 async function handleSpecialUrls(
 	url: string,
 	timeout: number,
-	signal?: AbortSignal,
+	signal: AbortSignal | undefined,
+	storage: AgentStorage | null,
 ): Promise<FetchRenderResult | null> {
 	for (const handler of specialHandlers) {
 		if (signal?.aborted) {
 			throw new ToolAbortError();
 		}
-		const result = await handler(url, timeout, signal);
+		const result = await handler(url, timeout, signal, storage);
 		if (result) return result;
 	}
 	return null;
@@ -706,7 +713,8 @@ async function renderUrl(
 	timeout: number,
 	raw: boolean,
 	settings: Settings,
-	signal?: AbortSignal,
+	signal: AbortSignal | undefined,
+	storage: AgentStorage | null,
 ): Promise<FetchRenderResult> {
 	const notes: string[] = [];
 	const fetchedAt = new Date().toISOString();
@@ -733,7 +741,7 @@ async function renderUrl(
 
 	// Step 1: Try special handlers for known sites (unless raw mode)
 	if (!raw) {
-		const specialResult = await handleSpecialUrls(url, timeout, signal);
+		const specialResult = await handleSpecialUrls(url, timeout, signal, storage);
 		if (specialResult) return specialResult;
 	}
 
@@ -1051,7 +1059,7 @@ async function renderUrl(
 		}
 
 		// 5E: Render HTML with lynx or html2text
-		const htmlResult = await renderHtmlToText(finalUrl, rawContent, timeout, settings, signal);
+		const htmlResult = await renderHtmlToText(finalUrl, rawContent, timeout, settings, signal, storage);
 		if (!htmlResult.ok) {
 			notes.push("html rendering failed (lynx/html2text unavailable)");
 			const output = finalizeOutput(rawContent);
@@ -1233,7 +1241,8 @@ async function buildReadUrlCacheEntry(
 		throw new ToolAbortError();
 	}
 
-	const result = await renderUrl(url, effectiveTimeout, raw, session.settings, signal);
+	const storage = session.settings.getStorage();
+	const result = await renderUrl(url, effectiveTimeout, raw, session.settings, signal, storage);
 	const output = buildUrlReadOutput(result, result.content);
 	const artifactId = options?.ensureArtifact ? await persistReadUrlArtifact(session, output) : undefined;
 

package/src/tools/index.ts

@@ -91,7 +91,6 @@ export * from "./search";
 export * from "./search-tool-bm25";
 export * from "./ssh";
 export * from "./todo-write";
-export * from "./vim";
 export * from "./write";
 export * from "./yield";
 
@@ -104,7 +103,6 @@ export type ContextFileEntry = {
 	depth?: number;
 };
 
-export type { DiscoverableMCPTool } from "../mcp/discoverable-tool-metadata";
 export type {
 	DiscoverableTool,
 	DiscoverableToolSearchIndex,
@@ -140,6 +138,8 @@ export interface ToolSession {
 	requireYieldTool?: boolean;
 	/** Task recursion depth (0 = top-level, 1 = first child, etc.) */
 	taskDepth?: number;
+	/** Get shared eval executor session ID. Subagents inherit this to share JS/Python state. */
+	getEvalSessionId?: () => string | null;
 	/** Get session file */
 	getSessionFile: () => string | null;
 	/** Get eval kernel owner ID for session-scoped retained-kernel cleanup. */
@@ -194,12 +194,6 @@ export interface ToolSession {
 	setTodoPhases?: (phases: TodoPhase[]) => void;
 	/** Whether MCP tool discovery is active for this session. */
 	isMCPDiscoveryEnabled?: () => boolean;
-	/** Get hidden-but-discoverable MCP tools for search_tool_bm25 prompts and fallbacks.
-	 * @deprecated Use getDiscoverableTools with source filter instead. */
-	getDiscoverableMCPTools?: () => import("../mcp/discoverable-tool-metadata").DiscoverableMCPTool[];
-	/** Get the cached discoverable MCP search index for search_tool_bm25 execution.
-	 * @deprecated Use getDiscoverableToolSearchIndex instead. */
-	getDiscoverableMCPSearchIndex?: () => import("../tool-discovery/tool-index").DiscoverableMCPSearchIndex;
 	/** Get MCP tools activated by prior search_tool_bm25 calls. */
 	getSelectedMCPToolNames?: () => string[];
 	/** Merge MCP tool selections into the active session tool set. */