@oh-my-pi/pi-coding-agent 13.13.2 → 13.14.0

package/src/mcp/tool-bridge.ts

@@ -5,6 +5,7 @@
  */
 import type { AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { sanitizeSchemaForMCP } from "@oh-my-pi/pi-ai/utils/schema";
+import { untilAborted } from "@oh-my-pi/pi-utils";
 import type { TSchema } from "@sinclair/typebox";
 import type { SourceMeta } from "../capability/types";
 import type {
@@ -17,22 +18,43 @@ import type { Theme } from "../modes/theme/theme";
 import { ToolAbortError, throwIfAborted } from "../tools/tool-errors";
 import { callTool } from "./client";
 import { renderMCPCall, renderMCPResult } from "./render";
-import type { MCPContent, MCPServerConnection, MCPToolDefinition } from "./types";
+import type { MCPContent, MCPServerConnection, MCPToolCallParams, MCPToolCallResult, MCPToolDefinition } from "./types";
 
-function withAbort<T>(promise: Promise<T>, signal?: AbortSignal): Promise<T> {
-	if (!signal) return promise;
-	if (signal.aborted) {
-		return Promise.reject(signal.reason instanceof Error ? signal.reason : new ToolAbortError());
-	}
+/** Reconnect callback: tears down stale connection, returns new one or null. */
+export type MCPReconnect = () => Promise<MCPServerConnection | null>;
 
-	const { promise: wrapped, resolve, reject } = Promise.withResolvers<T>();
-	const onAbort = () => {
-		reject(signal.reason instanceof Error ? signal.reason : new ToolAbortError());
-	};
+/**
+ * Network-level and stale-session errors that warrant a reconnect + single retry.
+ * Conservative: only catches errors where the server is likely alive but the
+ * connection object is stale (dead SSE, expired session, refused after restart).
+ */
+const RETRIABLE_PATTERNS = [
+	"econnrefused",
+	"econnreset",
+	"epipe",
+	"enetunreach",
+	"ehostunreach",
+	"fetch failed",
+	"transport not connected",
+	"transport closed",
+	"network error",
+];
+
+export function isRetriableConnectionError(error: unknown): boolean {
+	if (!(error instanceof Error)) return false;
+	const msg = error.message.toLowerCase();
+	// Stale session (server restarted, old session ID is gone)
+	if (/^http (404|502|503):/.test(msg)) return true;
+	return RETRIABLE_PATTERNS.some(p => msg.includes(p));
+}
 
-	signal.addEventListener("abort", onAbort, { once: true });
-	promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
-	return wrapped;
+type MCPToolArgs = NonNullable<MCPToolCallParams["arguments"]>;
+
+function normalizeToolArgs(value: unknown): MCPToolArgs {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) {
+		return {};
+	}
+	return value as MCPToolArgs;
 }
 
 /** Details included in MCP tool results for rendering */
@@ -77,6 +99,60 @@ function formatMCPContent(content: MCPContent[]): string {
 	return parts.join("\n\n");
 }
 
+/** Build a CustomToolResult from a callTool response. */
+function buildResult(
+	result: MCPToolCallResult,
+	serverName: string,
+	mcpToolName: string,
+	provider?: string,
+	providerName?: string,
+): CustomToolResult<MCPToolDetails> {
+	const text = formatMCPContent(result.content);
+	const details: MCPToolDetails = {
+		serverName,
+		mcpToolName,
+		isError: result.isError,
+		rawContent: result.content,
+		provider,
+		providerName,
+	};
+	if (result.isError) {
+		return { content: [{ type: "text", text: `Error: ${text}` }], details };
+	}
+	return { content: [{ type: "text", text }], details };
+}
+
+/** Build an error CustomToolResult from a caught exception. */
+function buildErrorResult(
+	error: unknown,
+	serverName: string,
+	mcpToolName: string,
+	provider?: string,
+	providerName?: string,
+): CustomToolResult<MCPToolDetails> {
+	const message = error instanceof Error ? error.message : String(error);
+	return {
+		content: [{ type: "text", text: `MCP error: ${message}` }],
+		details: { serverName, mcpToolName, isError: true, provider, providerName },
+	};
+}
+
+/** Re-throw abort-related errors so they bypass error-result handling. */
+function rethrowIfAborted(error: unknown, signal?: AbortSignal): void {
+	if (error instanceof ToolAbortError) throw error;
+	if (error instanceof Error && error.name === "AbortError") throw new ToolAbortError();
+	if (signal?.aborted) throw new ToolAbortError();
+}
+
+async function reconnectWithAbort(reconnect: MCPReconnect, signal?: AbortSignal): Promise<MCPServerConnection | null> {
+	try {
+		return await untilAborted(signal, reconnect);
+	} catch (error) {
+		rethrowIfAborted(error, signal);
+		return null;
+	}
+}
+
 /**
  * Create a unique tool name for an MCP tool.
  *
@@ -143,13 +219,14 @@ export class MCPTool implements CustomTool<TSchema, MCPToolDetails> {
 	readonly mcpServerName: string;
 
 	/** Create MCPTool instances for all tools from an MCP server connection */
-	static fromTools(connection: MCPServerConnection, tools: MCPToolDefinition[]): MCPTool[] {
-		return tools.map(tool => new MCPTool(connection, tool));
+	static fromTools(connection: MCPServerConnection, tools: MCPToolDefinition[], reconnect?: MCPReconnect): MCPTool[] {
+		return tools.map(tool => new MCPTool(connection, tool, reconnect));
 	}
 
 	constructor(
-		private readonly connection: MCPServerConnection,
+		private connection: MCPServerConnection,
 		private readonly tool: MCPToolDefinition,
+		private readonly reconnect?: MCPReconnect,
 	) {
 		this.name = createMCPToolName(connection.name, tool.name);
 		this.label = `${connection.name}/${tool.name}`;
@@ -160,11 +237,11 @@ export class MCPTool implements CustomTool<TSchema, MCPToolDetails> {
 	}
 
 	renderCall(args: unknown, _options: RenderResultOptions, theme: Theme) {
-		return renderMCPCall((args ?? {}) as Record<string, unknown>, theme, this.label);
+		return renderMCPCall(normalizeToolArgs(args), theme, this.label);
 	}
 
 	renderResult(result: CustomToolResult<MCPToolDetails>, options: RenderResultOptions, theme: Theme, args?: unknown) {
-		return renderMCPResult(result, options, theme, (args ?? {}) as Record<string, unknown>);
+		return renderMCPResult(result, options, theme, normalizeToolArgs(args));
 	}
 
 	async execute(
@@ -175,51 +252,38 @@ export class MCPTool implements CustomTool<TSchema, MCPToolDetails> {
 		signal?: AbortSignal,
 	): Promise<CustomToolResult<MCPToolDetails>> {
 		throwIfAborted(signal);
-		try {
-			const result = await callTool(this.connection, this.tool.name, params as Record<string, unknown>, { signal });
-
-			const text = formatMCPContent(result.content);
-			const details: MCPToolDetails = {
-				serverName: this.connection.name,
-				mcpToolName: this.tool.name,
-				isError: result.isError,
-				rawContent: result.content,
-				provider: this.connection._source?.provider,
-				providerName: this.connection._source?.providerName,
-			};
-
-			if (result.isError) {
-				return {
-					content: [{ type: "text", text: `Error: ${text}` }],
-					details,
-				};
-			}
+		const args = normalizeToolArgs(params);
+		const provider = this.connection._source?.provider;
+		const providerName = this.connection._source?.providerName;
 
-			return {
-				content: [{ type: "text", text }],
-				details,
-			};
+		try {
+			const result = await callTool(this.connection, this.tool.name, args, { signal });
+			return buildResult(result, this.connection.name, this.tool.name, provider, providerName);
 		} catch (error) {
-			if (error instanceof ToolAbortError) {
-				throw error;
-			}
-			if (error instanceof Error && error.name === "AbortError") {
-				throw new ToolAbortError();
-			}
-			if (signal?.aborted) {
-				throw new ToolAbortError();
+			rethrowIfAborted(error, signal);
+			if (this.reconnect && isRetriableConnectionError(error)) {
+				const newConn = await reconnectWithAbort(this.reconnect, signal);
+				if (newConn) {
+					// Rebind so subsequent calls on this instance use the fresh connection
+					this.connection = newConn;
+					const retryProvider = newConn._source?.provider ?? provider;
+					const retryProviderName = newConn._source?.providerName ?? providerName;
+					try {
+						const result = await callTool(newConn, this.tool.name, args, { signal });
+						return buildResult(result, newConn.name, this.tool.name, retryProvider, retryProviderName);
+					} catch (retryError) {
+						rethrowIfAborted(retryError, signal);
+						return buildErrorResult(
+							retryError,
+							this.connection.name,
+							this.tool.name,
+							retryProvider,
+							retryProviderName,
+						);
+					}
+				}
 			}
-			const message = error instanceof Error ? error.message : String(error);
-			return {
-				content: [{ type: "text", text: `MCP error: ${message}` }],
-				details: {
-					serverName: this.connection.name,
-					mcpToolName: this.tool.name,
-					isError: true,
-					provider: this.connection._source?.provider,
-					providerName: this.connection._source?.providerName,
-				},
-			};
+			return buildErrorResult(error, this.connection.name, this.tool.name, provider, providerName);
 		}
 	}
 }
@@ -245,8 +309,9 @@ export class DeferredMCPTool implements CustomTool<TSchema, MCPToolDetails> {
 		tools: MCPToolDefinition[],
 		getConnection: () => Promise<MCPServerConnection>,
 		source?: SourceMeta,
+		reconnect?: MCPReconnect,
 	): DeferredMCPTool[] {
-		return tools.map(tool => new DeferredMCPTool(serverName, tool, getConnection, source));
+		return tools.map(tool => new DeferredMCPTool(serverName, tool, getConnection, source, reconnect));
 	}
 
 	constructor(
@@ -254,6 +319,7 @@ export class DeferredMCPTool implements CustomTool<TSchema, MCPToolDetails> {
 		private readonly tool: MCPToolDefinition,
 		private readonly getConnection: () => Promise<MCPServerConnection>,
 		source?: SourceMeta,
+		private readonly reconnect?: MCPReconnect,
 	) {
 		this.name = createMCPToolName(serverName, tool.name);
 		this.label = `${serverName}/${tool.name}`;
@@ -266,11 +332,11 @@ export class DeferredMCPTool implements CustomTool<TSchema, MCPToolDetails> {
 	}
 
 	renderCall(args: unknown, _options: RenderResultOptions, theme: Theme) {
-		return renderMCPCall((args ?? {}) as Record<string, unknown>, theme, this.label);
+		return renderMCPCall(normalizeToolArgs(args), theme, this.label);
 	}
 
 	renderResult(result: CustomToolResult<MCPToolDetails>, options: RenderResultOptions, theme: Theme, args?: unknown) {
-		return renderMCPResult(result, options, theme, (args ?? {}) as Record<string, unknown>);
+		return renderMCPResult(result, options, theme, normalizeToolArgs(args));
 	}
 
 	async execute(
@@ -281,53 +347,70 @@ export class DeferredMCPTool implements CustomTool<TSchema, MCPToolDetails> {
 		signal?: AbortSignal,
 	): Promise<CustomToolResult<MCPToolDetails>> {
 		throwIfAborted(signal);
+		const args = normalizeToolArgs(params);
+		const provider = this.#fallbackProvider;
+		const providerName = this.#fallbackProviderName;
+
 		try {
-			const connection = await withAbort(this.getConnection(), signal);
+			const connection = await untilAborted(signal, () => this.getConnection());
 			throwIfAborted(signal);
-			const result = await callTool(connection, this.tool.name, params as Record<string, unknown>, { signal });
-
-			const text = formatMCPContent(result.content);
-			const details: MCPToolDetails = {
-				serverName: this.serverName,
-				mcpToolName: this.tool.name,
-				isError: result.isError,
-				rawContent: result.content,
-				provider: connection._source?.provider ?? this.#fallbackProvider,
-				providerName: connection._source?.providerName ?? this.#fallbackProviderName,
-			};
-
-			if (result.isError) {
-				return {
-					content: [{ type: "text", text: `Error: ${text}` }],
-					details,
-				};
-			}
-
-			return {
-				content: [{ type: "text", text }],
-				details,
-			};
-		} catch (error) {
-			if (error instanceof ToolAbortError) {
-				throw error;
-			}
-			if (error instanceof Error && error.name === "AbortError") {
-				throw new ToolAbortError();
+			try {
+				const result = await callTool(connection, this.tool.name, args, { signal });
+				return buildResult(
+					result,
+					this.serverName,
+					this.tool.name,
+					connection._source?.provider ?? provider,
+					connection._source?.providerName ?? providerName,
+				);
+			} catch (callError) {
+				rethrowIfAborted(callError, signal);
+				if (this.reconnect && isRetriableConnectionError(callError)) {
+					const newConn = await reconnectWithAbort(this.reconnect, signal);
+					if (newConn) {
+						const retryProvider = newConn._source?.provider ?? provider;
+						const retryProviderName = newConn._source?.providerName ?? providerName;
+						try {
+							const result = await callTool(newConn, this.tool.name, args, { signal });
+							return buildResult(result, this.serverName, this.tool.name, retryProvider, retryProviderName);
+						} catch (retryError) {
+							rethrowIfAborted(retryError, signal);
+							return buildErrorResult(
+								retryError,
+								this.serverName,
+								this.tool.name,
+								retryProvider,
+								retryProviderName,
+							);
+						}
+					}
+				}
+				return buildErrorResult(callError, this.serverName, this.tool.name, provider, providerName);
 			}
-			if (signal?.aborted) {
-				throw new ToolAbortError();
+		} catch (connError) {
+			// getConnection() failed — server never connected or connection lost.
+			// This is always worth a reconnect attempt for deferred tools, since the
+			// error ("MCP server not connected") isn't a network error from callTool.
+			rethrowIfAborted(connError, signal);
+			if (this.reconnect) {
+				const newConn = await reconnectWithAbort(this.reconnect, signal);
+				if (newConn) {
+					try {
+						const result = await callTool(newConn, this.tool.name, args, { signal });
+						return buildResult(
+							result,
+							this.serverName,
+							this.tool.name,
+							newConn._source?.provider ?? provider,
+							newConn._source?.providerName ?? providerName,
+						);
+					} catch (retryError) {
+						rethrowIfAborted(retryError, signal);
+						return buildErrorResult(retryError, this.serverName, this.tool.name, provider, providerName);
+					}
+				}
 			}
-			const message = error instanceof Error ? error.message : String(error);
-			return {
-				content: [{ type: "text", text: `MCP error: ${message}` }],
-				details: {
-					serverName: this.serverName,
-					mcpToolName: this.tool.name,
-					isError: true,
-					provider: this.#fallbackProvider,
-					providerName: this.#fallbackProviderName,
-				},
-			};
+			return buildErrorResult(connError, this.serverName, this.tool.name, provider, providerName);
 		}
 	}
 }

package/src/mcp/transports/http.ts

@@ -4,7 +4,7 @@
  * Implements JSON-RPC 2.0 over HTTP POST with optional SSE streaming.
  * Based on MCP spec 2025-03-26.
  */
-import { readSseJson, Snowflake } from "@oh-my-pi/pi-utils";
+import { logger, readSseJson, Snowflake } from "@oh-my-pi/pi-utils";
 import type {
 	JsonRpcError,
 	JsonRpcMessage,
@@ -91,13 +91,16 @@ export class HttpTransport implements MCPTransport {
 			return;
 		}
 
-		// Connection established — read messages in background, reset sseConnection when done
+		// Connection established — read messages in background.
+		// If the stream ends unexpectedly (server restart, network drop),
+		// fire onClose so the manager can trigger reconnection.
 		const signal = this.#sseConnection.signal;
 		void this.#readSSEStream(response.body!, signal).finally(() => {
+			const wasConnected = this.#connected;
 			this.#sseConnection = null;
+			if (wasConnected) this.onClose?.();
 		});
 	}
-
 	async #readSSEStream(body: ReadableStream<Uint8Array>, signal: AbortSignal): Promise<void> {
 		try {
 			for await (const message of readSseJson<JsonRpcMessage>(body, signal)) {
@@ -106,6 +109,7 @@ export class HttpTransport implements MCPTransport {
 			}
 		} catch (error) {
 			if (error instanceof Error && error.name !== "AbortError") {
+				logger.debug("HTTP SSE stream error", { url: this.config.url, error: error.message });
 				this.onError?.(error);
 			}
 		}
@@ -457,6 +461,7 @@ export class HttpTransport implements MCPTransport {
 		}
 
 		this.onClose?.();
+		this.onClose = undefined;
 	}
 }
 

package/src/modes/controllers/mcp-command-controller.ts

@@ -127,6 +127,9 @@ export class MCPCommandController {
 			case "smithery-logout":
 				await this.#handleSmitheryLogout();
 				break;
+			case "reconnect":
+				await this.#handleReconnect(parts[2]);
+				break;
 			case "reload":
 				await this.#handleReload();
 				break;
@@ -159,6 +162,7 @@ export class MCPCommandController {
 			"                        Search Smithery registry and deploy from picker",
 			"  /mcp smithery-login   Login to Smithery and cache API key",
 			"  /mcp smithery-logout  Remove cached Smithery API key",
+			"  /mcp reconnect <name> Reconnect to a specific MCP server",
 			"  /mcp reload           Force reload and rediscover MCP runtime tools",
 			"  /mcp resources        List available resources from connected servers",
 			"  /mcp prompts          List available prompts from connected servers",
@@ -1372,6 +1376,47 @@ export class MCPCommandController {
 		}
 	}
 
+	/**
+	 * Handle /mcp reconnect <name> - Reconnect to a specific server.
+	 */
+	async #handleReconnect(name: string | undefined): Promise<void> {
+		if (!name) {
+			this.ctx.showError("Server name required. Usage: /mcp reconnect <name>");
+			return;
+		}
+		if (!this.ctx.mcpManager) {
+			this.ctx.showError("MCP manager not available.");
+			return;
+		}
+
+		this.#showMessage(["", theme.fg("muted", `Reconnecting to "${name}"...`), ""].join("\n"));
+
+		try {
+			const connection = await this.ctx.mcpManager.reconnectServer(name);
+			if (connection) {
+				// refreshMCPTools re-registers tools and preserves the user's prior
+				// MCP tool selection. No need to call activateDiscoveredMCPTools —
+				// that would broaden the selection to all server tools.
+				await this.ctx.session.refreshMCPTools(this.ctx.mcpManager.getTools());
+				const serverTools = this.ctx.mcpManager.getTools().filter(t => t.mcpServerName === name);
+				this.#showMessage(
+					[
+						"\n",
+						theme.fg("success", `\u2713 Reconnected to "${name}"`),
+						`  Tools: ${serverTools.length}`,
+						"\n",
+					].join("\n"),
+				);
+			} else {
+				this.ctx.showError(`Failed to reconnect to "${name}". Check server status and logs.`);
+			}
+		} catch (error) {
+			this.ctx.showError(
+				`Failed to reconnect to "${name}": ${error instanceof Error ? error.message : String(error)}`,
+			);
+		}
+	}
+
 	/**
 	 * Reload MCP manager with new configs
 	 */

package/src/modes/interactive-mode.ts

@@ -6,7 +6,7 @@ import * as path from "node:path";
 import { type Agent, type AgentMessage, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { AssistantMessage, ImageContent, Message, Model, UsageReport } from "@oh-my-pi/pi-ai";
 import type { Component, SlashCommand } from "@oh-my-pi/pi-tui";
-import { Container, Loader, Markdown, ProcessTerminal, Spacer, Text, TUI } from "@oh-my-pi/pi-tui";
+import { Container, Loader, Markdown, ProcessTerminal, Spacer, Text, TUI, visibleWidth } from "@oh-my-pi/pi-tui";
 import { APP_NAME, getProjectDir, hsvToRgb, isEnoent, logger, postmortem } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
 import { KeybindingsManager } from "../config/keybindings";
@@ -1111,8 +1111,7 @@ export class InteractiveMode implements InteractiveModeContext {
 					this.#startMicAnimation();
 				} else if (state === "transcribing") {
 					this.#stopMicAnimation();
-					this.editor.cursorOverride = `\x1b[38;2;200;200;200m${theme.icon.mic}\x1b[0m`;
-					this.editor.cursorOverrideWidth = 1;
+					this.#setMicCursor({ r: 200, g: 200, b: 200 });
 				} else {
 					this.#cleanupMicAnimation();
 				}
@@ -1122,10 +1121,15 @@ export class InteractiveMode implements InteractiveModeContext {
 		});
 	}
 
+	#setMicCursor(color: { r: number; g: number; b: number }): void {
+		this.editor.cursorOverride = `\x1b[38;2;${color.r};${color.g};${color.b}m${theme.icon.mic}\x1b[0m`;
+		// Theme symbols can be wide (for example, 🎤), so measure the rendered override.
+		this.editor.cursorOverrideWidth = visibleWidth(this.editor.cursorOverride);
+	}
+
 	#updateMicIcon(): void {
 		const { r, g, b } = hsvToRgb({ h: this.#voiceHue, s: 0.9, v: 1.0 });
-		this.editor.cursorOverride = `\x1b[38;2;${r};${g};${b}m${theme.icon.mic}\x1b[0m`;
-		this.editor.cursorOverrideWidth = 1;
+		this.#setMicCursor({ r, g, b });
 	}
 
 	#startMicAnimation(): void {

package/src/patch/index.ts

@@ -97,8 +97,12 @@ const patchEditSchema = Type.Object({
 export type ReplaceParams = Static<typeof replaceEditSchema>;
 export type PatchParams = Static<typeof patchEditSchema>;
 
-/** Pattern matching hashline display format prefixes: `LINE#ID:CONTENT` and `#ID:CONTENT` */
-const HASHLINE_PREFIX_RE = /^\s*(?:>>>|>>)?\s*(?:\d+\s*#\s*|#\s*)[ZPMQVRWSNKTXJBYH]{2}:/;
+/**
+ * Pattern matching hashline display format prefixes: `LINE#ID:CONTENT`, `#ID:CONTENT`, and `+ID:CONTENT`.
+ * A plus-prefixed form appears in diff-like output and should be treated as hashline metadata too.
+ */
+const HASHLINE_PREFIX_RE = /^\s*(?:>>>|>>)?\s*(?:\+?\s*(?:\d+\s*#\s*|#\s*)|\+)\s*[ZPMQVRWSNKTXJBYH]{2}:/;
+const HASHLINE_PREFIX_PLUS_RE = /^\s*(?:>>>|>>)?\s*\+\s*(?:\d+\s*#\s*|#\s*)?[ZPMQVRWSNKTXJBYH]{2}:/;
 
 /** Pattern matching a unified-diff added-line `+` prefix (but not `++`). Does NOT match `-` to avoid corrupting Markdown list items. */
 const DIFF_PLUS_RE = /^[+](?![+])/;
@@ -111,27 +115,31 @@ const DIFF_PLUS_RE = /^[+](?![+])/;
  * output file. This strips them heuristically before application.
  */
 export function stripNewLinePrefixes(lines: string[]): string[] {
-	// Hashline prefixes are highly specific to read output and should only be
-	// stripped when *every* non-empty line carries one.
-	// Diff '+' markers can be legitimate content less often, so keep majority mode.
+	// Hashline prefixes are highly specific to read output and are usually stripped only when
+	// *every* non-empty line carries one. If a line is prefixed as `+ID:`, strip that
+	// prefix while leaving other `+` lines untouched to avoid corrupting mixed snippets.
 	let hashPrefixCount = 0;
+	let diffPlusHashPrefixCount = 0;
 	let diffPlusCount = 0;
 	let nonEmpty = 0;
 	for (const l of lines) {
 		if (l.length === 0) continue;
 		nonEmpty++;
 		if (HASHLINE_PREFIX_RE.test(l)) hashPrefixCount++;
+		if (HASHLINE_PREFIX_PLUS_RE.test(l)) diffPlusHashPrefixCount++;
 		if (DIFF_PLUS_RE.test(l)) diffPlusCount++;
 	}
 	if (nonEmpty === 0) return lines;
 
 	const stripHash = hashPrefixCount > 0 && hashPrefixCount === nonEmpty;
-	const stripPlus = !stripHash && diffPlusCount > 0 && diffPlusCount >= nonEmpty * 0.5;
-	if (!stripHash && !stripPlus) return lines;
+	const stripPlus =
+		!stripHash && diffPlusHashPrefixCount === 0 && diffPlusCount > 0 && diffPlusCount >= nonEmpty * 0.5;
+	if (!stripHash && !stripPlus && diffPlusHashPrefixCount === 0) return lines;
 
 	return lines.map(l => {
 		if (stripHash) return l.replace(HASHLINE_PREFIX_RE, "");
 		if (stripPlus) return l.replace(DIFF_PLUS_RE, "");
+		if (diffPlusHashPrefixCount > 0 && HASHLINE_PREFIX_PLUS_RE.test(l)) return l.replace(HASHLINE_PREFIX_RE, "");
 		return l;
 	});
 }

package/src/prompts/agents/explore.md

@@ -3,7 +3,7 @@ name: explore
 description: Fast read-only codebase scout returning compressed context for handoff
 tools: read, grep, find, fetch, web_search
 model: pi/smol
-thinking-level: off
+thinking-level: med
 output:
   properties:
     summary:
@@ -12,84 +12,21 @@ output:
       type: string
     files:
       metadata:
-        description: Files examined with exact line ranges
+        description: Files examined with relevant code references
       elements:
         properties:
-          path:
+          ref:
             metadata:
-              description: Absolute path to file
+              description: Project-relative path or paths to the most relevant code reference(s), optionally suffixed with line ranges like `:12-34` when relevant
             type: string
-          line_start:
-            metadata:
-              description: First line read (1-indexed)
-            type: number
-          line_end:
-            metadata:
-              description: Last line read (1-indexed)
-            type: number
           description:
             metadata:
               description: Section contents
             type: string
-    code:
-      metadata:
-        description: Critical types/interfaces/functions extracted verbatim
-      elements:
-        properties:
-          path:
-            metadata:
-              description: Absolute path to source file
-            type: string
-          line_start:
-            metadata:
-              description: Excerpt first line (1-indexed)
-            type: number
-          line_end:
-            metadata:
-              description: Excerpt last line (1-indexed)
-            type: number
-          language:
-            metadata:
-              description: Language id for syntax highlighting
-            type: string
-          content:
-            metadata:
-              description: Verbatim code excerpt
-            type: string
     architecture:
       metadata:
         description: Brief explanation of how pieces connect
       type: string
-    dependencies:
-      metadata:
-        description: Key internal and external dependencies relevant to the task
-      elements:
-        properties:
-          name:
-            metadata:
-              description: Package or module name
-            type: string
-          role:
-            metadata:
-              description: What it provides in context of the task
-            type: string
-    risks:
-      metadata:
-        description: Gotchas, edge cases, or constraints the receiving agent should know
-      elements:
-        type: string
-    start_here:
-      metadata:
-        description: Recommended entry point for receiving agent
-      properties:
-        path:
-          metadata:
-            description: Absolute path to start reading
-          type: string
-        reason:
-          metadata:
-            description: Why this file best starting point
-          type: string
 ---
 
 You are a file search specialist and a codebase scout.