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

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/python.ts

@@ -64,6 +64,7 @@ export interface PythonToolDetails {
 	images?: ImageContent[];
 	/** Structured status events from prelude helpers */
 	statusEvents?: PythonStatusEvent[];
+	isError?: boolean;
 }
 
 function formatJsonScalar(value: unknown): string {

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(",");
 
@@ -343,7 +359,9 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	let abortSent = false;
 	let abortReason: AbortReason | undefined;
 	let terminationScheduled = false;
-	let pendingTerminationController: AbortController | null = null;
+	let terminated = false;
+	let terminationTimeoutId: ReturnType<typeof setTimeout> | null = null;
+	let pendingTerminationTimeoutId: ReturnType<typeof setTimeout> | null = null;
 	let finalize: ((message: Extract<SubagentWorkerResponse, { type: "done" }>) => void) | null = null;
 	const listenerController = new AbortController();
 	const listenerSignal = listenerController.signal;
@@ -416,28 +434,25 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	const scheduleTermination = () => {
 		if (terminationScheduled) return;
 		terminationScheduled = true;
-		const timeoutSignal = AbortSignal.timeout(2000);
-		timeoutSignal.addEventListener(
-			"abort",
-			() => {
-				if (resolved) return;
-				try {
-					worker.terminate();
-				} catch {
-					// Ignore termination errors
-				}
-				if (finalize && !resolved) {
-					finalize({
-						type: "done",
-						exitCode: 1,
-						durationMs: Date.now() - startTime,
-						error: abortReason === "signal" ? "Aborted" : "Worker terminated after tool completion",
-						aborted: abortReason === "signal",
-					});
-				}
-			},
-			{ once: true, signal: listenerSignal },
-		);
+		terminationTimeoutId = setTimeout(() => {
+			terminationTimeoutId = null;
+			if (resolved || terminated) return;
+			terminated = true;
+			try {
+				worker.terminate();
+			} catch {
+				// Ignore termination errors
+			}
+			if (finalize && !resolved) {
+				finalize({
+					type: "done",
+					exitCode: 1,
+					durationMs: Date.now() - startTime,
+					error: abortReason === "signal" ? "Aborted" : "Worker terminated after tool completion",
+					aborted: abortReason === "signal",
+				});
+			}
+		}, 2000);
 	};
 
 	const requestAbort = (reason: AbortReason) => {
@@ -461,28 +476,25 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			// Worker already terminated, nothing to do
 		}
 		// Cancel pending termination if it exists
-		if (pendingTerminationController) {
-			pendingTerminationController.abort();
-			pendingTerminationController = null;
-		}
+		cancelPendingTermination();
 		scheduleTermination();
 	};
 
 	const schedulePendingTermination = () => {
-		if (pendingTerminationController || abortSent || terminationScheduled || resolved) return;
-		const readyController = new AbortController();
-		pendingTerminationController = readyController;
-		const pendingSignal = AbortSignal.any([AbortSignal.timeout(2000), readyController.signal]);
-		pendingSignal.addEventListener(
-			"abort",
-			() => {
-				pendingTerminationController = null;
-				if (!resolved) {
-					requestAbort("terminate");
-				}
-			},
-			{ once: true, signal: listenerSignal },
-		);
+		if (pendingTerminationTimeoutId || abortSent || terminationScheduled || resolved) return;
+		pendingTerminationTimeoutId = setTimeout(() => {
+			pendingTerminationTimeoutId = null;
+			if (!resolved) {
+				requestAbort("terminate");
+			}
+		}, 2000);
+	};
+
+	const cancelPendingTermination = () => {
+		if (pendingTerminationTimeoutId) {
+			clearTimeout(pendingTerminationTimeoutId);
+			pendingTerminationTimeoutId = null;
+		}
 	};
 
 	// Handle abort signal
@@ -655,9 +667,10 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 					// Accumulate tokens for progress display
 					progress.tokens += getUsageTokens(messageUsage);
 				}
-				// If pending termination, now we have tokens - terminate
-				if (pendingTerminationController) {
-					pendingTerminationController.abort();
+				// If pending termination, now we have tokens - terminate immediately
+				if (pendingTerminationTimeoutId) {
+					cancelPendingTermination();
+					requestAbort("terminate");
 				}
 				break;
 			}
@@ -714,7 +727,6 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 	const done = await new Promise<Extract<SubagentWorkerResponse, { type: "done" }>>((resolve) => {
 		const cleanup = () => {
-			pendingTerminationController = null;
 			listenerController.abort();
 		};
 		finalize = (message) => {
@@ -723,10 +735,18 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			cleanup();
 			resolve(message);
 		};
+		const postMessageSafe = (message: unknown) => {
+			if (resolved || terminated) return;
+			try {
+				worker.postMessage(message);
+			} catch {
+				// Worker already terminated
+			}
+		};
 		const handleMCPCall = async (request: MCPToolCallRequest) => {
 			const mcpManager = options.mcpManager;
 			if (!mcpManager) {
-				worker.postMessage({
+				postMessageSafe({
 					type: "mcp_tool_result",
 					callId: request.callId,
 					error: "MCP not available",
@@ -743,13 +763,13 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 					})(),
 					request.timeoutMs,
 				);
-				worker.postMessage({
+				postMessageSafe({
 					type: "mcp_tool_result",
 					callId: request.callId,
 					result: { content: result.content ?? [], isError: result.isError },
 				});
 			} catch (error) {
-				worker.postMessage({
+				postMessageSafe({
 					type: "mcp_tool_result",
 					callId: request.callId,
 					error: error instanceof Error ? error.message : String(error),
@@ -767,7 +787,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 		const handlePythonCall = async (request: PythonToolCallRequest) => {
 			if (!pythonTool) {
-				worker.postMessage({
+				postMessageSafe({
 					type: "python_tool_result",
 					callId: request.callId,
 					error: "Python proxy not available",
@@ -785,7 +805,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 					request.params as { code: string; timeout?: number; workdir?: string; reset?: boolean },
 					combinedSignal,
 				);
-				worker.postMessage({
+				postMessageSafe({
 					type: "python_tool_result",
 					callId: request.callId,
 					result: { content: result.content ?? [], details: result.details },
@@ -797,7 +817,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 						: error instanceof Error
 							? error.message
 							: String(error);
-				worker.postMessage({
+				postMessageSafe({
 					type: "python_tool_result",
 					callId: request.callId,
 					error: message,
@@ -816,7 +836,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 		const handleLspCall = async (request: LspToolCallRequest) => {
 			if (!lspTool) {
-				worker.postMessage({
+				postMessageSafe({
 					type: "lsp_tool_result",
 					callId: request.callId,
 					error: "LSP proxy not available",
@@ -828,7 +848,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 					lspTool.execute(request.callId, request.params as LspParams, signal),
 					request.timeoutMs,
 				);
-				worker.postMessage({
+				postMessageSafe({
 					type: "lsp_tool_result",
 					callId: request.callId,
 					result: { content: result.content ?? [], details: result.details },
@@ -840,7 +860,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 						: error instanceof Error
 							? error.message
 							: String(error);
-				worker.postMessage({
+				postMessageSafe({
 					type: "lsp_tool_result",
 					callId: request.callId,
 					error: message,
@@ -881,10 +901,14 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				return;
 			}
 			if (message.type === "done") {
+				// Worker is exiting - mark as terminated to prevent calling terminate() on dead worker
+				terminated = true;
 				finalize?.(message);
 			}
 		};
 		const onError = (event: WorkerErrorEvent) => {
+			// Worker error likely means it's dead or dying
+			terminated = true;
 			finalize?.({
 				type: "done",
 				exitCode: 1,
@@ -893,6 +917,8 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			});
 		};
 		const onMessageError = () => {
+			// Message error may indicate worker is in bad state
+			terminated = true;
 			finalize?.({
 				type: "done",
 				exitCode: 1,
@@ -902,6 +928,8 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		};
 		const onClose = () => {
 			// Worker terminated unexpectedly (crashed or was killed without sending done)
+			// Mark as terminated since the worker is already dead - calling terminate() again would crash
+			terminated = true;
 			const abortMessage =
 				abortSent && abortReason === "signal"
 					? "Worker terminated after abort"
@@ -932,11 +960,19 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		}
 	});
 
-	// Cleanup
-	try {
-		worker.terminate();
-	} catch {
-		// Ignore termination errors
+	// Cleanup - cancel any pending timeouts first
+	if (terminationTimeoutId) {
+		clearTimeout(terminationTimeoutId);
+		terminationTimeoutId = null;
+	}
+	cancelPendingTermination();
+	if (!terminated) {
+		terminated = true;
+		try {
+			worker.terminate();
+		} catch {
+			// Ignore termination errors
+		}
 	}
 
 	let exitCode = done.exitCode;

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

@@ -15,7 +15,7 @@
 
 import type { AgentEvent, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Api, Model } from "@oh-my-pi/pi-ai";
-import { logger, untilAborted } from "@oh-my-pi/pi-utils";
+import { logger, postmortem, untilAborted } from "@oh-my-pi/pi-utils";
 import type { TSchema } from "@sinclair/typebox";
 import lspDescription from "../../../prompts/tools/lsp.md" with { type: "text" };
 import type { AgentSessionEvent } from "../../agent-session";
@@ -377,17 +377,29 @@ function createPythonProxyTool(): CustomTool<typeof pythonSchema> {
 		description: getPythonToolDescription(),
 		parameters: pythonSchema,
 		execute: async (_toolCallId, params, _onUpdate, _ctx, signal) => {
-			const timeoutMs = getPythonCallTimeoutMs(params as PythonToolParams);
-			const result = await callPythonToolViaParent(params as PythonToolParams, signal, timeoutMs);
-			return {
-				content:
-					result?.content?.map((c) =>
-						c.type === "text"
-							? { type: "text" as const, text: c.text ?? "" }
-							: { type: "text" as const, text: JSON.stringify(c) },
-					) ?? [],
-				details: result?.details as PythonToolDetails | undefined,
-			};
+			try {
+				const timeoutMs = getPythonCallTimeoutMs(params as PythonToolParams);
+				const result = await callPythonToolViaParent(params as PythonToolParams, signal, timeoutMs);
+				return {
+					content:
+						result?.content?.map((c) =>
+							c.type === "text"
+								? { type: "text" as const, text: c.text ?? "" }
+								: { type: "text" as const, text: JSON.stringify(c) },
+						) ?? [],
+					details: result?.details as PythonToolDetails | undefined,
+				};
+			} catch (error) {
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: `Python error: ${error instanceof Error ? error.message : String(error)}`,
+						},
+					],
+					details: { isError: true } as PythonToolDetails,
+				};
+			}
 		},
 	};
 }
@@ -780,10 +792,18 @@ function handleAbort(): void {
 	}
 }
 
-const reportFatal = (message: string): void => {
+const reportFatal = async (message: string): Promise<void> => {
+	// Run postmortem cleanup first to ensure child processes are killed
+	try {
+		await postmortem.cleanup();
+	} 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();
 		}
@@ -821,6 +841,16 @@ self.addEventListener("error", (event) => {
 self.addEventListener("unhandledrejection", (event) => {
 	const reason = event.reason;
 	const message = reason instanceof Error ? reason.stack || reason.message : String(reason);
+
+	// Avoid terminating active runs on tool-level errors that bubble as rejections.
+	if (activeRun) {
+		logger.error("Unhandled rejection in subagent worker", { error: message });
+		if ("preventDefault" in event && typeof event.preventDefault === "function") {
+			event.preventDefault();
+		}
+		return;
+	}
+
 	reportFatal(`Unhandled rejection: ${message}`);
 });
 

package/src/core/tools/web-fetch.ts

@@ -4,8 +4,8 @@ import * as path from "node:path";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
+import { ptree } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
-import { $ } from "bun";
 import { nanoid } from "nanoid";
 import { parse as parseHtml } from "node-html-parser";
 import { type Theme, theme } from "../../modes/interactive/theme/theme";
@@ -75,18 +75,58 @@ const CONVERTIBLE_EXTENSIONS = new Set([
  * Execute a command and return stdout
  */
 
+type WritableLike = {
+	write: (chunk: string | Uint8Array) => unknown;
+	flush?: () => unknown;
+	end?: () => unknown;
+};
+
+const textEncoder = new TextEncoder();
+
+async function writeStdin(handle: unknown, input: string | Buffer): Promise<void> {
+	if (!handle || typeof handle === "number") return;
+	if (typeof (handle as WritableStream<Uint8Array>).getWriter === "function") {
+		const writer = (handle as WritableStream<Uint8Array>).getWriter();
+		try {
+			const chunk = typeof input === "string" ? textEncoder.encode(input) : new Uint8Array(input);
+			await writer.write(chunk);
+		} finally {
+			await writer.close();
+		}
+		return;
+	}
+
+	const sink = handle as WritableLike;
+	sink.write(input);
+	if (sink.flush) sink.flush();
+	if (sink.end) sink.end();
+}
+
 async function exec(
 	cmd: string,
 	args: string[],
 	options?: { timeout?: number; input?: string | Buffer },
 ): Promise<{ stdout: string; stderr: string; ok: boolean }> {
-	void options;
-	const result = await $`${cmd} ${args}`.quiet().nothrow();
-	const decoder = new TextDecoder();
+	const proc = ptree.cspawn([cmd, ...args], {
+		stdin: options?.input ? "pipe" : null,
+		timeout: options?.timeout,
+	});
+
+	if (options?.input) {
+		await writeStdin(proc.stdin, options.input);
+	}
+
+	const [stdout, stderr] = await Promise.all([proc.stdout.text(), proc.stderr.text()]);
+	try {
+		await proc.exited;
+	} catch {
+		// Handle non-zero exit or timeout
+	}
+
 	return {
-		stdout: result.stdout ? decoder.decode(result.stdout) : "",
-		stderr: result.stderr ? decoder.decode(result.stderr) : "",
-		ok: result.exitCode === 0,
+		stdout,
+		stderr,
+		ok: proc.exitCode === 0,
 	};
 }
 

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(