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

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.

package/src/session/agent-session.ts

@@ -3791,33 +3791,24 @@ export class AgentSession {
 		if (calledRequiredTool) {
 			return;
 		}
-
-		const askTool = this.#toolRegistry.get("ask");
-		const exitPlanModeTool = this.#toolRegistry.get("exit_plan_mode");
-		if (!askTool || !exitPlanModeTool) {
+		const hasRequiredTools = this.#toolRegistry.has("ask") && this.#toolRegistry.has("exit_plan_mode");
+		if (!hasRequiredTools) {
 			logger.warn("Plan mode enforcement skipped because ask/exit tools are unavailable", {
 				activeToolNames: this.agent.state.tools.map(tool => tool.name),
 			});
 			return;
 		}
-		const forcedTools = [askTool, exitPlanModeTool];
 
 		const reminder = renderPromptTemplate(planModeToolDecisionReminderPrompt, {
 			askToolName: "ask",
 			exitToolName: "exit_plan_mode",
 		});
 
-		const previousTools = this.agent.state.tools;
-		this.agent.setTools(forcedTools);
-		try {
-			await this.prompt(reminder, {
-				synthetic: true,
-				expandPromptTemplates: false,
-				toolChoice: "required",
-			});
-		} finally {
-			this.agent.setTools(previousTools);
-		}
+		await this.prompt(reminder, {
+			synthetic: true,
+			expandPromptTemplates: false,
+			toolChoice: "required",
+		});
 	}
 
 	#createEagerTodoPrelude(): { message: AgentMessage; toolChoice: ToolChoice } | undefined {

package/src/session/streaming-output.ts

@@ -32,6 +32,8 @@ export interface OutputSinkOptions {
 	artifactId?: string;
 	spillThreshold?: number;
 	onChunk?: (chunk: string) => void;
+	/** Minimum ms between onChunk calls. 0 = every chunk (default). */
+	chunkThrottleMs?: number;
 }
 
 export interface TruncationResult {
@@ -521,6 +523,7 @@ export class OutputSink {
 	#totalBytes = 0;
 	#sawData = false;
 	#truncated = false;
+	#lastChunkTime = 0;
 
 	#file?: {
 		path: string;
@@ -528,22 +531,46 @@ export class OutputSink {
 		sink: Bun.FileSink;
 	};
 
+	// Queue of chunks waiting for the file sink to be created.
+	#pendingFileWrites?: string[];
+	#fileReady = false;
+
 	readonly #artifactPath?: string;
 	readonly #artifactId?: string;
 	readonly #spillThreshold: number;
 	readonly #onChunk?: (chunk: string) => void;
+	readonly #chunkThrottleMs: number;
 
 	constructor(options?: OutputSinkOptions) {
-		const { artifactPath, artifactId, spillThreshold = DEFAULT_MAX_BYTES, onChunk } = options ?? {};
+		const {
+			artifactPath,
+			artifactId,
+			spillThreshold = DEFAULT_MAX_BYTES,
+			onChunk,
+			chunkThrottleMs = 0,
+		} = options ?? {};
 		this.#artifactPath = artifactPath;
 		this.#artifactId = artifactId;
 		this.#spillThreshold = spillThreshold;
 		this.#onChunk = onChunk;
+		this.#chunkThrottleMs = chunkThrottleMs;
 	}
 
-	async push(chunk: string): Promise<void> {
+	/**
+	 * Push a chunk of output. The buffer management and onChunk callback run
+	 * synchronously. File sink writes are deferred and serialized internally.
+	 */
+	push(chunk: string): void {
 		chunk = sanitizeWithOptionalSixelPassthrough(chunk, sanitizeText);
-		this.#onChunk?.(chunk);
+
+		// Throttled onChunk: only call the callback when enough time has passed.
+		if (this.#onChunk) {
+			const now = Date.now();
+			if (now - this.#lastChunkTime >= this.#chunkThrottleMs) {
+				this.#lastChunkTime = now;
+				this.#onChunk(chunk);
+			}
+		}
 
 		const dataBytes = Buffer.byteLength(chunk, "utf-8");
 		this.#totalBytes += dataBytes;
@@ -556,10 +583,9 @@ export class OutputSink {
 		const threshold = this.#spillThreshold;
 		const willOverflow = this.#bufferBytes + dataBytes > threshold;
 
-		// Write to file if already spilling or about to overflow
-		if (this.#file != null || willOverflow) {
-			const sink = await this.#ensureFileSink();
-			await sink?.write(chunk);
+		// Write to artifact file if configured and past the threshold
+		if (this.#artifactPath && (this.#file != null || willOverflow)) {
+			this.#writeToFile(chunk);
 		}
 
 		if (!willOverflow) {
@@ -589,14 +615,64 @@ export class OutputSink {
 		if (this.#file) this.#truncated = true;
 	}
 
+	/**
+	 * Write a chunk to the artifact file. Handles the async file sink creation
+	 * by queuing writes until the sink is ready, then draining synchronously.
+	 */
+	#writeToFile(chunk: string): void {
+		if (this.#fileReady && this.#file) {
+			// Fast path: file sink exists, write synchronously
+			this.#file.sink.write(chunk);
+			return;
+		}
+		// File sink not yet created — queue this chunk and kick off creation
+		if (!this.#pendingFileWrites) {
+			this.#pendingFileWrites = [chunk];
+			void this.#createFileSink();
+		} else {
+			this.#pendingFileWrites.push(chunk);
+		}
+	}
+
+	async #createFileSink(): Promise<void> {
+		if (!this.#artifactPath || this.#fileReady) return;
+		try {
+			const sink = Bun.file(this.#artifactPath).writer();
+			this.#file = { path: this.#artifactPath, artifactId: this.#artifactId, sink };
+
+			// Flush existing buffer to file BEFORE it gets trimmed further.
+			if (this.#buffer.length > 0) {
+				sink.write(this.#buffer);
+			}
+
+			// Drain any chunks that arrived while the sink was being created
+			if (this.#pendingFileWrites) {
+				for (const pending of this.#pendingFileWrites) {
+					sink.write(pending);
+				}
+				this.#pendingFileWrites = undefined;
+			}
+
+			this.#fileReady = true;
+		} catch {
+			try {
+				await this.#file?.sink?.end();
+			} catch {
+				/* ignore */
+			}
+			this.#file = undefined;
+			this.#pendingFileWrites = undefined;
+		}
+	}
+
 	createInput(): WritableStream<Uint8Array | string> {
 		const dec = new TextDecoder("utf-8", { ignoreBOM: true });
-		const finalize = async () => {
-			await this.push(dec.decode());
+		const finalize = () => {
+			this.push(dec.decode());
 		};
 		return new WritableStream({
-			write: async chunk => {
-				await this.push(typeof chunk === "string" ? chunk : dec.decode(chunk, { stream: true }));
+			write: chunk => {
+				this.push(typeof chunk === "string" ? chunk : dec.decode(chunk, { stream: true }));
 			},
 			close: finalize,
 			abort: finalize,
@@ -620,32 +696,6 @@ export class OutputSink {
 			artifactId: this.#file?.artifactId,
 		};
 	}
-
-	// -- private ---------------------------------------------------------------
-
-	async #ensureFileSink(): Promise<Bun.FileSink | null> {
-		if (!this.#artifactPath) return null;
-		if (this.#file) return this.#file.sink;
-
-		try {
-			const sink = Bun.file(this.#artifactPath).writer();
-			this.#file = { path: this.#artifactPath, artifactId: this.#artifactId, sink };
-
-			// Flush existing buffer to file BEFORE it gets trimmed further.
-			if (this.#buffer.length > 0) {
-				await sink.write(this.#buffer);
-			}
-			return sink;
-		} catch {
-			try {
-				await this.#file?.sink?.end();
-			} catch {
-				/* ignore */
-			}
-			this.#file = undefined;
-			return null;
-		}
-	}
 }
 
 // =============================================================================

package/src/slash-commands/builtin-registry.ts

@@ -406,6 +406,7 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
 			},
 			{ name: "smithery-login", description: "Login to Smithery and cache API key" },
 			{ name: "smithery-logout", description: "Remove cached Smithery API key" },
+			{ name: "reconnect", description: "Reconnect to a specific MCP server", usage: "<name>" },
 			{ name: "reload", description: "Force reload MCP runtime tools" },
 			{ name: "resources", description: "List available resources from connected servers" },
 			{ name: "prompts", description: "List available prompts from connected servers" },

package/src/tools/bash-interactive.ts

@@ -295,7 +295,6 @@ export async function runInteractiveBashPty(
 	},
 ): Promise<BashInteractiveResult> {
 	const sink = new OutputSink({ artifactPath: options.artifactPath, artifactId: options.artifactId });
-	let pendingChunks = Promise.resolve();
 	const result = await ui.custom<BashInteractiveResult>(
 		(tui, uiTheme, _keybindings, done) => {
 			const session = new PtySession();
@@ -309,7 +308,6 @@ export async function runInteractiveBashPty(
 				tui.requestRender();
 				void (async () => {
 					await component.flushOutput();
-					await pendingChunks;
 					const summary = await sink.dump();
 					done({
 						exitCode: run.exitCode,
@@ -362,15 +360,13 @@ export async function runInteractiveBashPty(
 						if (finished || err || !chunk) return;
 						component.appendOutput(chunk);
 						const normalizedChunk = normalizeCaptureChunk(chunk);
-						pendingChunks = pendingChunks.then(() => sink.push(normalizedChunk)).catch(() => {});
+						sink.push(normalizedChunk);
 						tui.requestRender();
 					},
 				)
 				.then(finalize)
 				.catch(error => {
-					pendingChunks = pendingChunks
-						.then(() => sink.push(`PTY error: ${error instanceof Error ? error.message : String(error)}\n`))
-						.catch(() => {});
+					sink.push(`PTY error: ${error instanceof Error ? error.message : String(error)}\n`);
 					finalize({ exitCode: undefined, cancelled: false, timedOut: false });
 				});
 			return component;

package/src/tools/python.ts

@@ -289,8 +289,8 @@ export class PythonTool implements AgentTool<typeof pythonSchema> {
 				const executorOptions: PythonExecutorOptions = {
 					...baseExecutorOptions,
 					reset: isFirstCell ? reset : false,
-					onChunk: async chunk => {
-						await outputSink!.push(chunk);
+					onChunk: chunk => {
+						outputSink!.push(chunk);
 					},
 				};