@selesai/code 0.9.11 → 0.9.13

package/dist/extensions/pi-subagents/test/unit/public-execution.test.ts

@@ -3,17 +3,61 @@ import { describe, it } from "node:test";
 import { normalizePublicSubagentExecution } from "../../src/extension/public-execution.ts";
 
 describe("public subagent execution normalization", () => {
-	it("accepts all four execution modes, management, and direct-field schedules", () => {
+	it("accepts structured single-child, workflow, management, and schedules", () => {
 		assert.deepEqual(normalizePublicSubagentExecution({ workflowScript: "return 1" }), { ok: true, params: { workflowScript: "return 1" } });
-		const single = normalizePublicSubagentExecution({ agent: "worker", task: "work" });
-		assert.equal(single.ok, true);
-		if (single.ok) {
-			assert.equal(typeof (single.params as { workflowScript?: unknown }).workflowScript, "string");
-			assert.match((single.params as { workflowScript: string }).workflowScript, /runs\.run\("main", \{"agent":"worker","task":"work","output":true\}\)/);
-		}
-		assert.deepEqual(normalizePublicSubagentExecution({ tasks: [{ agent: "worker" }] }), { ok: true, params: { tasks: [{ agent: "worker" }] } });
-		assert.deepEqual(normalizePublicSubagentExecution({ chain: [{ agent: "worker" }] }), { ok: true, params: { chain: [{ agent: "worker" }] } });
+		const task = "Use `quotes`\nand newlines";
+		assert.deepEqual(normalizePublicSubagentExecution({ agent: " worker ", task, context: "fresh", async: false }), {
+			ok: true,
+			params: {
+				agent: "worker",
+				task,
+				context: "fresh",
+				async: false,
+				output: true,
+			},
+		});
+		assert.deepEqual(normalizePublicSubagentExecution({ agent: "worker" }), {
+			ok: true,
+			params: {
+				agent: "worker",
+				output: true,
+			},
+		});
+		assert.deepEqual(normalizePublicSubagentExecution({ agent: "worker" }, { asyncByDefault: false }), {
+			ok: true,
+			params: {
+				agent: "worker",
+				output: true,
+			},
+		});
+		assert.deepEqual(normalizePublicSubagentExecution({ agent: "worker", async: true }, { asyncByDefault: false }), {
+			ok: true,
+			params: {
+				agent: "worker",
+				async: true,
+				output: true,
+			},
+		});
+		assert.deepEqual(normalizePublicSubagentExecution({ agent: "worker", output: false }), {
+			ok: true,
+			params: {
+				agent: "worker",
+				output: false,
+			},
+		});
+		assert.deepEqual(normalizePublicSubagentExecution({ agent: "worker", isolation: "none" }), {
+			ok: true,
+			params: {
+				agent: "worker",
+				worktree: false,
+				output: true,
+			},
+		});
 		assert.deepEqual(normalizePublicSubagentExecution({ action: " list " }), { ok: true, params: { action: "list" } });
+		assert.deepEqual(
+			normalizePublicSubagentExecution({ action: " schedule.create ", every: "1h", workflowScript: "return 1" }),
+			{ ok: true, params: { action: "schedule.create", every: "1h", workflowScript: "return 1" } },
+		);
 	});
 
 	it("rejects private run fan-out fields at the public boundary", () => {
@@ -27,20 +71,51 @@ describe("public subagent execution normalization", () => {
 		}
 	});
 
-	it("rejects removed public execution shapes", () => {
+	it("rejects private workflow child fields at the public boundary", () => {
+		for (const params of [
+			{ agent: "worker", workflowParentRunId: "workflow" },
+			{ agent: "worker", workflowKey: "child" },
+			{ agent: "worker", workflowChildAsyncId: "child" },
+			{ agent: "worker", workflowAwaitAsync: true },
+			{ agent: "worker", workflowParentDeadlineAt: Date.now() + 1_000 },
+			{ agent: "worker", suppressRoutineResultIntercom: true },
+		] as const) {
+			const result = normalizePublicSubagentExecution(params);
+			assert.equal(result.ok, false);
+			if (!result.ok) assert.match(result.error, /internal workflow child fields/);
+		}
+	});
+
+	it("rejects mixed, invalid, and removed public execution shapes", () => {
 		for (const params of [
 			{ action: " " },
 			{ action: "single" },
 			{ action: "parallel" },
 			{ action: "chain" },
+			{ action: "append-step", id: "run", step: { agent: "worker" } },
+			{ action: "approve-checkpoint", id: "run" },
+			{ action: "reject-checkpoint", id: "run" },
+			{ agent: "" },
+			{ agent: 42 },
+			{ task: "work" },
+			{ agent: "worker", task: 42 },
+			{ agent: "worker", workflowScript: "return 1" },
+			{ action: "status", task: "work" },
+			{ tasks: [{ agent: "worker" }] },
+			{ chain: [{ agent: "worker" }] },
 			{ parallel: [{ agent: "worker" }] },
 			{ concurrency: 2 },
+			{ action: "get", chainName: "review-pipeline" },
+			{ action: "create", config: { name: "review-pipeline", steps: [{ agent: "worker" }] } },
 			{ clarify: true, workflowScript: "return 1" },
 			{ resume: "retained-run", workflowScript: "return 1" },
 			{},
 			{ workflowScript: " " },
 			{ action: "status", workflowScript: "return 1" },
-			{ action: "schedule.create", every: "1h" },
+			{ action: "schedule.create", every: "1h", agent: "worker", workflowScript: "return 1" },
+			{ workflowScript: "return 1", isolation: "invalid" },
+			{ workflowScript: "return 1", isolation: "none", worktree: true },
+			{ workflowScript: "return 1", isolation: "worktree", worktree: false },
 		] as const) {
 			assert.equal(normalizePublicSubagentExecution(params).ok, false, JSON.stringify(params));
 		}

package/dist/extensions/pi-subagents/test/unit/render-helpers.test.ts

@@ -3,7 +3,8 @@ import assert from "node:assert/strict";
 
 import { visibleWidth } from "@earendil-works/pi-tui";
 import { row } from "../../src/tui/render-helpers.ts";
-import { renderSubagentResult, truncLine } from "../../src/tui/render.ts";
+import { renderSubagentResult, truncLine, widgetRenderKey } from "../../src/tui/render.ts";
+import type { AsyncJobState } from "../../src/shared/types.ts";
 
 const theme = {
 	fg(_name: string, text: string): string {
@@ -65,6 +66,53 @@ test("truncLine emits no marker at zero width", () => {
 	assert.equal(truncLine("abcdef", 0), "");
 });
 
+test("widget render keys keep compact payloads quiet and expanded payloads fresh", () => {
+	const job: AsyncJobState = {
+		asyncId: "workflow-1",
+		asyncDir: "/tmp/workflow-1",
+		status: "running",
+		mode: "workflow",
+		startedAt: 100,
+		updatedAt: 200,
+		steps: [{
+			agent: "reviewer",
+			workflowKey: "review",
+			status: "running",
+			currentTool: "grep",
+			recentOutput: ["started", "x".repeat(20_000)],
+			recentTools: [
+				{ tool: "read", args: "hidden", endMs: 100 },
+				{ tool: "grep", args: "visible", endMs: 150 },
+			],
+		}],
+	};
+	const noisy = structuredClone(job);
+	noisy.steps![0]!.recentOutput = ["started", "y".repeat(20_000)];
+	noisy.steps![0]!.recentTools = [
+		{ tool: "read", args: "changed-hidden", endMs: 100 },
+		{ tool: "grep", args: "visible", endMs: 150 },
+	];
+	assert.equal(widgetRenderKey(noisy), widgetRenderKey(job));
+	assert.notEqual(widgetRenderKey(noisy, true), widgetRenderKey(job, true));
+
+	const expandedVisibleChange = structuredClone(job);
+	expandedVisibleChange.steps![0]!.recentTools![1]!.args = "changed-visible";
+	assert.equal(widgetRenderKey(expandedVisibleChange), widgetRenderKey(job));
+	assert.notEqual(widgetRenderKey(expandedVisibleChange, true), widgetRenderKey(job, true));
+
+	const visibleChange = structuredClone(job);
+	visibleChange.steps![0]!.currentTool = "bash";
+	assert.notEqual(widgetRenderKey(visibleChange), widgetRenderKey(job));
+
+	const visibleArgsChange = structuredClone(job);
+	visibleArgsChange.steps![0]!.currentToolArgs = "{\"pattern\":\"workflow\"}";
+	assert.notEqual(widgetRenderKey(visibleArgsChange), widgetRenderKey(job));
+
+	const nestedVisibleChange = structuredClone(job);
+	nestedVisibleChange.nestedChildren = [{ id: "nested-1", parentRunId: "workflow-1", depth: 1, path: [{ runId: "workflow-1" }], state: "failed", agent: "nested", error: "failed" }];
+	assert.notEqual(widgetRenderKey(nestedVisibleChange), widgetRenderKey(job));
+});
+
 test("multiline rendering omits two-column graphemes at one-column width", () => {
 	const originalColumns = Object.getOwnPropertyDescriptor(process.stdout, "columns");
 	Object.defineProperty(process.stdout, "columns", { configurable: true, value: 5 });

package/dist/extensions/pi-subagents/test/unit/result-files.test.ts

@@ -1,15 +1,38 @@
 import assert from "node:assert/strict";
-import * as fs from "node:fs";
+import fsDefault, * as fs from "node:fs";
+import { syncBuiltinESMExports } from "node:module";
 import * as os from "node:os";
 import * as path from "node:path";
 import { describe, it } from "node:test";
-import { cleanupResultIndexes, removeResultIndex, resultCandidateFilesForSession, resultFilesForSession, resultPayloadPathForIndexedRun, resultPayloadPathForSessionRun, writeAsyncResultFile, writePendingAsyncResultFile, writeResultIndexForData } from "../../src/runs/background/result-files.ts";
+import { encodeIndexSegment, MAX_INDEX_SEGMENT_BYTES } from "../../src/runs/background/index-segment.ts";
+import { cleanupResultIndexes, removeResultIndex, resultCandidateFilesForSession, resultFilesForSession, resultFilesForToolCall, resultPayloadPathForIndexedRun, resultPayloadPathForSessionRun, writeAsyncResultFile, writePendingAsyncResultFile, writeResultIndexForData } from "../../src/runs/background/result-files.ts";
+
+const JSON_EXTENSION = ".json";
+const MAX_JSON_FILE_STEM_BYTES = MAX_INDEX_SEGMENT_BYTES - Buffer.byteLength(JSON_EXTENSION, "utf-8");
 
 function pendingPath(resultsDir: string, sessionId: string, runId: string): string {
-	return path.join(resultsDir, "result-pending", encodeURIComponent(sessionId), `${encodeURIComponent(runId)}.json`);
+	return path.join(resultsDir, "result-pending", encodeIndexSegment(sessionId), `${encodeIndexSegment(runId, MAX_JSON_FILE_STEM_BYTES)}${JSON_EXTENSION}`);
 }
 
 describe("result file indexes", () => {
+	it("resolves run ids without enumerating session indexes", () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-files-run-index-"));
+		const originalReaddirSync = fsDefault.readdirSync;
+		try {
+			const resultPath = path.join(resultsDir, "direct-run.json");
+			writeAsyncResultFile(resultPath, { id: "direct-run", runId: "direct-run", sessionId: "session-a", success: true });
+			fsDefault.readdirSync = (() => { throw new Error("result index enumerated"); }) as typeof fsDefault.readdirSync;
+			syncBuiltinESMExports();
+
+			assert.equal(resultPayloadPathForIndexedRun(resultsDir, "direct-run"), resultPath);
+			assert.equal(resultPayloadPathForIndexedRun(resultsDir, "missing-run"), undefined);
+		} finally {
+			fsDefault.readdirSync = originalReaddirSync;
+			syncBuiltinESMExports();
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
 	it("removes orphan index entries without deleting flat result files", () => {
 		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-files-index-"));
 		try {
@@ -18,7 +41,7 @@ describe("result file indexes", () => {
 			fs.rmSync(path.join(resultsDir, "missing.json"));
 			fs.writeFileSync(path.join(resultsDir, "unindexed.json"), JSON.stringify({ id: "unindexed", sessionId: "session-a" }), "utf-8");
 
-			assert.equal(cleanupResultIndexes(resultsDir, Date.now() + 86_400_001, 86_400_000), 2);
+			assert.equal(cleanupResultIndexes(resultsDir, Date.now() + 86_400_001, 86_400_000), 3);
 
 			assert.deepEqual(resultFilesForSession(resultsDir, "session-a"), ["kept.json"]);
 			assert.equal(fs.existsSync(path.join(resultsDir, "kept.json")), true);
@@ -70,6 +93,56 @@ describe("result file indexes", () => {
 		}
 	});
 
+	it("keeps pending results for long session ids below filesystem component limits", () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-files-long-session-"));
+		const originalError = console.error;
+		try {
+			console.error = () => {};
+			const sessionId = `/Users/zhouatie/.config/pi/sessions/${"界".repeat(100)}.jsonl`;
+			const runId = "pending-long-session";
+			const resultPath = path.join(resultsDir, `${runId}.json`);
+			fs.mkdirSync(resultPath);
+
+			writePendingAsyncResultFile(resultPath, { id: runId, runId, sessionId, success: true });
+
+			const payloadPath = pendingPath(resultsDir, sessionId, runId);
+			assert.ok(Buffer.byteLength(path.basename(path.dirname(payloadPath)), "utf-8") <= 255);
+			assert.equal(fs.existsSync(payloadPath), true);
+			assert.deepEqual(resultCandidateFilesForSession(resultsDir, sessionId), [`${runId}.json`]);
+			assert.equal(resultPayloadPathForSessionRun(resultsDir, sessionId, runId), payloadPath);
+			fs.rmSync(path.join(resultsDir, "result-index"), { recursive: true });
+			assert.equal(resultPayloadPathForIndexedRun(resultsDir, runId), undefined);
+		} finally {
+			console.error = originalError;
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
+	it("keeps pending results for near-limit run ids below filesystem component limits", () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-files-long-run-"));
+		const originalError = console.error;
+		try {
+			console.error = () => {};
+			const sessionId = "session-a";
+			for (const runId of ["x".repeat(250), "y".repeat(251)]) {
+				const resultPath = path.join(resultsDir, `${runId}.json`);
+				if (runId.length === 250) fs.mkdirSync(resultPath);
+				writePendingAsyncResultFile(resultPath, { id: runId, runId, sessionId, success: true });
+
+				const payloadPath = pendingPath(resultsDir, sessionId, runId);
+				const pendingFile = path.basename(payloadPath);
+				assert.ok(Buffer.byteLength(pendingFile, "utf-8") <= 255);
+				assert.equal(fs.existsSync(payloadPath), true);
+				assert.equal(resultPayloadPathForSessionRun(resultsDir, sessionId, runId), payloadPath);
+			}
+			assert.equal(path.basename(pendingPath(resultsDir, sessionId, "x".repeat(250))), `${"x".repeat(250)}.json`);
+			assert.match(path.basename(pendingPath(resultsDir, sessionId, "y".repeat(251))), /^~sha256-[a-f0-9]{64}\.json$/);
+		} finally {
+			console.error = originalError;
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
 	it("keeps a legacy valid index while the result payload is not visible yet", () => {
 		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-files-legacy-late-payload-"));
 		try {
@@ -95,7 +168,7 @@ describe("result file indexes", () => {
 			assert.equal(fs.existsSync(resultPath), false);
 			assert.equal(fs.existsSync(pendingPath(resultsDir, "session-a", "blocked")), true);
 			assert.equal(resultPayloadPathForSessionRun(resultsDir, "session-a", "blocked"), pendingPath(resultsDir, "session-a", "blocked"));
-			assert.equal(resultPayloadPathForIndexedRun(resultsDir, "blocked"), pendingPath(resultsDir, "session-a", "blocked"));
+			assert.equal(resultPayloadPathForIndexedRun(resultsDir, "blocked"), undefined);
 			assert.deepEqual(resultCandidateFilesForSession(resultsDir, "session-a"), ["blocked.json"]);
 		} finally {
 			fs.rmSync(resultsDir, { recursive: true, force: true });
@@ -136,6 +209,32 @@ describe("result file indexes", () => {
 		}
 	});
 
+	it("keeps a newer pending payload readable when Windows cannot replace the public result", (t) => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-files-windows-pending-wins-"));
+		try {
+			const resultPath = path.join(resultsDir, "blocked.json");
+			writeAsyncResultFile(resultPath, { id: "blocked", runId: "blocked", sessionId: "session-a", success: false });
+			writePendingAsyncResultFile(resultPath, { id: "blocked", runId: "blocked", sessionId: "session-a", success: true });
+
+			t.mock.method(fsDefault, "renameSync", () => {
+				const error = new Error("destination exists") as NodeJS.ErrnoException;
+				error.code = "EEXIST";
+				throw error;
+			});
+			syncBuiltinESMExports();
+
+			const payloadPath = resultPayloadPathForSessionRun(resultsDir, "session-a", "blocked");
+			assert.equal(payloadPath, pendingPath(resultsDir, "session-a", "blocked"));
+			assert.equal(JSON.parse(fs.readFileSync(payloadPath, "utf-8")).success, true);
+			assert.equal(JSON.parse(fs.readFileSync(resultPath, "utf-8")).success, false);
+			assert.equal(fs.existsSync(pendingPath(resultsDir, "session-a", "blocked")), true);
+		} finally {
+			t.mock.restoreAll();
+			syncBuiltinESMExports();
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
 	it("removes pending payloads with result indexes", () => {
 		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-files-pending-cleanup-"));
 		const originalError = console.error;
@@ -154,6 +253,24 @@ describe("result file indexes", () => {
 		}
 	});
 
+	it("indexes results with oversized provider tool-call ids", () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-files-long-tool-call-"));
+		try {
+			const runId = "workflow-long-tool-call";
+			const toolCallId = `call_${"opaque/+=".repeat(80)}`;
+			const resultPath = path.join(resultsDir, `${runId}.json`);
+
+			writeAsyncResultFile(resultPath, { id: runId, runId, sessionId: "session-a", toolCallId, success: true });
+
+			assert.deepEqual(resultFilesForToolCall(resultsDir, toolCallId), [`${runId}.json`]);
+			removeResultIndex(resultsDir, "session-a", runId, toolCallId);
+			assert.deepEqual(resultFilesForToolCall(resultsDir, toolCallId), []);
+			assert.equal(fs.existsSync(resultPath), true);
+		} finally {
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
 	it("commits a result payload when only an optional index fails", () => {
 		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-files-optional-index-"));
 		const originalError = console.error;
@@ -172,4 +289,115 @@ describe("result file indexes", () => {
 			fs.rmSync(resultsDir, { recursive: true, force: true });
 		}
 	});
+
+	it("round-trips results for Windows session file paths", () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-files-win-session-"));
+		try {
+			const sessionId = String.raw`C:\Users\theap\.pi\agent\sessions\leaf.jsonl`;
+			const runId = "win-session-run";
+			const resultPath = path.join(resultsDir, `${runId}.json`);
+			writeAsyncResultFile(resultPath, { id: runId, runId, sessionId, success: true });
+
+			const sessionDirs = fs.readdirSync(path.join(resultsDir, "result-index", "sessions"));
+			assert.equal(sessionDirs.length, 1);
+			assert.match(sessionDirs[0]!, /^~sha256-[a-f0-9]{64}$/);
+			assert.deepEqual(resultFilesForSession(resultsDir, sessionId), [`${runId}.json`]);
+			assert.deepEqual(resultCandidateFilesForSession(resultsDir, sessionId), [`${runId}.json`]);
+		} finally {
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
+	it("reads a pre-hash URI-encoded session index after the encoding change", () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-files-legacy-session-"));
+		try {
+			const sessionId = String.raw`C:\Users\theap\.pi\agent\sessions\leaf.jsonl`;
+			const runId = "legacy-session-run";
+			const resultPath = path.join(resultsDir, `${runId}.json`);
+			writeAsyncResultFile(resultPath, { id: runId, runId, sessionId, success: true });
+
+			const currentDir = path.join(resultsDir, "result-index", "sessions", encodeIndexSegment(sessionId));
+			const historicalDir = path.join(resultsDir, "result-index", "sessions", encodeURIComponent(sessionId));
+			fs.renameSync(currentDir, historicalDir);
+
+			assert.deepEqual(resultFilesForSession(resultsDir, sessionId), [`${runId}.json`]);
+			assert.equal(resultPayloadPathForSessionRun(resultsDir, sessionId, runId), resultPath);
+		} finally {
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
+	it("reads a pre-hash extension-like run index filename", () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-files-legacy-run-"));
+		try {
+			const sessionId = "session-a";
+			const runId = "legacy.jsonl";
+			const resultPath = path.join(resultsDir, `${runId}.json`);
+			writeAsyncResultFile(resultPath, { id: runId, runId, sessionId, success: true });
+
+			const indexDir = path.join(resultsDir, "result-index", "sessions", encodeIndexSegment(sessionId));
+			const [currentFile] = fs.readdirSync(indexDir);
+			assert.ok(currentFile);
+			fs.renameSync(path.join(indexDir, currentFile), path.join(indexDir, `${runId}.json`));
+
+			assert.equal(resultPayloadPathForSessionRun(resultsDir, sessionId, runId), resultPath);
+		} finally {
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
+	it("reads a pre-hash extension-like pending filename", () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-files-legacy-pending-"));
+		const originalError = console.error;
+		try {
+			const sessionId = "session-a";
+			const runId = "legacy.jsonl";
+			const resultPath = path.join(resultsDir, `${runId}.json`);
+			fs.mkdirSync(resultPath);
+			console.error = () => {};
+			writePendingAsyncResultFile(resultPath, { id: runId, runId, sessionId, success: true });
+
+			const currentPath = pendingPath(resultsDir, sessionId, runId);
+			const historicalPath = path.join(path.dirname(currentPath), `${runId}.json`);
+			fs.renameSync(currentPath, historicalPath);
+
+			assert.equal(resultPayloadPathForSessionRun(resultsDir, sessionId, runId), historicalPath);
+		} finally {
+			console.error = originalError;
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
+	it("throws access-denied direct session index reads", (t) => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-files-eacces-index-"));
+		const error = new Error("permission denied") as NodeJS.ErrnoException;
+		error.code = "EACCES";
+		try {
+			writeAsyncResultFile(path.join(resultsDir, "blocked.json"), { id: "blocked", runId: "blocked", sessionId: "session-a", success: true });
+			t.mock.method(fsDefault, "readFileSync", () => { throw error; });
+			syncBuiltinESMExports();
+
+			assert.throws(() => resultPayloadPathForSessionRun(resultsDir, "session-a", "blocked"), (thrown) => thrown === error);
+		} finally {
+			t.mock.restoreAll();
+			syncBuiltinESMExports();
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
+	it("returns no session candidates when the session index is unlistable", () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-files-eperm-scan-"));
+		const error = new Error("operation not permitted") as NodeJS.ErrnoException;
+		error.code = "EPERM";
+		const originalReaddirSync = fsDefault.readdirSync;
+		try {
+			fsDefault.readdirSync = (() => { throw error; }) as typeof fsDefault.readdirSync;
+			syncBuiltinESMExports();
+			assert.deepEqual(resultCandidateFilesForSession(resultsDir, "session-a"), []);
+		} finally {
+			fsDefault.readdirSync = originalReaddirSync;
+			syncBuiltinESMExports();
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
 });

package/dist/extensions/pi-subagents/test/unit/retained-children.test.ts

@@ -4,6 +4,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { describe, it } from "node:test";
 import { formatRetainedChildren, listRetainedChildren } from "../../src/runs/background/retained-children.ts";
+import { updateActiveRunIndex } from "../../src/runs/background/active-run-index.ts";
 import { createRunFanoutBudget } from "../../src/runs/shared/run-fanout-budget.ts";
 
 interface WriteRunOptions {
@@ -12,10 +13,11 @@ interface WriteRunOptions {
 	state?: "complete" | "failed" | "paused" | "stopped";
 	stepStatus?: "complete" | "completed" | "failed" | "paused" | "stopped";
 	sessionFile?: "present" | "missing" | "omitted";
-	runner?: "external-cli";
+	runner?: "external-cli" | "external-job";
 	recoveryDescriptor?: "present" | "missing" | "invalid";
 	recoverySourceRunId?: string;
 	recoveryAgent?: string;
+	recoveryCwd?: string;
 }
 
 function writeRetainedRun(root: string, index: number, options: WriteRunOptions = {}): void {
@@ -45,16 +47,18 @@ function writeRetainedRun(root: string, index: number, options: WriteRunOptions
 			description: `  Task ${index}  with   spacing ${"x".repeat(140)}  `,
 			endedAt: 1_000 + index,
 			...(options.runner === "external-cli" ? { runner: { type: "external-cli", command: "codex", args: [], promptDelivery: "stdin", capabilities: { stop: true, steer: false, resume: false, structuredOutput: false, toolEvents: false } } } : {}),
+			...(options.runner === "external-job" ? { runner: { type: "external-job", provider: "surf-oracle", options: {}, capabilities: { stop: false, steer: false, resume: false, structuredOutput: false, toolEvents: false } } } : {}),
 			...(options.sessionFile === "omitted" ? {} : { sessionFile }),
 			tokens: { input: index, output: index + 1, total: index * 2 + 1 },
 		}],
 	}), "utf-8");
+	updateActiveRunIndex(asyncDir, state);
 	if (options.recoveryDescriptor === "invalid") {
 		fs.writeFileSync(path.join(asyncDir, "recovery-descriptor.json"), JSON.stringify({
 			version: 2,
 			sourceRunId: runId,
 			agent: "worker",
-			cwd: root,
+			cwd: options.recoveryCwd ?? root,
 			systemPromptMode: "replace",
 			outputMode: "inline",
 		}), "utf-8");
@@ -64,7 +68,7 @@ function writeRetainedRun(root: string, index: number, options: WriteRunOptions
 			runFanoutBudget: createRunFanoutBudget(runId, 64),
 			sourceRunId: options.recoverySourceRunId ?? runId,
 			agent: options.recoveryAgent ?? "worker",
-			cwd: root,
+			cwd: options.recoveryCwd ?? root,
 			systemPromptMode: "replace",
 			inheritProjectContext: false,
 			inheritSkills: false,
@@ -137,16 +141,18 @@ describe("retained child roster", () => {
 			writeRetainedRun(root, 6, { recoveryDescriptor: "invalid" });
 			writeRetainedRun(root, 7, { recoverySourceRunId: "other-run" });
 			writeRetainedRun(root, 8, { recoveryAgent: "reviewer" });
+			writeRetainedRun(root, 9, { runner: "external-job" });
 
 			const children = listRetainedChildren(path.join(root, "runs"), "parent-a");
 			const formatted = formatRetainedChildren(children);
 
 			assert.deepEqual(children.map((child) => [child.runId, child.resumability]), [
+				["child-9", { state: "not-resumable", reason: "external runner" }],
 				["child-8", { state: "not-resumable", reason: "recovery descriptor belongs to agent reviewer" }],
 				["child-7", { state: "not-resumable", reason: "recovery descriptor belongs to run other-run" }],
 				["child-6", { state: "not-resumable", reason: `invalid recovery descriptor: Invalid async recovery descriptor '${path.join(root, "runs", "child-6", "recovery-descriptor.json")}': version must be 1.` }],
 				["child-5", { state: "not-resumable", reason: "missing recovery descriptor" }],
-				["child-4", { state: "not-resumable", reason: "external CLI runner" }],
+				["child-4", { state: "not-resumable", reason: "external runner" }],
 				["child-3", { state: "not-resumable", reason: "stopped run" }],
 				["child-2", { state: "not-resumable", reason: `persisted session file is missing: ${path.join(root, "sessions", "child-2.jsonl")}` }],
 				["child-1", { state: "not-resumable", reason: "no persisted session file" }],
@@ -155,7 +161,7 @@ describe("retained child roster", () => {
 			assert.match(formatted, /resumability: not resumable \(recovery descriptor belongs to run other-run\)/);
 			assert.match(formatted, /resumability: not resumable \(invalid recovery descriptor:/);
 			assert.match(formatted, /resumability: not resumable \(missing recovery descriptor\)/);
-			assert.match(formatted, /resumability: not resumable \(external CLI runner\)/);
+			assert.match(formatted, /resumability: not resumable \(external runner\)/);
 			assert.match(formatted, /resumability: not resumable \(stopped run\)/);
 			assert.match(formatted, /resumability: not resumable \(no persisted session file\)/);
 			assert.doesNotMatch(formatted, /resume: subagent/);
@@ -164,4 +170,21 @@ describe("retained child roster", () => {
 			fs.rmSync(root, { recursive: true, force: true });
 		}
 	});
+
+	it("does not advertise a retained child when its required cwd is missing", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-retained-children-missing-cwd-"));
+		try {
+			const missingCwd = path.join(root, "removed-worktree");
+			writeRetainedRun(root, 1, { recoveryCwd: missingCwd });
+
+			const children = listRetainedChildren(path.join(root, "runs"), "parent-a");
+			const formatted = formatRetainedChildren(children);
+
+			assert.equal(children[0]?.resumability.state, "not-resumable");
+			assert.match(children[0]?.resumability.state === "not-resumable" ? children[0].resumability.reason : "", /required cwd is missing|resume dependency unavailable/);
+			assert.doesNotMatch(formatted, /resume: subagent/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
 });