@oh-my-pi/pi-coding-agent 16.1.14 → 16.1.16

package/src/eval/__tests__/agent-bridge.test.ts

@@ -1,4 +1,5 @@
 import { afterAll, afterEach, describe, expect, it, vi } from "bun:test";
+import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { TempDir } from "@oh-my-pi/pi-utils";
 import { Settings } from "../../config/settings";
@@ -6,6 +7,7 @@ import type { PlanModeState } from "../../plan-mode/state";
 import * as taskDiscovery from "../../task/discovery";
 import type { ExecutorOptions } from "../../task/executor";
 import * as taskExecutor from "../../task/executor";
+import * as isolationRunner from "../../task/isolation-runner";
 import { AgentOutputManager } from "../../task/output-manager";
 import type { AgentDefinition, AgentProgress, SingleResult } from "../../task/types";
 import type { ToolSession } from "../../tools";
@@ -154,7 +156,7 @@ describe("runEvalAgent", () => {
 		vi.restoreAllMocks();
 	});
 
-	it("resolves the default task agent and agentType overrides", async () => {
+	it("resolves the default task agent and agent overrides", async () => {
 		mockAgents();
 		const runSpy = vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options =>
 			singleResult(options, {
@@ -164,7 +166,7 @@ describe("runEvalAgent", () => {
 		const session = makeSession();
 
 		const defaultResult = await runEvalAgent({ prompt: "hello" }, { session });
-		const overrideResult = await runEvalAgent({ prompt: "hello", agentType: "reviewer" }, { session });
+		const overrideResult = await runEvalAgent({ prompt: "hello", agent: "reviewer" }, { session });
 
 		expect(defaultResult.text).toBe("task");
 		expect(overrideResult.text).toBe("reviewer");
@@ -176,7 +178,7 @@ describe("runEvalAgent", () => {
 		mockAgents([taskAgent]);
 		vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => singleResult(options));
 
-		await expect(runEvalAgent({ prompt: "hello", agentType: "missing" }, { session: makeSession() })).rejects.toThrow(
+		await expect(runEvalAgent({ prompt: "hello", agent: "missing" }, { session: makeSession() })).rejects.toThrow(
 			'Unknown agent "missing"',
 		);
 	});
@@ -767,3 +769,460 @@ describe("agent() through eval runtimes", () => {
 		expect(idle.signal.aborted).toBe(false);
 	});
 });
+
+describe("runEvalAgent isolation", () => {
+	afterEach(() => {
+		vi.restoreAllMocks();
+	});
+
+	function isolatedSession(overrides: Partial<Parameters<typeof Settings.isolated>[0]> = {}): ToolSession {
+		return makeSession({
+			settings: Settings.isolated({
+				"async.enabled": false,
+				"task.isolation.mode": "auto",
+				"task.isolation.merge": "patch",
+				...overrides,
+			}),
+		});
+	}
+
+	function mockIsolationContext(): { repoRoot: string } {
+		const repoRoot = "/repo-root";
+		vi.spyOn(isolationRunner, "prepareIsolationContext").mockResolvedValue({
+			repoRoot,
+			baseline: {
+				root: { repoRoot, headCommit: "HEAD", staged: "", unstaged: "", untracked: [], untrackedPatch: "" },
+				nested: [],
+			},
+		});
+		return { repoRoot };
+	}
+
+	it("rejects isolated=true when task.isolation.mode is 'none'", async () => {
+		mockAgents();
+		const runSpy = vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => singleResult(options));
+		const prepSpy = vi.spyOn(isolationRunner, "prepareIsolationContext");
+
+		const session = makeSession(); // default settings: isolation.mode === "none"
+
+		await expect(runEvalAgent({ prompt: "do work", isolated: true }, { session })).rejects.toThrow(
+			'task.isolation.mode to be set; current mode is "none"',
+		);
+		expect(prepSpy).not.toHaveBeenCalled();
+		expect(runSpy).not.toHaveBeenCalled();
+	});
+
+	it("stays non-isolated by default even when task.isolation.mode is set; isolated=true opts in", async () => {
+		mockAgents();
+		mockIsolationContext();
+		const isolatedSpy = vi
+			.spyOn(isolationRunner, "runIsolatedSubprocess")
+			.mockImplementation(async opts => singleResult(opts.baseOptions, { output: "isolated-run" }));
+		const plainSpy = vi
+			.spyOn(taskExecutor, "runSubprocess")
+			.mockImplementation(async options => singleResult(options, { output: "plain-run" }));
+		const mergeSpy = vi.spyOn(isolationRunner, "mergeIsolatedChanges").mockResolvedValue({
+			summary: "",
+			changesApplied: true,
+			hadAnyChanges: false,
+			mergedBranchForNestedPatches: false,
+		});
+
+		// Default (no isolated arg) — stays non-isolated even when settings allow it.
+		const defaultResult = await runEvalAgent({ prompt: "default" }, { session: isolatedSession() });
+		expect(plainSpy).toHaveBeenCalledTimes(1);
+		expect(isolatedSpy).not.toHaveBeenCalled();
+		expect(defaultResult.details.isolated).toBeUndefined();
+		expect(defaultResult.details.changesApplied).toBeUndefined();
+		expect(mergeSpy).not.toHaveBeenCalled();
+
+		// Explicit isolated=true — opt-in turns it on and surfaces merge details.
+		const explicitOn = await runEvalAgent({ prompt: "on", isolated: true }, { session: isolatedSession() });
+		expect(isolatedSpy).toHaveBeenCalledTimes(1);
+		expect(plainSpy).toHaveBeenCalledTimes(1);
+		expect(explicitOn.details.isolated).toBe(true);
+		expect(mergeSpy).toHaveBeenCalledTimes(1);
+	});
+
+	it("preserves temp artifacts for non-isolated handle outputs", async () => {
+		mockAgents();
+		const rmSpy = vi.spyOn(fs, "rm").mockResolvedValue(undefined);
+		vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => singleResult(options));
+
+		await runEvalAgent({ prompt: "plain handle", handle: true }, { session: makeSession() });
+
+		const removedArtifactsDir = rmSpy.mock.calls.some(
+			([target]) => typeof target === "string" && target.includes("omp-eval-agent-"),
+		);
+		expect(removedArtifactsDir).toBe(false);
+	});
+
+	it("forwards merge=false as patch mode and passes the worktree cwd through baseOptions", async () => {
+		mockAgents();
+		const { repoRoot } = mockIsolationContext();
+		const isolatedSpy = vi.spyOn(isolationRunner, "runIsolatedSubprocess").mockImplementation(async opts =>
+			singleResult(opts.baseOptions, {
+				output: "isolated-run",
+				patchPath: `/artifacts/${opts.agentId}.patch`,
+			}),
+		);
+		vi.spyOn(isolationRunner, "mergeIsolatedChanges").mockResolvedValue({
+			summary: "\n\nApplied patches: yes",
+			changesApplied: true,
+			hadAnyChanges: true,
+			mergedBranchForNestedPatches: false,
+		});
+
+		// Branch is the configured merge mode, but `merge: false` must demote to patch.
+		const session = isolatedSession({ "task.isolation.merge": "branch" });
+		const result = await runEvalAgent({ prompt: "migration", isolated: true, merge: false }, { session });
+
+		expect(isolatedSpy).toHaveBeenCalledTimes(1);
+		const isolatedCall = isolatedSpy.mock.calls[0]?.[0];
+		if (!isolatedCall) throw new Error("runIsolatedSubprocess was not called");
+		expect(isolatedCall.mergeMode).toBe("patch");
+		expect(isolatedCall.baseOptions.cwd).toBe(session.cwd);
+		expect(isolatedCall.context.repoRoot).toBe(repoRoot);
+		expect(result.details.patchPath).toMatch(/\.patch$/);
+		expect(result.text).toContain("Applied patches: yes");
+	});
+
+	it("keeps the timeout paused through isolation merge/apply so the cell can't abort mid-cherry-pick", async () => {
+		mockAgents();
+		mockIsolationContext();
+		const ops: string[] = [];
+		vi.spyOn(isolationRunner, "runIsolatedSubprocess").mockImplementation(async opts => {
+			ops.push("subprocess");
+			return singleResult(opts.baseOptions, { output: "done", patchPath: `/artifacts/${opts.agentId}.patch` });
+		});
+		vi.spyOn(isolationRunner, "mergeIsolatedChanges").mockImplementation(async () => {
+			ops.push("merge");
+			return {
+				summary: "\n\nMerged",
+				changesApplied: true,
+				hadAnyChanges: true,
+				mergedBranchForNestedPatches: false,
+			};
+		});
+
+		await runEvalAgent(
+			{ prompt: "migration", isolated: true },
+			{
+				session: isolatedSession(),
+				emitStatus: event => {
+					if (event.op === EVAL_TIMEOUT_PAUSE_OP || event.op === EVAL_TIMEOUT_RESUME_OP) ops.push(event.op);
+				},
+			},
+		);
+
+		const pauseIdx = ops.indexOf(EVAL_TIMEOUT_PAUSE_OP);
+		const resumeIdx = ops.lastIndexOf(EVAL_TIMEOUT_RESUME_OP);
+		const mergeIdx = ops.indexOf("merge");
+		expect(pauseIdx).toBeGreaterThanOrEqual(0);
+		expect(resumeIdx).toBeGreaterThan(pauseIdx);
+		expect(mergeIdx).toBeGreaterThan(pauseIdx);
+		expect(mergeIdx).toBeLessThan(resumeIdx);
+	});
+
+	it("keeps the timeout paused through isolation baseline capture", async () => {
+		mockAgents();
+		const ops: string[] = [];
+		vi.spyOn(isolationRunner, "prepareIsolationContext").mockImplementation(async () => {
+			ops.push("prepare");
+			return {
+				repoRoot: "/repo-root",
+				baseline: {
+					root: {
+						repoRoot: "/repo-root",
+						headCommit: "HEAD",
+						staged: "",
+						unstaged: "",
+						untracked: [],
+						untrackedPatch: "",
+					},
+					nested: [],
+				},
+			};
+		});
+		vi.spyOn(isolationRunner, "runIsolatedSubprocess").mockImplementation(async opts =>
+			singleResult(opts.baseOptions, { output: "done", patchPath: `/artifacts/${opts.agentId}.patch` }),
+		);
+		vi.spyOn(isolationRunner, "mergeIsolatedChanges").mockResolvedValue({
+			summary: "\n\nMerged",
+			changesApplied: true,
+			hadAnyChanges: true,
+			mergedBranchForNestedPatches: false,
+		});
+
+		await runEvalAgent(
+			{ prompt: "scout", isolated: true },
+			{
+				session: isolatedSession(),
+				emitStatus: event => {
+					if (event.op === EVAL_TIMEOUT_PAUSE_OP || event.op === EVAL_TIMEOUT_RESUME_OP) ops.push(event.op);
+				},
+			},
+		);
+
+		const pauseIdx = ops.indexOf(EVAL_TIMEOUT_PAUSE_OP);
+		const resumeIdx = ops.lastIndexOf(EVAL_TIMEOUT_RESUME_OP);
+		const prepareIdx = ops.indexOf("prepare");
+		expect(pauseIdx).toBeGreaterThanOrEqual(0);
+		expect(prepareIdx).toBeGreaterThan(pauseIdx);
+		expect(prepareIdx).toBeLessThan(resumeIdx);
+	});
+
+	it("keeps schema-backed isolated output parseable by moving merge text into details", async () => {
+		mockAgents();
+		mockIsolationContext();
+		const structuredOutput = JSON.stringify({ status: "ok" });
+		vi.spyOn(isolationRunner, "runIsolatedSubprocess").mockImplementation(async opts =>
+			singleResult(opts.baseOptions, {
+				output: structuredOutput,
+				patchPath: `/artifacts/${opts.agentId}.patch`,
+			}),
+		);
+		vi.spyOn(isolationRunner, "mergeIsolatedChanges").mockResolvedValue({
+			summary: "\n\nNo changes to apply.",
+			changesApplied: true,
+			hadAnyChanges: false,
+			mergedBranchForNestedPatches: false,
+		});
+
+		const result = await runEvalAgent(
+			{
+				prompt: "structured",
+				isolated: true,
+				schema: {
+					type: "object",
+					properties: { status: { type: "string" } },
+					required: ["status"],
+				},
+			},
+			{ session: isolatedSession() },
+		);
+
+		expect(JSON.parse(result.text)).toEqual({ status: "ok" });
+		expect(result.text).toBe(structuredOutput);
+		expect(result.details.isolationSummary).toBe("No changes to apply.");
+	});
+
+	it("throws when an isolated apply fails so schema callers cannot mistake it for success", async () => {
+		mockAgents();
+		mockIsolationContext();
+		const structuredOutput = JSON.stringify({ status: "ok" });
+		vi.spyOn(isolationRunner, "runIsolatedSubprocess").mockImplementation(async opts =>
+			singleResult(opts.baseOptions, {
+				output: structuredOutput,
+				patchPath: `/artifacts/${opts.agentId}.patch`,
+			}),
+		);
+		vi.spyOn(isolationRunner, "mergeIsolatedChanges").mockResolvedValue({
+			summary: "\n\n<system-notification>Patch apply failed: conflict in foo.ts</system-notification>",
+			changesApplied: false,
+			hadAnyChanges: false,
+			mergedBranchForNestedPatches: false,
+		});
+
+		await expect(
+			runEvalAgent(
+				{
+					prompt: "structured",
+					isolated: true,
+					schema: {
+						type: "object",
+						properties: { status: { type: "string" } },
+						required: ["status"],
+					},
+				},
+				{ session: isolatedSession() },
+			),
+		).rejects.toThrow(/isolated apply failed.*Patch apply failed.*Captured patch preserved at \/artifacts\//s);
+	});
+
+	it("throws on apply failure for non-schema callers too instead of burying the warning in text", async () => {
+		mockAgents();
+		mockIsolationContext();
+		vi.spyOn(isolationRunner, "runIsolatedSubprocess").mockImplementation(async opts =>
+			singleResult(opts.baseOptions, {
+				output: "ran",
+				branchName: `omp/task/${opts.agentId}`,
+			}),
+		);
+		vi.spyOn(isolationRunner, "mergeIsolatedChanges").mockResolvedValue({
+			summary: "\n\n<system-notification>Branch merge failed: omp/task/x.\nConflict: foo.ts</system-notification>",
+			changesApplied: false,
+			hadAnyChanges: false,
+			mergedBranchForNestedPatches: false,
+		});
+
+		const session = isolatedSession({ "task.isolation.merge": "branch" });
+		await expect(runEvalAgent({ prompt: "scout", isolated: true }, { session })).rejects.toThrow(
+			/isolated apply failed.*Branch merge failed.*Captured branch preserved as omp\/task\//s,
+		);
+	});
+
+	it("persists captured nested patches to a recoverable file before throwing on apply failure", async () => {
+		mockAgents();
+		mockIsolationContext();
+		const nestedPatch = "diff --git a/file b/file\n";
+		vi.spyOn(isolationRunner, "runIsolatedSubprocess").mockImplementation(async opts =>
+			singleResult(opts.baseOptions, {
+				output: "ran",
+				patchPath: `/artifacts/${opts.agentId}.patch`,
+				nestedPatches: [{ relativePath: "sub/nested", patch: nestedPatch }],
+			}),
+		);
+		vi.spyOn(isolationRunner, "mergeIsolatedChanges").mockResolvedValue({
+			summary: "\n\n<system-notification>Patch apply failed: conflict in foo.ts</system-notification>",
+			changesApplied: false,
+			hadAnyChanges: false,
+			mergedBranchForNestedPatches: false,
+		});
+
+		let caught: Error | undefined;
+		try {
+			await runEvalAgent({ prompt: "scout", isolated: true }, { session: isolatedSession() });
+		} catch (err) {
+			caught = err as Error;
+		}
+		expect(caught).toBeDefined();
+		const match = caught?.message.match(/(\/[^\s,]+?\.nested-0-sub_nested\.patch)/);
+		expect(match).not.toBeNull();
+		const persistedPath = match?.[1];
+		expect(persistedPath).toBeDefined();
+		const contents = await fs.readFile(persistedPath!, "utf-8");
+		expect(contents).toBe(nestedPatch);
+		await fs.rm(path.dirname(persistedPath!), { recursive: true, force: true });
+	});
+
+	it("skips the merge phase when apply=false and surfaces the patch artifact instead", async () => {
+		mockAgents();
+		mockIsolationContext();
+		vi.spyOn(isolationRunner, "runIsolatedSubprocess").mockImplementation(async opts =>
+			singleResult(opts.baseOptions, {
+				output: "captured",
+				patchPath: "/artifacts/captured.patch",
+			}),
+		);
+		const mergeSpy = vi.spyOn(isolationRunner, "mergeIsolatedChanges");
+
+		const result = await runEvalAgent(
+			{ prompt: "scout", isolated: true, apply: false },
+			{ session: isolatedSession() },
+		);
+
+		expect(mergeSpy).not.toHaveBeenCalled();
+		expect(result.details.isolated).toBe(true);
+		expect(result.details.changesApplied).toBeNull();
+		expect(result.details.patchPath).toBe("/artifacts/captured.patch");
+		expect(result.text).toContain("/artifacts/captured.patch");
+		expect(result.text).toContain("apply=false");
+	});
+
+	it("surfaces a captured branch name when apply=false and the run used branch mode", async () => {
+		mockAgents();
+		mockIsolationContext();
+		vi.spyOn(isolationRunner, "runIsolatedSubprocess").mockImplementation(async opts =>
+			singleResult(opts.baseOptions, {
+				output: "branched",
+				branchName: `omp/task/${opts.agentId}`,
+			}),
+		);
+		const mergeSpy = vi.spyOn(isolationRunner, "mergeIsolatedChanges");
+
+		const session = isolatedSession({ "task.isolation.merge": "branch" });
+		const result = await runEvalAgent({ prompt: "scout", isolated: true, apply: false }, { session });
+
+		expect(mergeSpy).not.toHaveBeenCalled();
+		expect(result.details.branchName).toMatch(/^omp\/task\//);
+		expect(result.text).toContain("omp/task/");
+		expect(result.text).toContain("apply=false");
+	});
+
+	it("surfaces nested patches when apply=false captured branch-mode nested-only changes", async () => {
+		mockAgents();
+		mockIsolationContext();
+		vi.spyOn(isolationRunner, "runIsolatedSubprocess").mockImplementation(async opts =>
+			singleResult(opts.baseOptions, {
+				output: "nested-only",
+				nestedPatches: [{ relativePath: "nested", patch: "diff --git a/file b/file\n" }],
+			}),
+		);
+		const mergeSpy = vi.spyOn(isolationRunner, "mergeIsolatedChanges");
+
+		const session = isolatedSession({ "task.isolation.merge": "branch" });
+		const result = await runEvalAgent({ prompt: "scout", isolated: true, apply: false }, { session });
+
+		expect(mergeSpy).not.toHaveBeenCalled();
+		expect(result.details.branchName).toBeUndefined();
+		expect(result.details.patchPath).toBeUndefined();
+		expect(result.details.nestedPatches).toEqual([{ relativePath: "nested", patch: "diff --git a/file b/file\n" }]);
+		expect(result.text).toContain("nested repository");
+		expect(result.text).toContain("apply=false");
+	});
+
+	it("preserves the temp artifacts dir when apply=false so details.patchPath remains valid", async () => {
+		mockAgents();
+		mockIsolationContext();
+		const rmSpy = vi.spyOn(fs, "rm").mockResolvedValue(undefined);
+		vi.spyOn(isolationRunner, "runIsolatedSubprocess").mockImplementation(async opts =>
+			singleResult(opts.baseOptions, { output: "captured", patchPath: `/artifacts/${opts.agentId}.patch` }),
+		);
+
+		const result = await runEvalAgent(
+			{ prompt: "scout", isolated: true, apply: false },
+			{ session: isolatedSession() },
+		);
+
+		expect(result.details.patchPath).toMatch(/\.patch$/);
+		const removedArtifactsDir = rmSpy.mock.calls.some(
+			([target]) => typeof target === "string" && target.includes("omp-eval-agent-"),
+		);
+		expect(removedArtifactsDir).toBe(false);
+	});
+
+	it("still cleans the temp artifacts dir when apply succeeds", async () => {
+		mockAgents();
+		mockIsolationContext();
+		const rmSpy = vi.spyOn(fs, "rm").mockResolvedValue(undefined);
+		vi.spyOn(isolationRunner, "runIsolatedSubprocess").mockImplementation(async opts =>
+			singleResult(opts.baseOptions, { output: "captured", patchPath: `/artifacts/${opts.agentId}.patch` }),
+		);
+		vi.spyOn(isolationRunner, "mergeIsolatedChanges").mockResolvedValue({
+			summary: "\n\nApplied",
+			changesApplied: true,
+			hadAnyChanges: true,
+			mergedBranchForNestedPatches: false,
+		});
+
+		await runEvalAgent({ prompt: "scout", isolated: true }, { session: isolatedSession() });
+
+		const removedArtifactsDir = rmSpy.mock.calls.some(
+			([target]) => typeof target === "string" && target.includes("omp-eval-agent-"),
+		);
+		expect(removedArtifactsDir).toBe(true);
+	});
+
+	it("preserves the temp artifacts dir after a successful apply when handle is requested", async () => {
+		mockAgents();
+		mockIsolationContext();
+		const rmSpy = vi.spyOn(fs, "rm").mockResolvedValue(undefined);
+		vi.spyOn(isolationRunner, "runIsolatedSubprocess").mockImplementation(async opts =>
+			singleResult(opts.baseOptions, { output: "captured", patchPath: `/artifacts/${opts.agentId}.patch` }),
+		);
+		vi.spyOn(isolationRunner, "mergeIsolatedChanges").mockResolvedValue({
+			summary: "\n\nApplied",
+			changesApplied: true,
+			hadAnyChanges: true,
+			mergedBranchForNestedPatches: false,
+		});
+
+		await runEvalAgent({ prompt: "scout", isolated: true, handle: true }, { session: isolatedSession() });
+
+		const removedArtifactsDir = rmSpy.mock.calls.some(
+			([target]) => typeof target === "string" && target.includes("omp-eval-agent-"),
+		);
+		expect(removedArtifactsDir).toBe(false);
+	});
+});

package/src/eval/__tests__/helpers-local-roots.test.ts

@@ -4,7 +4,7 @@ import { TempDir } from "@oh-my-pi/pi-utils/temp";
 import { createHelpers, type HelperContext } from "../js/shared/helpers";
 
 /**
- * The eval helpers (`read`/`write`/`append`) must substitute injected on-disk
+ * The eval helpers (`read`/`write`) must substitute injected on-disk
  * roots for internal-URL schemes. Without it, `write("local://x.md")` hits a
  * stdlib `path.resolve` that collapses `local://` to `local:/`, creating a junk
  * `local:` directory under the cwd instead of landing where `read local://x.md`
@@ -20,7 +20,7 @@ function makeCtx(cwd: string, roots: Record<string, string>): HelperContext {
 }
 
 describe("eval js helpers internal-url resolution", () => {
-	it("writes, reads, and appends local:// under the injected root", async () => {
+	it("writes and reads local:// under the injected root", async () => {
 		using tmp = TempDir.createSync("@eval-helpers-local-");
 		const root = path.join(tmp.path(), "local");
 		const helpers = createHelpers(makeCtx(tmp.path(), { local: root }));
@@ -30,9 +30,6 @@ describe("eval js helpers internal-url resolution", () => {
 		expect(await Bun.file(written).text()).toBe("hello");
 		expect(await helpers.read("local://notes/merge-map.md")).toBe("hello");
 
-		await helpers.append("local://notes/merge-map.md", " world");
-		expect(await helpers.read("local://notes/merge-map.md")).toBe("hello world");
-
 		// Regression: no literal `local:` directory created under the cwd.
 		expect(await Bun.file(path.join(tmp.path(), "local:")).exists()).toBe(false);
 		expect(await Bun.file(path.join(tmp.path(), "local:", "notes", "merge-map.md")).exists()).toBe(false);

package/src/eval/__tests__/julia-prelude.test.ts

@@ -11,35 +11,6 @@ describe.skipIf(!HAS_JULIA)("eval Julia prelude helpers", () => {
 		await disposeJuliaKernelSessionsByOwner(OWNER_ID);
 	});
 
-	it("supports tree keyword options and unified diff", async () => {
-		using tempDir = TempDir.createSync("@omp-eval-julia-helpers-");
-		await Bun.write(path.join(tempDir.path(), "a.txt"), "same\nold\n");
-		await Bun.write(path.join(tempDir.path(), "b.txt"), "same\nnew\n");
-		await Bun.write(path.join(tempDir.path(), "dir", "child.txt"), "child");
-
-		const result = await executeJulia(
-			`
-d = diff("a.txt", "b.txt")
-println("DIFF_DELETE=", occursin("-old", d))
-println("DIFF_ADD=", occursin("+new", d))
-t = tree(".", max_depth=2)
-println("TREE_CHILD=", occursin("child.txt", t))
-nothing
-`,
-			{
-				cwd: tempDir.path(),
-				sessionId: `julia-prelude-diff:${crypto.randomUUID()}`,
-				kernelOwnerId: OWNER_ID,
-				reset: true,
-			},
-		);
-
-		expect(result.exitCode).toBe(0);
-		expect(result.output).toContain("DIFF_DELETE=true");
-		expect(result.output).toContain("DIFF_ADD=true");
-		expect(result.output).toContain("TREE_CHILD=true");
-	});
-
 	it("supports output ranges, JSON queries, metadata, and ANSI stripping", async () => {
 		using tempDir = TempDir.createSync("@omp-eval-julia-output-");
 		const artifactsDir = path.join(tempDir.path(), "session-artifacts");
@@ -73,5 +44,5 @@ nothing
 		expect(result.output).toContain("STRIPPED=red");
 		expect(result.output).toContain("META=alpha:true");
 		expect(result.output).toContain("MULTI=2:alpha:json");
-	});
+	}, 30_000);
 });

package/src/eval/__tests__/prelude-agent.test.ts

@@ -3,7 +3,7 @@ import * as vm from "node:vm";
 import { JAVASCRIPT_PRELUDE_SOURCE } from "../js/shared/prelude";
 
 /**
- * The eval `agent()` helper grows a `returnHandle` option that turns its bare
+ * The eval `agent()` helper grows a `handle` option that turns its bare
  * text result into a DAG node dict carrying the spawned agent's recoverable
  * `agent://<id>` handle, so a downstream `pipeline`/`parallel` stage can wire
  * the transcript by reference instead of re-inlining it. These lock the node
@@ -23,15 +23,18 @@ function loadPrelude(callTool: (name: string, args: unknown) => Promise<unknown>
 
 type AgentHelper = (prompt: string, opts?: Record<string, unknown>) => Promise<unknown>;
 
-describe("eval js agent() returnHandle", () => {
-	it("returns a DAG node carrying the agent:// handle when returnHandle is set", async () => {
+describe("eval js agent() handle", () => {
+	it("returns a DAG node carrying the agent:// handle when handle is set", async () => {
 		let seenName: string | undefined;
-		const sandbox = loadPrelude(async name => {
+		let seenArgs: Record<string, unknown> | undefined;
+		const sandbox = loadPrelude(async (name, args) => {
 			seenName = name;
+			seenArgs = args as Record<string, unknown>;
 			return { text: "hello world", details: { agent: "task", id: "abc123", model: "m", structured: false } };
 		});
-		const node = await (sandbox.agent as AgentHelper)("say hi", { returnHandle: true });
+		const node = await (sandbox.agent as AgentHelper)("say hi", { handle: true });
 		expect(seenName).toBe("__agent__");
+		expect(seenArgs?.handle).toBe(true);
 		expect(node).toEqual({
 			text: "hello world",
 			output: "hello world",
@@ -50,7 +53,7 @@ describe("eval js agent() returnHandle", () => {
 		expect(out).toBe("hello world");
 	});
 
-	it("carries the parsed object under data when schema and returnHandle combine", async () => {
+	it("carries the parsed object under data when schema and handle combine", async () => {
 		const payload = JSON.stringify({ k: 1 });
 		const sandbox = loadPrelude(async () => ({
 			text: payload,
@@ -58,7 +61,7 @@ describe("eval js agent() returnHandle", () => {
 		}));
 		const node = (await (sandbox.agent as AgentHelper)("emit", {
 			schema: { type: "object" },
-			returnHandle: true,
+			handle: true,
 		})) as Record<string, unknown>;
 		expect(node.handle).toBe("agent://id-9");
 		expect(node.data).toEqual({ k: 1 });
@@ -67,7 +70,38 @@ describe("eval js agent() returnHandle", () => {
 
 	it("falls back to a null handle without throwing when the bridge omits details", async () => {
 		const sandbox = loadPrelude(async () => ({ text: "lonely" }));
-		const node = await (sandbox.agent as AgentHelper)("x", { returnHandle: true });
+		const node = await (sandbox.agent as AgentHelper)("x", { handle: true });
 		expect(node).toEqual({ text: "lonely", output: "lonely", handle: null, id: null, agent: null });
 	});
+
+	it("exposes patchPath/branchName/nestedPatches/changesApplied/isolated/isolationSummary on the handle", async () => {
+		const payload = JSON.stringify({ ok: true });
+		const sandbox = loadPrelude(async () => ({
+			text: payload,
+			details: {
+				agent: "task",
+				id: "iso-1",
+				structured: true,
+				isolated: true,
+				patchPath: "/artifacts/iso-1.patch",
+				changesApplied: null,
+				nestedPatches: [{ relativePath: "nested", patch: "diff --git a/file b/file\n" }],
+				isolationSummary: "Isolation: changes captured at `/artifacts/iso-1.patch` (apply=false). Not applied.",
+			},
+		}));
+		const node = (await (sandbox.agent as AgentHelper)("scout", {
+			schema: { type: "object" },
+			isolated: true,
+			apply: false,
+			handle: true,
+		})) as Record<string, unknown>;
+		expect(node.handle).toBe("agent://iso-1");
+		expect(node.data).toEqual({ ok: true });
+		expect(node.isolated).toBe(true);
+		expect(node.patchPath).toBe("/artifacts/iso-1.patch");
+		expect(node.nestedPatches).toEqual([{ relativePath: "nested", patch: "diff --git a/file b/file\n" }]);
+		expect(node.changesApplied).toBeNull();
+		expect(node.isolationSummary).toContain("/artifacts/iso-1.patch");
+		expect("branchName" in node).toBe(false);
+	});
 });