@oh-my-pi/pi-coding-agent 6.8.1 → 6.8.2

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased]
 
+## [6.8.2] - 2026-01-21
+
+### Fixed
+
+- Improved error messages when multiple text occurrences are found by showing line previews and context
+- Enhanced patch application to better handle duplicate content in context lines
+- Added occurrence previews to help users disambiguate between multiple matches
+- Fixed cache invalidation for streaming edits to prevent stale data
+- Fixed file existence check for prompt templates directory
+- Fixed bash output streaming to prevent premature stream closure
+- Fixed LSP client request handling when signal is already aborted
+- Fixed git apply operations with stdin input handling
+
+### Security
+
+- Updated Anthropic authentication to handle manual code input securely
+
 ## [6.8.1] - 2026-01-20
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "6.8.1",
+	"version": "6.8.2",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -40,11 +40,11 @@
 		"prepublishOnly": "bun run generate-template && bun run clean && bun run build"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-agent-core": "6.8.1",
-		"@oh-my-pi/pi-ai": "6.8.1",
-		"@oh-my-pi/pi-git-tool": "6.8.1",
-		"@oh-my-pi/pi-tui": "6.8.1",
-		"@oh-my-pi/pi-utils": "6.8.1",
+		"@oh-my-pi/pi-agent-core": "6.8.2",
+		"@oh-my-pi/pi-ai": "6.8.2",
+		"@oh-my-pi/pi-git-tool": "6.8.2",
+		"@oh-my-pi/pi-tui": "6.8.2",
+		"@oh-my-pi/pi-utils": "6.8.2",
 		"@openai/agents": "^0.3.7",
 		"@sinclair/typebox": "^0.34.46",
 		"ajv": "^8.17.1",

package/src/core/agent-session.ts

@@ -454,15 +454,19 @@ export class AgentSession {
 			}
 
 			if (event.message.role === "toolResult") {
-				const { $normative, toolCallId } = event.message as {
+				const { toolName, $normative, toolCallId, details } = event.message as {
 					toolName?: string;
 					toolCallId?: string;
-					details?: unknown;
+					details?: { path?: string };
 					$normative?: Record<string, unknown>;
 				};
 				if ($normative && toolCallId && this.settingsManager.getNormativeRewrite()) {
 					await this._rewriteToolCallArgs(toolCallId, $normative);
 				}
+				// Invalidate streaming edit cache when edit tool completes to prevent stale data
+				if (toolName === "edit" && details?.path) {
+					this._invalidateFileCacheForPath(details.path);
+				}
 			}
 		}
 
@@ -579,11 +583,16 @@ export class AgentSession {
 				this._streamingEditFileCache.set(resolvedPath, normalizeToLF(text));
 			}
 		} catch {
-			// Ignore errors - mark as empty string so we don't retry
-			this._streamingEditFileCache.set(resolvedPath, "");
+			// Don't cache on read errors - let the edit tool handle them
 		}
 	}
 
+	/** Invalidate cache for a file after an edit completes to prevent stale data */
+	private _invalidateFileCacheForPath(path: string): void {
+		const resolvedPath = resolveToCwd(path, this.sessionManager.getCwd());
+		this._streamingEditFileCache.delete(resolvedPath);
+	}
+
 	private _maybeAbortStreamingEdit(event: AgentEvent): void {
 		if (!this.settingsManager.getEditStreamingAbort()) return;
 		if (this._streamingEditAbortTriggered) return;

package/src/core/auth-storage.ts

@@ -560,7 +560,11 @@ export class AuthStorage {
 
 		switch (provider) {
 			case "anthropic":
-				credentials = await loginAnthropic(ctrl);
+				credentials = await loginAnthropic({
+					...ctrl,
+					onManualCodeInput: async () =>
+						ctrl.onPrompt({ message: "Paste the authorization code (or full redirect URL):" }),
+				});
 				break;
 			case "github-copilot":
 				credentials = await loginGitHubCopilot({

package/src/core/bash-executor.ts

@@ -34,7 +34,7 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 	const prefixedCommand = prefix ? `${prefix} ${command}` : command;
 	const finalCommand = `${snapshotPrefix}${prefixedCommand}`;
 
-	const stream = new OutputSink({ onLine: options?.onChunk });
+	const stream = new OutputSink({ onChunk: options?.onChunk });
 
 	const child = cspawn([shell, ...args, finalCommand], {
 		cwd: options?.cwd,
@@ -44,6 +44,7 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 	});
 
 	// Pump streams - errors during abort/timeout are expected
+	// Use preventClose to avoid closing the shared sink when either stream finishes
 	await Promise.allSettled([
 		child.stdout.pipeTo(stream.createWritable()),
 		child.stderr.pipeTo(stream.createWritable()),
@@ -92,7 +93,7 @@ export async function executeBashWithOperations(
 	operations: BashOperations,
 	options?: BashExecutorOptions,
 ): Promise<BashResult> {
-	const stream = new OutputSink({ onLine: options?.onChunk });
+	const stream = new OutputSink({ onChunk: options?.onChunk });
 	const writable = stream.createWritable();
 	const writer = writable.getWriter();
 

package/src/core/prompt-templates.ts

@@ -432,7 +432,7 @@ async function loadTemplatesFromDir(
 			}
 		}
 	} catch (error) {
-		if (!Bun.file(dir).exists()) {
+		if (!(await Bun.file(dir).exists())) {
 			return [];
 		}
 		logger.warn("Failed to scan prompt templates directory", { dir, error: String(error) });

package/src/core/tools/lsp/client.ts

@@ -741,7 +741,7 @@ export async function sendRequest(
 		signal.addEventListener("abort", abortHandler, { once: true });
 		if (signal.aborted) {
 			abortHandler();
-			return;
+			return promise;
 		}
 	}
 

package/src/core/tools/patch/applicator.ts

@@ -92,17 +92,17 @@ function adjustLinesIndentation(patternLines: string[], actualLines: string[], n
 		}
 	}
 
-	// Build a map from trimmed content to available (pattern index, actual index) pairs
-	// This lets us find context lines and their corresponding actual content
-	const contentToIndices = new Map<string, Array<{ patternIdx: number; actualIdx: number }>>();
-	for (let i = 0; i < Math.min(patternLines.length, actualLines.length); i++) {
-		const trimmed = patternLines[i].trim();
+	// Build a map from trimmed content to actual lines (by content, not position)
+	// This handles fuzzy matches where pattern and actual may not be positionally aligned
+	const contentToActualLines = new Map<string, string[]>();
+	for (const line of actualLines) {
+		const trimmed = line.trim();
 		if (trimmed.length === 0) continue;
-		const arr = contentToIndices.get(trimmed);
+		const arr = contentToActualLines.get(trimmed);
 		if (arr) {
-			arr.push({ patternIdx: i, actualIdx: i });
+			arr.push(line);
 		} else {
-			contentToIndices.set(trimmed, [{ patternIdx: i, actualIdx: i }]);
+			contentToActualLines.set(trimmed, [line]);
 		}
 	}
 
@@ -119,8 +119,8 @@ function adjustLinesIndentation(patternLines: string[], actualLines: string[], n
 	}
 	const avgDelta = deltaCount > 0 ? Math.round(totalDelta / deltaCount) : 0;
 
-	// Track which indices we've used to handle duplicate content correctly
-	const usedIndices = new Set<number>();
+	// Track which actual lines we've used to handle duplicate content correctly
+	const usedActualLines = new Map<string, number>(); // trimmed content -> count used
 
 	return newLines.map((newLine) => {
 		if (newLine.trim().length === 0) {
@@ -128,16 +128,15 @@ function adjustLinesIndentation(patternLines: string[], actualLines: string[], n
 		}
 
 		const trimmed = newLine.trim();
-		const indices = contentToIndices.get(trimmed);
-
-		// Check if this is a context line (same trimmed content exists in pattern)
-		if (indices) {
-			for (const { patternIdx, actualIdx } of indices) {
-				if (!usedIndices.has(patternIdx)) {
-					usedIndices.add(patternIdx);
-					// Use actual file content directly for context lines
-					return actualLines[actualIdx];
-				}
+		const matchingActualLines = contentToActualLines.get(trimmed);
+
+		// Check if this is a context line (same trimmed content exists in actual)
+		if (matchingActualLines && matchingActualLines.length > 0) {
+			const usedCount = usedActualLines.get(trimmed) ?? 0;
+			if (usedCount < matchingActualLines.length) {
+				usedActualLines.set(trimmed, usedCount + 1);
+				// Use actual file content directly for context lines
+				return matchingActualLines[usedCount];
 			}
 		}
 
@@ -599,9 +598,11 @@ function applyCharacterMatch(
 
 	// Check for multiple exact occurrences
 	if (matchOutcome.occurrences && matchOutcome.occurrences > 1) {
+		const previews = matchOutcome.occurrencePreviews?.join("\n\n") ?? "";
+		const moreMsg = matchOutcome.occurrences > 5 ? ` (showing first 5 of ${matchOutcome.occurrences})` : "";
 		throw new ApplyPatchError(
-			`Found ${matchOutcome.occurrences} occurrences of the text in ${path}. ` +
-				`The text must be unique. Please provide more context to make it unique.`,
+			`Found ${matchOutcome.occurrences} occurrences in ${path}${moreMsg}:\n\n${previews}\n\n` +
+				`Add more context lines to disambiguate.`,
 		);
 	}
 
@@ -857,9 +858,22 @@ function computeReplacements(
 		if (hunk.changeContext === undefined && !hunk.hasContextLines && !hunk.isEndOfFile && lineHint === undefined) {
 			const secondMatch = seekSequence(originalLines, pattern, found + 1, false, { allowFuzzy });
 			if (secondMatch.index !== undefined) {
+				// Extract 3-line previews for each match
+				const formatPreview = (startIdx: number) => {
+					const lines = originalLines.slice(startIdx, startIdx + 3);
+					return lines
+						.map((line, i) => {
+							const num = startIdx + i + 1;
+							const truncated = line.length > 60 ? `${line.slice(0, 57)}...` : line;
+							return `  ${num} | ${truncated}`;
+						})
+						.join("\n");
+				};
+				const preview1 = formatPreview(found);
+				const preview2 = formatPreview(secondMatch.index);
 				throw new ApplyPatchError(
-					`Found 2 occurrences of the text in ${path}. ` +
-						`The text must be unique. Please provide more context to make it unique.`,
+					`Found 2 occurrences in ${path}:\n\n${preview1}\n\n${preview2}\n\n` +
+						`Add more context lines to disambiguate.`,
 				);
 			}
 		}

package/src/core/tools/patch/diff.ts

@@ -228,9 +228,11 @@ export function replaceText(content: string, oldText: string, newText: string, o
 	});
 
 	if (matchOutcome.occurrences && matchOutcome.occurrences > 1) {
+		const previews = matchOutcome.occurrencePreviews?.join("\n\n") ?? "";
+		const moreMsg = matchOutcome.occurrences > 5 ? ` (showing first 5 of ${matchOutcome.occurrences})` : "";
 		throw new Error(
-			`Found ${matchOutcome.occurrences} occurrences of the text. ` +
-				`The text must be unique. Please provide more context to make it unique, or use all: true to replace all.`,
+			`Found ${matchOutcome.occurrences} occurrences${moreMsg}:\n\n${previews}\n\n` +
+				`Add more context lines to disambiguate.`,
 		);
 	}
 
@@ -307,8 +309,10 @@ export async function computeEditDiff(
 			});
 
 			if (matchOutcome.occurrences && matchOutcome.occurrences > 1) {
+				const previews = matchOutcome.occurrencePreviews?.join("\n\n") ?? "";
+				const moreMsg = matchOutcome.occurrences > 5 ? ` (showing first 5 of ${matchOutcome.occurrences})` : "";
 				return {
-					error: `Found ${matchOutcome.occurrences} occurrences of the text in ${path}. The text must be unique. Please provide more context to make it unique, or use all: true to replace all.`,
+					error: `Found ${matchOutcome.occurrences} occurrences in ${path}${moreMsg}:\n\n${previews}\n\nAdd more context lines to disambiguate.`,
 				};
 			}
 

package/src/core/tools/patch/fuzzy.ts

@@ -215,7 +215,25 @@ export function findMatch(
 	if (exactIndex !== -1) {
 		const occurrences = content.split(target).length - 1;
 		if (occurrences > 1) {
-			return { occurrences };
+			// Find line numbers and previews for each occurrence (up to 5)
+			const contentLines = content.split("\n");
+			const occurrenceLines: number[] = [];
+			const occurrencePreviews: string[] = [];
+			let searchStart = 0;
+			for (let i = 0; i < 5; i++) {
+				const idx = content.indexOf(target, searchStart);
+				if (idx === -1) break;
+				const lineNumber = content.slice(0, idx).split("\n").length;
+				occurrenceLines.push(lineNumber);
+				// Extract 3 lines starting from match (0-indexed)
+				const previewLines = contentLines.slice(lineNumber - 1, lineNumber + 2);
+				const preview = previewLines
+					.map((line, i) => `  ${lineNumber + i} | ${line.length > 60 ? `${line.slice(0, 57)}...` : line}`)
+					.join("\n");
+				occurrencePreviews.push(preview);
+				searchStart = idx + 1;
+			}
+			return { occurrences, occurrenceLines, occurrencePreviews };
 		}
 		const startLine = content.slice(0, exactIndex).split("\n").length;
 		return {

package/src/core/tools/patch/index.ts

@@ -390,8 +390,11 @@ export class EditTool implements AgentTool<TInput> {
 			});
 
 			if (matchOutcome.occurrences && matchOutcome.occurrences > 1) {
+				const previews = matchOutcome.occurrencePreviews?.join("\n\n") ?? "";
+				const moreMsg = matchOutcome.occurrences > 5 ? ` (showing first 5 of ${matchOutcome.occurrences})` : "";
 				throw new Error(
-					`Found ${matchOutcome.occurrences} occurrences of the text in ${path}. The text must be unique. Please provide more context to make it unique, or use all: true to replace all.`,
+					`Found ${matchOutcome.occurrences} occurrences in ${path}${moreMsg}:\n\n${previews}\n\n` +
+						`Add more context lines to disambiguate.`,
 				);
 			}
 

package/src/core/tools/patch/types.ts

@@ -40,6 +40,10 @@ export interface MatchOutcome {
 	closest?: FuzzyMatch;
 	/** Number of occurrences if multiple exact matches found */
 	occurrences?: number;
+	/** Line numbers where occurrences were found (1-indexed) */
+	occurrenceLines?: number[];
+	/** Preview snippets for each occurrence (up to 5) */
+	occurrencePreviews?: string[];
 	/** Number of fuzzy matches above threshold */
 	fuzzyMatches?: number;
 }

package/src/core/tools/task/executor.ts

@@ -10,13 +10,13 @@ import type { EventBus } from "../../event-bus";
 import { callTool } from "../../mcp/client";
 import type { MCPManager } from "../../mcp/manager";
 import type { ModelRegistry } from "../../model-registry";
+import { formatModelString, parseModelPattern } from "../../model-resolver";
 import { checkPythonKernelAvailability } from "../../python-kernel";
 import type { ToolSession } from "..";
 import { LspTool } from "../lsp/index";
 import type { LspParams } from "../lsp/types";
 import { PythonTool } from "../python";
 import { ensureArtifactsDir, getArtifactPaths } from "./artifacts";
-import { resolveModelPattern } from "./model-resolver";
 import { subprocessToolRegistry } from "./subprocess-tool-registry";
 import {
 	type AgentDefinition,
@@ -296,10 +296,26 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	}
 
 	const serializedSettings = options.settingsManager?.serialize();
-	const availableModels = options.modelRegistry?.getAvailable().map((model) => `${model.provider}/${model.id}`);
-
-	// Resolve and add model
-	const resolvedModel = await resolveModelPattern(modelOverride || agent.model, availableModels, serializedSettings);
+	const availableModels = options.modelRegistry?.getAvailable() ?? [];
+
+	// Resolve model pattern to provider/modelId string
+	const modelPattern = modelOverride ?? agent.model;
+	let resolvedModel: string | undefined;
+	if (modelPattern) {
+		// Handle omp/<role> or pi/<role> aliases (e.g., "omp/slow", "pi/fast")
+		let effectivePattern = modelPattern;
+		const lower = modelPattern.toLowerCase();
+		if (lower.startsWith("omp/") || lower.startsWith("pi/")) {
+			const role = lower.startsWith("omp/") ? modelPattern.slice(4) : modelPattern.slice(3);
+			const roles = serializedSettings?.modelRoles as Record<string, string> | undefined;
+			const configured = roles?.[role] ?? roles?.[role.toLowerCase()];
+			if (configured) {
+				effectivePattern = configured;
+			}
+		}
+		const { model } = parseModelPattern(effectivePattern, availableModels);
+		resolvedModel = model ? formatModelString(model) : undefined;
+	}
 	const sessionFile = subtaskSessionFile ?? null;
 	const spawnsEnv = agent.spawns === undefined ? "" : agent.spawns === "*" ? "*" : agent.spawns.join(",");
 

package/src/core/tools/task/worker.ts

@@ -799,10 +799,11 @@ const reportFatal = async (message: string): Promise<void> => {
 	} catch {
 		// Ignore cleanup errors
 	}
+	const error = new Error(message);
 
 	const runState = activeRun;
 	if (runState) {
-		runState.abortController.abort();
+		runState.abortController.abort(error);
 		if (runState.session) {
 			void runState.session.abort();
 		}

package/src/core/tools/web-scrapers/youtube.ts

@@ -2,7 +2,6 @@ import { unlinkSync } from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { cspawn } from "@oh-my-pi/pi-utils";
-import type { FileSink } from "bun";
 import { nanoid } from "nanoid";
 import { ensureTool } from "../../../utils/tools-manager";
 import type { RenderResult, SpecialHandler } from "./types";
@@ -16,59 +15,17 @@ async function exec(
 	args: string[],
 	options?: { timeout?: number; input?: string | Buffer; signal?: AbortSignal },
 ): Promise<{ stdout: string; stderr: string; ok: boolean; exitCode: number | null }> {
-	const controller = new AbortController();
-	const onAbort = () => controller.abort(options?.signal?.reason ?? new Error("Aborted"));
-	if (options?.signal) {
-		if (options.signal.aborted) {
-			onAbort();
-		} else {
-			options.signal.addEventListener("abort", onAbort, { once: true });
-		}
-	}
-	const timeoutId =
-		options?.timeout && options.timeout > 0
-			? setTimeout(() => controller.abort(new Error("Timeout")), options.timeout)
-			: undefined;
 	const proc = cspawn([cmd, ...args], {
-		signal: controller.signal,
+		signal: options?.signal,
+		timeout: options?.timeout,
+		stdin: options?.input ? Buffer.from(options.input) : undefined,
 	});
 
-	if (options?.input && proc.stdin) {
-		const stdin = proc.stdin as FileSink;
-		const payload = typeof options.input === "string" ? new TextEncoder().encode(options.input) : options.input;
-		stdin.write(payload);
-		const flushed = stdin.flush();
-		if (flushed instanceof Promise) {
-			await flushed;
-		}
-		const ended = stdin.end();
-		if (ended instanceof Promise) {
-			await ended;
-		}
-	}
-
 	const [stdout, stderr, exitResult] = await Promise.all([
-		new Response(proc.stdout).text(),
-		new Response(proc.stderr).text(),
-		(async () => {
-			try {
-				await proc.exited;
-				return proc.exitCode ?? 0;
-			} catch (err) {
-				if (err && typeof err === "object" && "exitCode" in err) {
-					const exitValue = (err as { exitCode?: number }).exitCode;
-					if (typeof exitValue === "number") {
-						return exitValue;
-					}
-				}
-				throw err instanceof Error ? err : new Error(String(err));
-			}
-		})(),
+		proc.stdout.text(),
+		proc.stderr.text(),
+		proc.exited.then(() => proc.exitCode ?? 0),
 	]);
-	if (timeoutId) clearTimeout(timeoutId);
-	if (options?.signal) {
-		options.signal.removeEventListener("abort", onAbort);
-	}
 
 	return {
 		stdout,

package/src/lib/worktree/collapse.ts

@@ -1,6 +1,6 @@
 import { nanoid } from "nanoid";
 import { WorktreeError, WorktreeErrorCode } from "./errors";
-import { git, gitWithStdin } from "./git";
+import { git, gitWithInput } from "./git";
 import { find, remove, type Worktree } from "./operations";
 
 export type CollapseStrategy = "simple" | "merge-base" | "rebase";
@@ -121,10 +121,10 @@ async function collapseRebase(src: Worktree, dst: Worktree): Promise<string> {
 }
 
 async function applyDiff(diff: string, targetPath: string): Promise<void> {
-	let result = await gitWithStdin(["apply"], diff, targetPath);
+	let result = await gitWithInput(["apply"], diff, targetPath);
 	if (result.code === 0) return;
 
-	result = await gitWithStdin(["apply", "--3way"], diff, targetPath);
+	result = await gitWithInput(["apply", "--3way"], diff, targetPath);
 	if (result.code === 0) return;
 
 	throw new WorktreeError(

package/src/lib/worktree/git.ts

@@ -1,5 +1,5 @@
 import * as path from "node:path";
-import type { Subprocess } from "bun";
+import { ptree } from "@oh-my-pi/pi-utils";
 import { execCommand } from "../../core/exec";
 import { WorktreeError, WorktreeErrorCode } from "./errors";
 
@@ -9,32 +9,6 @@ export interface GitResult {
 	stderr: string;
 }
 
-type WritableLike = {
-	write: (chunk: string | Uint8Array) => unknown;
-	flush?: () => unknown;
-	end?: () => unknown;
-};
-
-const textEncoder = new TextEncoder();
-
-async function writeStdin(handle: unknown, stdin: string): Promise<void> {
-	if (!handle || typeof handle === "number") return;
-	if (typeof (handle as WritableStream<Uint8Array>).getWriter === "function") {
-		const writer = (handle as WritableStream<Uint8Array>).getWriter();
-		try {
-			await writer.write(textEncoder.encode(stdin));
-		} finally {
-			await writer.close();
-		}
-		return;
-	}
-
-	const sink = handle as WritableLike;
-	sink.write(stdin);
-	if (sink.flush) sink.flush();
-	if (sink.end) sink.end();
-}
-
 /**
  * Execute a git command.
  * @param args - Command arguments (excluding 'git')
@@ -50,23 +24,15 @@ export async function git(args: string[], cwd?: string): Promise<GitResult> {
  * Execute git command with stdin input.
  * Used for piping diffs to `git apply`.
  */
-export async function gitWithStdin(args: string[], stdin: string, cwd?: string): Promise<GitResult> {
-	const proc: Subprocess = Bun.spawn(["git", ...args], {
+export async function gitWithInput(args: string[], stdin: string, cwd?: string): Promise<GitResult> {
+	const proc = ptree.cspawn(["git", ...args], {
 		cwd: cwd ?? process.cwd(),
-		stdin: "pipe",
-		stdout: "pipe",
-		stderr: "pipe",
+		stdin: Buffer.from(stdin),
 	});
 
-	await writeStdin(proc.stdin, stdin);
-
-	const [stdout, stderr, exitCode] = await Promise.all([
-		(proc.stdout as ReadableStream<Uint8Array>).text(),
-		(proc.stderr as ReadableStream<Uint8Array>).text(),
-		proc.exited,
-	]);
+	const [stdout, stderr] = await Promise.all([proc.stdout.text(), proc.stderr.text()]);
 
-	return { code: exitCode ?? 0, stdout, stderr };
+	return { code: proc.exitCode ?? 0, stdout, stderr };
 }
 
 /**

package/src/lib/worktree/index.ts

@@ -1,7 +1,7 @@
 export { type CollapseOptions, type CollapseResult, type CollapseStrategy, collapse } from "./collapse";
 export { WORKTREE_BASE } from "./constants";
 export { WorktreeError, WorktreeErrorCode } from "./errors";
-export { getRepoName, getRepoRoot, git, gitWithStdin } from "./git";
+export { getRepoName, getRepoRoot, git, gitWithInput as gitWithStdin } from "./git";
 export { create, find, list, prune, remove, type Worktree, which } from "./operations";
 export {
 	cleanupSessions,

package/src/utils/clipboard.ts

@@ -32,8 +32,6 @@ function selectPreferredImageMimeType(mimeTypes: string[]): string | null {
 }
 
 export async function copyToClipboard(text: string): Promise<void> {
-	const timeout = Bun.sleep(3000).then(() => Promise.reject(new Error("Clipboard operation timed out")));
-
 	let promise: Promise<void>;
 	try {
 		switch (platform()) {
@@ -56,11 +54,11 @@ export async function copyToClipboard(text: string): Promise<void> {
 		}
 	} catch (error) {
 		if (error instanceof Error) {
-			throw new Error(`Failed to copy to clipboard: ${error.message}`);
+			throw new Error(`Failed to copy to clipboard: ${error.message}`, { cause: error });
 		}
-		throw new Error(`Failed to copy to clipboard: ${String(error)}`);
+		throw new Error(`Failed to copy to clipboard: ${String(error)}`, { cause: error });
 	}
-	await Promise.race([promise, timeout]);
+	await Promise.race([promise, Bun.sleep(3000)]);
 }
 
 export interface ClipboardImage {

package/src/core/tools/task/model-resolver.ts

@@ -1,206 +0,0 @@
-/**
- * Model resolution with fuzzy pattern matching.
- *
- * Returns models in "provider/modelId" format for use with --model flag.
- *
- * Supports:
- *   - Exact match: "gpt-5.2" → "p-openai/gpt-5.2"
- *   - Fuzzy match: "opus" → "p-anthropic/claude-opus-4-5"
- *   - Comma fallback: "gpt, opus" → tries gpt first, then opus
- *   - "default" → undefined (use system default)
- *   - "omp/slow" or "pi/slow" → configured slow model from settings
- */
-
-import { $ } from "bun";
-import { type Settings as SettingsFile, settingsCapability } from "../../../capability/settings";
-import { loadCapability } from "../../../discovery";
-import type { Settings as SettingsData } from "../../settings-manager";
-import { resolveOmpCommand } from "./omp-command";
-
-/** Cache for available models (provider/modelId format) */
-let cachedModels: string[] | null = null;
-
-/** Cache expiry time (5 minutes) */
-let cacheExpiry = 0;
-
-const CACHE_TTL_MS = 5 * 60 * 1000;
-
-/**
- * Get available models from `omp --list-models`.
- * Returns models in "provider/modelId" format.
- * Caches the result for performance.
- */
-export async function getAvailableModels(): Promise<string[]> {
-	const now = Date.now();
-	if (cachedModels !== null && now < cacheExpiry) {
-		return cachedModels;
-	}
-
-	try {
-		const ompCommand = resolveOmpCommand();
-		const result = await $`${ompCommand.cmd} ${ompCommand.args} --list-models`.quiet().nothrow();
-		const stdout = result.stdout?.toString() ?? "";
-
-		if (result.exitCode !== 0 || !stdout.trim()) {
-			cachedModels = [];
-			cacheExpiry = now + CACHE_TTL_MS;
-			return cachedModels;
-		}
-
-		// Parse output: skip header line, extract provider/model
-		const lines = stdout.trim().split("\n");
-		cachedModels = lines
-			.slice(1) // Skip header
-			.map((line) => {
-				const parts = line.trim().split(/\s+/);
-				// Format: provider/modelId
-				return parts[0] && parts[1] ? `${parts[0]}/${parts[1]}` : "";
-			})
-			.filter(Boolean);
-
-		cacheExpiry = now + CACHE_TTL_MS;
-		return cachedModels;
-	} catch {
-		cachedModels = [];
-		cacheExpiry = now + CACHE_TTL_MS;
-		return cachedModels;
-	}
-}
-
-/**
- * Clear the model cache (for testing).
- */
-export function clearModelCache(): void {
-	cachedModels = null;
-	cacheExpiry = 0;
-}
-
-/**
- * Load model roles from settings files using capability API.
- */
-async function loadModelRoles(): Promise<Record<string, string>> {
-	const result = await loadCapability<SettingsFile>(settingsCapability.id, { cwd: process.cwd() });
-
-	// Merge all settings, prioritizing first (highest priority)
-	let modelRoles: Record<string, string> = {};
-	for (const settings of result.items.reverse()) {
-		const roles = settings.data.modelRoles as Record<string, string> | undefined;
-		if (roles) {
-			modelRoles = { ...modelRoles, ...roles };
-		}
-	}
-
-	return modelRoles;
-}
-
-/**
- * Resolve an omp/<role> alias to a model string.
- * Looks up the role in settings.modelRoles and returns the configured model.
- * Returns undefined if the role isn't configured.
- */
-async function resolveOmpAlias(
-	role: string,
-	availableModels: string[],
-	settings?: SettingsData,
-): Promise<string | undefined> {
-	const roles = settings?.modelRoles ?? (await loadModelRoles());
-
-	// Look up role in settings (case-insensitive)
-	const configured = roles[role] || roles[role.toLowerCase()];
-	if (!configured) return undefined;
-
-	// configured is in "provider/modelId" format, find in available models
-	return availableModels.find((m) => m.toLowerCase() === configured.toLowerCase());
-}
-
-/**
- * Extract model ID from "provider/modelId" format.
- */
-function getModelId(fullModel: string): string {
-	const slashIdx = fullModel.indexOf("/");
-	return slashIdx > 0 ? fullModel.slice(slashIdx + 1) : fullModel;
-}
-
-/**
- * Extract provider from "provider/modelId" format.
- * Returns undefined if no provider prefix.
- */
-function getProvider(fullModel: string): string | undefined {
-	const slashIdx = fullModel.indexOf("/");
-	return slashIdx > 0 ? fullModel.slice(0, slashIdx) : undefined;
-}
-
-/**
- * Resolve a fuzzy model pattern to "provider/modelId" format.
- *
- * Supports comma-separated patterns (e.g., "gpt, opus") - tries each in order.
- * Returns undefined if pattern is "default", undefined, or no match found.
- *
- * @param pattern - Model pattern to resolve
- * @param availableModels - Optional pre-fetched list of available models (in provider/modelId format)
- * @param settings - Optional settings for role alias resolution (pi/..., omp/...)
- */
-export async function resolveModelPattern(
-	pattern: string | undefined,
-	availableModels?: string[],
-	settings?: SettingsData,
-): Promise<string | undefined> {
-	if (!pattern || pattern === "default") {
-		return undefined;
-	}
-
-	const models = availableModels ?? (await getAvailableModels());
-	if (models.length === 0) {
-		// Fallback: return pattern as-is if we can't get available models
-		return pattern;
-	}
-
-	// Split by comma, try each pattern in order
-	const patterns = pattern
-		.split(",")
-		.map((p) => p.trim())
-		.filter(Boolean);
-
-	for (const p of patterns) {
-		// Handle omp/<role> or pi/<role> aliases - looks up role in settings.modelRoles
-		const lower = p.toLowerCase();
-		if (lower.startsWith("omp/") || lower.startsWith("pi/")) {
-			const role = lower.startsWith("omp/") ? p.slice(4) : p.slice(3);
-			const resolved = await resolveOmpAlias(role, models, settings);
-			if (resolved) return resolved;
-			continue; // Role not configured, try next pattern
-		}
-
-		// Try exact match on full provider/modelId
-		const exactFull = models.find((m) => m.toLowerCase() === p.toLowerCase());
-		if (exactFull) return exactFull;
-
-		// Try exact match on model ID only
-		const exactId = models.find((m) => getModelId(m).toLowerCase() === p.toLowerCase());
-		if (exactId) return exactId;
-
-		// Check if pattern has provider prefix (e.g., "zai/glm-4.7")
-		const patternProvider = getProvider(p);
-		const patternModelId = getModelId(p);
-
-		// If pattern has provider prefix, fuzzy match must stay within that provider
-		// (don't cross provider boundaries when user explicitly specifies provider)
-		if (patternProvider) {
-			const providerFuzzyMatch = models.find(
-				(m) =>
-					getProvider(m)?.toLowerCase() === patternProvider.toLowerCase() &&
-					getModelId(m).toLowerCase().includes(patternModelId.toLowerCase()),
-			);
-			if (providerFuzzyMatch) return providerFuzzyMatch;
-			// No match in specified provider - don't fall through to other providers
-			continue;
-		}
-
-		// No provider prefix - fall back to general fuzzy match on model ID (substring)
-		const fuzzyMatch = models.find((m) => getModelId(m).toLowerCase().includes(patternModelId.toLowerCase()));
-		if (fuzzyMatch) return fuzzyMatch;
-	}
-
-	// No match found - use default model
-	return undefined;
-}