@oh-my-pi/pi-coding-agent 13.5.7 → 13.6.0

package/src/task/isolation-backend.ts

@@ -0,0 +1,72 @@
+import { projfsOverlayProbe } from "@oh-my-pi/pi-natives";
+import { Snowflake } from "@oh-my-pi/pi-utils";
+import { cleanupProjfsOverlay, ensureProjfsOverlay, isProjfsUnavailableError } from "./worktree";
+
+export type TaskIsolationMode = "none" | "worktree" | "fuse-overlay" | "fuse-projfs";
+
+export interface IsolationBackendResolution {
+	effectiveIsolationMode: TaskIsolationMode;
+	warning: string;
+}
+
+export async function resolveIsolationBackendForTaskExecution(
+	requestedMode: TaskIsolationMode,
+	isIsolated: boolean,
+	repoRoot: string | null,
+	platform: NodeJS.Platform = process.platform,
+): Promise<IsolationBackendResolution> {
+	let effectiveIsolationMode = requestedMode;
+	let warning = "";
+	if (!(isIsolated && repoRoot)) {
+		return { effectiveIsolationMode, warning };
+	}
+
+	if (requestedMode === "fuse-overlay" && platform === "win32") {
+		effectiveIsolationMode = "worktree";
+		warning =
+			'<system-notification>fuse-overlay isolation is unavailable on Windows. Use task.isolation.mode = "fuse-projfs" for ProjFS. Falling back to worktree isolation.</system-notification>';
+		return { effectiveIsolationMode, warning };
+	}
+
+	if (requestedMode === "fuse-projfs" && platform !== "win32") {
+		effectiveIsolationMode = "worktree";
+		warning =
+			"<system-notification>fuse-projfs isolation is only available on Windows. Falling back to worktree isolation.</system-notification>";
+		return { effectiveIsolationMode, warning };
+	}
+
+	if (!(requestedMode === "fuse-projfs" && platform === "win32")) {
+		return { effectiveIsolationMode, warning };
+	}
+
+	const probe = projfsOverlayProbe();
+	if (!probe.available) {
+		effectiveIsolationMode = "worktree";
+		const reason = probe.reason ? ` Reason: ${probe.reason}` : "";
+		warning = `<system-notification>ProjFS is unavailable on this host. Falling back to worktree isolation.${reason}</system-notification>`;
+		return { effectiveIsolationMode, warning };
+	}
+
+	const probeIsolationId = `probe-${Snowflake.next()}`;
+	let probeIsolationDir: string | null = null;
+	try {
+		probeIsolationDir = await ensureProjfsOverlay(repoRoot, probeIsolationId);
+	} catch (err) {
+		if (isProjfsUnavailableError(err)) {
+			effectiveIsolationMode = "worktree";
+			const raw = err instanceof Error ? err.message : String(err);
+			const reason = raw.replace(/^PROJFS_UNAVAILABLE:\s*/, "");
+			const detail = reason ? ` Reason: ${reason}` : "";
+			warning = `<system-notification>ProjFS prerequisites are unavailable for this repository. Falling back to worktree isolation.${detail}</system-notification>`;
+		} else {
+			const message = err instanceof Error ? err.message : String(err);
+			throw new Error(`ProjFS isolation initialization failed. ${message}`);
+		}
+	} finally {
+		if (probeIsolationDir) {
+			await cleanupProjfsOverlay(probeIsolationDir);
+		}
+	}
+
+	return { effectiveIsolationMode, warning };
+}

package/src/task/render.ts

@@ -783,6 +783,11 @@ function renderAgentResult(result: SingleResult, isLast: boolean, expanded: bool
 
 	lines.push(...renderTaskSection(result.task, continuePrefix, expanded, theme));
 
+	if (aborted && result.abortReason) {
+		lines.push(
+			`${continuePrefix}${theme.fg("error", theme.status.aborted)} ${theme.fg("dim", truncateToWidth(replaceTabs(result.abortReason), 80))}`,
+		);
+	}
 	// Check for review result (submit_result with review schema + report_finding)
 	const completeData = result.extractedToolData?.submit_result as Array<{ data: unknown }> | undefined;
 	const reportFindingData = normalizeReportFindings(result.extractedToolData?.report_finding);
@@ -873,7 +878,7 @@ function renderAgentResult(result: SingleResult, isLast: boolean, expanded: bool
 	}
 
 	// Error message
-	if (result.error && (!success || mergeFailed)) {
+	if (result.error && (!success || mergeFailed) && (!aborted || result.error !== result.abortReason)) {
 		lines.push(`${continuePrefix}${theme.fg(mergeFailed ? "warning" : "error", truncateToWidth(result.error, 70))}`);
 	}
 

package/src/task/types.ts

@@ -169,6 +169,7 @@ export interface SingleResult {
 	modelOverride?: string | string[];
 	error?: string;
 	aborted?: boolean;
+	abortReason?: string;
 	/** Aggregated usage from the subprocess, accumulated incrementally from message_end events. */
 	usage?: Usage;
 	/** Output path for the task result */

package/src/task/worktree.ts

@@ -2,6 +2,7 @@ import type { Dirent } from "node:fs";
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import path from "node:path";
+import { projfsOverlayStart, projfsOverlayStop } from "@oh-my-pi/pi-natives";
 import { getWorktreeDir, isEnoent, logger, Snowflake } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
 
@@ -37,6 +38,17 @@ export async function getRepoRoot(cwd: string): Promise<string> {
 	return repoRoot;
 }
 
+const PROJFS_UNAVAILABLE_PREFIX = "PROJFS_UNAVAILABLE:";
+const GIT_NO_INDEX_NULL_PATH = process.platform === "win32" ? "NUL" : "/dev/null";
+
+export function isProjfsUnavailableError(err: unknown): boolean {
+	return err instanceof Error && err.message.includes(PROJFS_UNAVAILABLE_PREFIX);
+}
+
+export function getGitNoIndexNullPath(): string {
+	return GIT_NO_INDEX_NULL_PATH;
+}
+
 export async function ensureWorktree(baseCwd: string, id: string): Promise<string> {
 	const repoRoot = await getRepoRoot(baseCwd);
 	const encodedProject = getEncodedProjectName(repoRoot);
@@ -248,9 +260,10 @@ async function captureRepoDeltaPatch(repoDir: string, rb: RepoBaseline): Promise
 		const baselineUntracked = new Set(rb.untracked);
 		const newUntracked = currentUntracked.filter(entry => !baselineUntracked.has(entry));
 		if (newUntracked.length > 0) {
+			const nullPath = getGitNoIndexNullPath();
 			const untrackedDiffs = await Promise.all(
 				newUntracked.map(entry =>
-					$`git diff --binary --no-index /dev/null ${entry}`.cwd(repoDir).quiet().nothrow().text(),
+					$`git diff --binary --no-index ${nullPath} ${entry}`.cwd(repoDir).quiet().nothrow().text(),
 				),
 			);
 			parts.push(...untrackedDiffs.filter(d => d.trim()));
@@ -273,9 +286,10 @@ async function captureRepoDeltaPatch(repoDir: string, rb: RepoBaseline): Promise
 
 		if (newUntracked.length === 0) return diff;
 
+		const nullPath = getGitNoIndexNullPath();
 		const untrackedDiffs = await Promise.all(
 			newUntracked.map(entry =>
-				$`git diff --binary --no-index /dev/null ${entry}`.cwd(repoDir).quiet().nothrow().text(),
+				$`git diff --binary --no-index ${nullPath} ${entry}`.cwd(repoDir).quiet().nothrow().text(),
 			),
 		);
 		return `${diff}${diff && !diff.endsWith("\n") ? "\n" : ""}${untrackedDiffs.join("\n")}`;
@@ -371,10 +385,14 @@ export async function cleanupWorktree(dir: string): Promise<void> {
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
-// Fuse-overlay isolation
+// Fuse-overlay isolation (Unix)
 // ═══════════════════════════════════════════════════════════════════════════
 
 export async function ensureFuseOverlay(baseCwd: string, id: string): Promise<string> {
+	if (process.platform === "win32") {
+		throw new Error('fuse-overlay isolation is unsupported on Windows. Use task.isolation.mode = "fuse-projfs".');
+	}
+
 	const repoRoot = await getRepoRoot(baseCwd);
 	const encodedProject = getEncodedProjectName(repoRoot);
 	const baseDir = getWorktreeDir(encodedProject, id);
@@ -382,13 +400,13 @@ export async function ensureFuseOverlay(baseCwd: string, id: string): Promise<st
 	const workDir = path.join(baseDir, "work");
 	const mergedDir = path.join(baseDir, "merged");
 
-	// Clean up any stale mount at this path
+	// Clean up any stale mount at this path (linux only)
 	const fusermount = Bun.which("fusermount3") ?? Bun.which("fusermount");
 	if (fusermount) {
 		await $`${fusermount} -u ${mergedDir}`.quiet().nothrow();
 	}
-	await fs.rm(baseDir, { recursive: true, force: true });
 
+	await fs.rm(baseDir, { recursive: true, force: true });
 	await fs.mkdir(upperDir, { recursive: true });
 	await fs.mkdir(workDir, { recursive: true });
 	await fs.mkdir(mergedDir, { recursive: true });
@@ -426,6 +444,50 @@ export async function cleanupFuseOverlay(mergedDir: string): Promise<void> {
 	}
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// ProjFS isolation (Windows)
+// ═══════════════════════════════════════════════════════════════════════════
+
+export async function ensureProjfsOverlay(baseCwd: string, id: string): Promise<string> {
+	if (process.platform !== "win32") {
+		throw new Error("fuse-projfs isolation is only available on Windows.");
+	}
+
+	const repoRoot = await getRepoRoot(baseCwd);
+	const encodedProject = getEncodedProjectName(repoRoot);
+	const baseDir = getWorktreeDir(encodedProject, id);
+	const mergedDir = path.join(baseDir, "merged");
+
+	await fs.rm(baseDir, { recursive: true, force: true });
+	await fs.mkdir(mergedDir, { recursive: true });
+	try {
+		projfsOverlayStart(repoRoot, mergedDir);
+		return mergedDir;
+	} catch (err) {
+		await fs.rm(baseDir, { recursive: true, force: true });
+		throw err;
+	}
+}
+
+export async function cleanupProjfsOverlay(mergedDir: string): Promise<void> {
+	try {
+		if (process.platform === "win32") {
+			try {
+				projfsOverlayStop(mergedDir);
+			} catch (err) {
+				logger.warn("ProjFS overlay stop failed during cleanup", {
+					mergedDir,
+					error: err instanceof Error ? err.message : String(err),
+				});
+			}
+		}
+	} finally {
+		// baseDir is the parent of the merged directory
+		const baseDir = path.dirname(mergedDir);
+		await fs.rm(baseDir, { recursive: true, force: true });
+	}
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Branch-mode isolation
 // ═══════════════════════════════════════════════════════════════════════════

package/src/tools/index.ts

@@ -129,7 +129,7 @@ export interface ToolSession {
 	modelRegistry?: import("../config/model-registry").ModelRegistry;
 	/** MCP manager for proxying MCP calls through parent */
 	mcpManager?: import("../mcp/manager").MCPManager;
-	/** Internal URL router for agent:// and skill:// URLs */
+	/** Internal URL router for protocols like agent://, skill://, and mcp:// */
 	internalRouter?: InternalUrlRouter;
 	/** Agent output manager for unique agent:// IDs across task invocations */
 	agentOutputManager?: AgentOutputManager;

package/src/tools/path-utils.ts

@@ -56,7 +56,8 @@ function normalizeAtPrefix(filePath: string): string {
 		withoutAt.startsWith("artifact://") ||
 		withoutAt.startsWith("skill://") ||
 		withoutAt.startsWith("rule://") ||
-		withoutAt.startsWith("local://")
+		withoutAt.startsWith("local://") ||
+		withoutAt.startsWith("mcp://")
 	) {
 		return withoutAt;
 	}

package/src/tools/read.ts

@@ -582,7 +582,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 
 		const displayMode = resolveFileDisplayMode(this.session);
 
-		// Handle internal URLs (agent://, artifact://, memory://, skill://, rule://, local://)
+		// Handle internal URLs (agent://, artifact://, memory://, skill://, rule://, local://, mcp://)
 		const internalRouter = this.session.internalRouter;
 		if (internalRouter?.canHandle(readPath)) {
 			return this.#handleInternalUrl(readPath, offset, limit);
@@ -841,7 +841,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 	}
 
 	/**
-	 * Handle internal URLs (agent://, artifact://, memory://, skill://, rule://, local://).
+	 * Handle internal URLs (agent://, artifact://, memory://, skill://, rule://, local://, mcp://).
 	 * Supports pagination via offset/limit but rejects them when query extraction is used.
 	 */
 	async #handleInternalUrl(url: string, offset?: number, limit?: number): Promise<AgentToolResult<ReadToolDetails>> {
@@ -859,13 +859,9 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		const scheme = parsed.protocol.replace(/:$/, "").toLowerCase();
 		const hasPathExtraction = parsed.pathname && parsed.pathname !== "/" && parsed.pathname !== "";
 		const queryParam = parsed.searchParams.get("q");
-		const hasQueryExtraction = queryParam !== null && queryParam !== "";
+		const hasQueryExtraction = scheme === "agent" && queryParam !== null && queryParam !== "";
 		const hasExtraction = scheme === "agent" && (hasPathExtraction || hasQueryExtraction);
 
-		if (scheme !== "agent" && hasQueryExtraction) {
-			throw new ToolError("Only agent:// URLs support ?q= query extraction");
-		}
-
 		// Reject offset/limit with query extraction
 		if (hasExtraction && (offset !== undefined || limit !== undefined)) {
 			throw new ToolError("Cannot combine query extraction with offset/limit");

package/src/utils/open.ts

@@ -13,7 +13,7 @@ export function openPath(urlOrPath: string): void {
 			break;
 	}
 	try {
-		Bun.spawn(cmd, { stdout: "ignore", stderr: "ignore", windowsHide: true });
+		Bun.spawn(cmd, { stdin: "ignore", stdout: "ignore", stderr: "ignore" });
 	} catch {
 		// Best-effort: browser opening is non-critical
 	}