@selesai/code 0.9.10 → 0.9.12

package/dist/extensions/pi-subagents/test/unit/async-recovery-descriptor.test.ts

@@ -34,6 +34,7 @@ describe("async recovery descriptor", () => {
 				inheritProjectContext: false,
 				inheritSkills: false,
 				outputMode: "inline",
+				context: "fork",
 				maxSubagentDepth: 2,
 				share: false,
 			}), "utf-8");
@@ -41,6 +42,34 @@ describe("async recovery descriptor", () => {
 			const descriptor = readAsyncRecoveryDescriptor(root);
 
 			assert.equal(descriptor?.launchContractDigest, digest);
+			assert.equal(descriptor?.context, "fork");
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("rejects unresolved profile context values", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-recovery-bad-context-"));
+		try {
+			fs.writeFileSync(path.join(root, "recovery-descriptor.json"), JSON.stringify({
+				version: 1,
+				runFanoutBudget: runFanoutBudget("run-bad-context"),
+				sourceRunId: "run-bad-context",
+				agent: "worker",
+				cwd: root,
+				systemPromptMode: "replace",
+				inheritProjectContext: false,
+				inheritSkills: false,
+				outputMode: "inline",
+				context: "profile",
+				maxSubagentDepth: 2,
+				share: false,
+			}), "utf-8");
+
+			assert.throws(
+				() => readAsyncRecoveryDescriptor(root),
+				/context is invalid/,
+			);
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });
 		}

package/dist/extensions/pi-subagents/test/unit/async-resume.test.ts

@@ -3,7 +3,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { describe, it } from "node:test";
-import { buildRevivedAsyncTask, resolveAsyncResumeTarget } from "../../src/runs/background/async-resume.ts";
+import { asyncReviveRequiresRecoveryDescriptor, buildRevivedAsyncTask, resolveAsyncResumeTarget } from "../../src/runs/background/async-resume.ts";
 import { createRunFanoutBudget } from "../../src/runs/shared/run-fanout-budget.ts";
 
 function writeJson(filePath: string, value: object): void {
@@ -18,8 +18,8 @@ describe("async resume lookup", () => {
 			const asyncRoot = path.join(root, "runs");
 			const sessionFile = path.join(root, "session.jsonl");
 			fs.writeFileSync(sessionFile, "", "utf-8");
-			writeJson(path.join(asyncRoot, "run-abc", "status.json"), {
-				runId: "run-abc",
+			writeJson(path.join(asyncRoot, "run-abcde", "status.json"), {
+				runId: "run-abcde",
 				mode: "single",
 				state: "complete",
 				startedAt: 100,
@@ -30,10 +30,10 @@ describe("async resume lookup", () => {
 				steps: [{ agent: "worker", status: "complete" }],
 			});
 
-			const target = resolveAsyncResumeTarget({ id: "run-a" }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") });
+			const target = resolveAsyncResumeTarget({ id: "run-abcd" }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") });
 
 			assert.equal(target.kind, "revive");
-			assert.equal(target.runId, "run-abc");
+			assert.equal(target.runId, "run-abcde");
 			assert.equal(target.agent, "worker");
 			assert.equal(target.sessionFile, sessionFile);
 			assert.equal(target.cwd, root);
@@ -42,6 +42,184 @@ describe("async resume lookup", () => {
 		}
 	});
 
+	it("resolves a workflow child session without a recovery descriptor", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-resume-workflow-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			const sessionFile = path.join(root, "child-session.jsonl");
+			fs.writeFileSync(sessionFile, "", "utf-8");
+			writeJson(path.join(asyncRoot, "workflow-1", "status.json"), {
+				runId: "workflow-1",
+				mode: "workflow",
+				state: "failed",
+				startedAt: 100,
+				endedAt: 200,
+				lastUpdate: 200,
+				cwd: root,
+				steps: [{ agent: "worker", status: "failed", sessionFile, runId: "child-1" }],
+			});
+
+			const target = resolveAsyncResumeTarget({ id: "workflow-1" }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") });
+
+			assert.equal(target.kind, "revive");
+			assert.equal(target.mode, "workflow");
+			assert.equal(target.agent, "worker");
+			assert.equal(target.sessionFile, sessionFile);
+			assert.equal(target.recoveryDescriptor, undefined);
+			assert.equal(asyncReviveRequiresRecoveryDescriptor(target), false);
+			assert.equal(asyncReviveRequiresRecoveryDescriptor({ mode: "single", sessionFile }), true);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("resolves a retained managed worktree cwd and fails closed when it is missing", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-resume-missing-cwd-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			const asyncDir = path.join(asyncRoot, "run-missing-cwd");
+			const sessionFile = path.join(root, "session.jsonl");
+			const worktreeCwd = path.join(root, "managed-worktree");
+			fs.writeFileSync(sessionFile, "", "utf-8");
+			fs.mkdirSync(worktreeCwd);
+			writeJson(path.join(asyncDir, "status.json"), {
+				runId: "run-missing-cwd", mode: "single", state: "complete", startedAt: 100, endedAt: 200, lastUpdate: 200,
+				cwd: root,
+				steps: [{ agent: "worker", status: "complete", sessionFile }],
+			});
+			writeJson(path.join(asyncDir, "handoff.json"), {
+				version: 1, runId: "run-missing-cwd", mode: "single", source: "async", cwd: root, createdAt: 100, updatedAt: 200,
+				groups: [{
+					stepIndex: 0, baseCommit: "deadbeef", repoRoot: root,
+					children: [{ index: 0, taskIndex: 0, agent: "worker", status: "completed", summary: "done", patch: { path: path.join(root, "patch"), branch: "branch", changed: false, diffStat: "", filesChanged: 0, insertions: 0, deletions: 0 } }],
+					cleanup: { state: "partial", pruned: true, tasks: [{ index: 0, path: worktreeCwd, branch: "branch", worktreeRemoved: false, branchRemoved: false, preserved: true }] },
+				}],
+			});
+
+			const target = resolveAsyncResumeTarget({ id: "run-missing-cwd" }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") });
+			assert.equal(target.cwd, worktreeCwd);
+			fs.rmSync(worktreeCwd, { recursive: true });
+
+			assert.throws(
+				() => resolveAsyncResumeTarget({ id: "run-missing-cwd" }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") }),
+				/required managed worktree cwd is missing/,
+			);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("resolves a retained managed worktree cwd in the original repository subdirectory", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-resume-nested-cwd-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			const asyncDir = path.join(asyncRoot, "run-nested-cwd");
+			const repoRoot = path.join(root, "repo");
+			const repoCwd = path.join(repoRoot, "packages", "feature");
+			const worktreeRoot = path.join(root, "managed-worktree");
+			const worktreeCwd = path.join(worktreeRoot, "packages", "feature");
+			const sessionFile = path.join(root, "session.jsonl");
+			fs.mkdirSync(repoCwd, { recursive: true });
+			fs.mkdirSync(worktreeCwd, { recursive: true });
+			fs.writeFileSync(sessionFile, "", "utf-8");
+			writeJson(path.join(asyncDir, "status.json"), {
+				runId: "run-nested-cwd", mode: "single", state: "complete", startedAt: 100, endedAt: 200, lastUpdate: 200,
+				cwd: repoCwd,
+				steps: [{ agent: "worker", status: "complete", sessionFile }],
+			});
+			writeJson(path.join(asyncDir, "handoff.json"), {
+				version: 1, runId: "run-nested-cwd", mode: "single", source: "async", cwd: repoCwd, createdAt: 100, updatedAt: 200,
+				groups: [{
+					stepIndex: 0, baseCommit: "deadbeef", repoRoot,
+					children: [{ index: 0, taskIndex: 0, agent: "worker", status: "completed", summary: "done", patch: { path: path.join(root, "patch"), branch: "branch", changed: false, diffStat: "", filesChanged: 0, insertions: 0, deletions: 0 } }],
+					cleanup: { state: "partial", pruned: true, tasks: [{ index: 0, path: worktreeRoot, branch: "branch", worktreeRemoved: false, branchRemoved: false, preserved: true }] },
+				}],
+			});
+
+			const target = resolveAsyncResumeTarget({ id: "run-nested-cwd" }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") });
+			assert.equal(target.cwd, worktreeCwd);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("resumes a normal child when a sibling has a managed worktree handoff", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-resume-mixed-cwd-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			const asyncDir = path.join(asyncRoot, "run-mixed-cwd");
+			const worktreeCwd = path.join(root, "managed-worktree");
+			const sessionFile = path.join(root, "session.jsonl");
+			fs.mkdirSync(worktreeCwd);
+			fs.writeFileSync(sessionFile, "", "utf-8");
+			writeJson(path.join(asyncDir, "status.json"), {
+				runId: "run-mixed-cwd", mode: "parallel", state: "complete", startedAt: 100, endedAt: 200, lastUpdate: 200, cwd: root,
+				steps: [{ agent: "worktree-worker", status: "complete" }, { agent: "normal-worker", status: "complete", sessionFile }],
+			});
+			writeJson(path.join(asyncDir, "handoff.json"), {
+				version: 1, runId: "run-mixed-cwd", mode: "parallel", source: "async", cwd: root, createdAt: 100, updatedAt: 200,
+				groups: [{
+					stepIndex: 0, baseCommit: "deadbeef", repoRoot: root,
+					children: [{ index: 0, taskIndex: 0, agent: "worktree-worker", status: "completed", summary: "done", patch: { path: path.join(root, "patch"), branch: "branch", changed: false, diffStat: "", filesChanged: 0, insertions: 0, deletions: 0 } }],
+					cleanup: { state: "partial", pruned: true, tasks: [{ index: 0, path: worktreeCwd, branch: "branch", worktreeRemoved: false, branchRemoved: false, preserved: true }] },
+				}],
+			});
+
+			const target = resolveAsyncResumeTarget({ id: "run-mixed-cwd", index: 1 }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") });
+			assert.equal(target.agent, "normal-worker");
+			assert.equal(target.cwd, root);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("rejects a retained managed worktree cwd that resolves outside the preserved worktree", (context) => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-resume-escaped-cwd-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			const asyncDir = path.join(asyncRoot, "run-escaped-cwd");
+			const repoRoot = path.join(root, "repo");
+			const repoCwd = path.join(repoRoot, "pkg");
+			const worktreeRoot = path.join(root, "managed-worktree");
+			const outsideCwd = path.join(root, "outside");
+			const sessionFile = path.join(root, "session.jsonl");
+			fs.mkdirSync(repoCwd, { recursive: true });
+			fs.mkdirSync(worktreeRoot);
+			fs.mkdirSync(outsideCwd);
+			fs.writeFileSync(sessionFile, "", "utf-8");
+			try {
+				fs.symlinkSync(outsideCwd, path.join(worktreeRoot, "pkg"), "dir");
+			} catch (error) {
+				const code = (error as NodeJS.ErrnoException).code;
+				if (code === "EPERM" || code === "EACCES") {
+					context.skip("directory symlink creation is unavailable");
+					return;
+				}
+				throw error;
+			}
+			writeJson(path.join(asyncDir, "status.json"), {
+				runId: "run-escaped-cwd", mode: "single", state: "complete", startedAt: 100, endedAt: 200, lastUpdate: 200,
+				cwd: repoCwd,
+				steps: [{ agent: "worker", status: "complete", sessionFile }],
+			});
+			writeJson(path.join(asyncDir, "handoff.json"), {
+				version: 1, runId: "run-escaped-cwd", mode: "single", source: "async", cwd: repoCwd, createdAt: 100, updatedAt: 200,
+				groups: [{
+					stepIndex: 0, baseCommit: "deadbeef", repoRoot,
+					children: [{ index: 0, taskIndex: 0, agent: "worker", status: "completed", summary: "done", patch: { path: path.join(root, "patch"), branch: "branch", changed: false, diffStat: "", filesChanged: 0, insertions: 0, deletions: 0 } }],
+					cleanup: { state: "partial", pruned: true, tasks: [{ index: 0, path: worktreeRoot, branch: "branch", worktreeRemoved: false, branchRemoved: false, preserved: true }] },
+				}],
+			});
+
+			assert.throws(
+				() => resolveAsyncResumeTarget({ id: "run-escaped-cwd" }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") }),
+				/invalid managed worktree cwd/,
+			);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("preserves and validates persisted capability ceilings for resume", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-resume-ceiling-"));
 		try {
@@ -114,11 +292,16 @@ describe("async resume lookup", () => {
 				...descriptor,
 				launchContractDigest: "launch-contract-digest",
 				intercomBridge: { mode: "off" },
+				extensionBindings: { "shepherd.dispatch/1": { role: "coder" } },
 			});
 			const valid = resolveAsyncResumeTarget({ id: "run-descriptor" }, { asyncDirRoot: asyncRoot, resultsDir });
 			assert.equal(valid.launchContractDigest, "launch-contract-digest");
 			assert.equal(valid.recoveryDescriptor?.launchContractDigest, "launch-contract-digest");
 			assert.deepEqual(valid.recoveryDescriptor?.intercomBridge, { mode: "off" });
+			assert.deepEqual(valid.recoveryDescriptor?.extensionBindings, { "shepherd.dispatch/1": { role: "coder" } });
+
+			writeJson(path.join(asyncDir, "recovery-descriptor.json"), { ...descriptor, extensionBindings: { invalid: true } });
+			assert.throws(() => resolveAsyncResumeTarget({ id: "run-descriptor" }, { asyncDirRoot: asyncRoot, resultsDir }), /namespace/);
 
 			writeJson(path.join(asyncDir, "recovery-descriptor.json"), { ...descriptor, sourceRunId: "another-run" });
 			assert.throws(() => resolveAsyncResumeTarget({ id: "run-descriptor" }, { asyncDirRoot: asyncRoot, resultsDir }), /different source run/);
@@ -185,7 +368,7 @@ describe("async resume lookup", () => {
 		}
 	});
 
-	it("accepts legacy resolved acceptance metadata in recovery descriptors", () => {
+	it("accepts current acceptance metadata in recovery descriptors", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-resume-acceptance-"));
 		try {
 			const asyncRoot = path.join(root, "runs");
@@ -211,8 +394,6 @@ describe("async resume lookup", () => {
 				share: false,
 				acceptance: {
 					level: "attested",
-					explicit: true,
-					inferredReason: ["async write-capable or risky run"],
 					criteria: [{ id: "criterion-1", must: "Return evidence", evidence: ["manual-notes"], severity: "required" }],
 					evidence: ["manual-notes", "residual-risks"],
 					verify: [],
@@ -235,7 +416,7 @@ describe("async resume lookup", () => {
 		}
 	});
 
-	it("rejects stale explicit reviewed acceptance metadata in recovery descriptors", () => {
+	it("rejects reviewed acceptance metadata in recovery descriptors", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-resume-reviewed-acceptance-"));
 		try {
 			const asyncRoot = path.join(root, "runs");
@@ -261,8 +442,6 @@ describe("async resume lookup", () => {
 				share: false,
 				acceptance: {
 					level: "reviewed",
-					explicit: true,
-					inferredReason: ["async write-capable or risky run"],
 					criteria: ["Return evidence"],
 					evidence: ["validation-output"],
 					verify: [],
@@ -280,7 +459,7 @@ describe("async resume lookup", () => {
 		}
 	});
 
-	it("drops inferred legacy acceptance metadata from recovery descriptors", () => {
+	it("rejects legacy acceptance metadata in recovery descriptors", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-resume-inferred-acceptance-"));
 		try {
 			const asyncRoot = path.join(root, "runs");
@@ -305,21 +484,20 @@ describe("async resume lookup", () => {
 				maxSubagentDepth: 2,
 				share: false,
 				acceptance: {
-					level: "reviewed",
+					level: "attested",
 					explicit: false,
 					inferredReason: ["async write-capable or risky run"],
 					criteria: [],
 					evidence: [],
 					verify: [],
-					review: { agent: "reviewer", required: true },
 					stopRules: [],
 				},
 			});
 
-			const target = resolveAsyncResumeTarget({ id: "run-inferred-acceptance" }, { asyncDirRoot: asyncRoot, resultsDir });
-
-			assert.equal(target.kind, "revive");
-			assert.equal(target.recoveryDescriptor?.acceptance, undefined);
+			assert.throws(
+				() => resolveAsyncResumeTarget({ id: "run-inferred-acceptance" }, { asyncDirRoot: asyncRoot, resultsDir }),
+				/recoveryDescriptor\.acceptance\.(explicit|inferredReason) is not supported/i,
+			);
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });
 		}
@@ -357,24 +535,28 @@ describe("async resume lookup", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-resume-ambiguous-"));
 		try {
 			const asyncRoot = path.join(root, "runs");
-			writeJson(path.join(asyncRoot, "run-aa", "status.json"), {
-				runId: "run-aa",
+			writeJson(path.join(asyncRoot, "run-aaaa-1", "status.json"), {
+				runId: "run-aaaa-1",
 				mode: "single",
 				state: "running",
 				startedAt: 100,
 				steps: [{ agent: "scout", status: "running" }],
 			});
-			writeJson(path.join(asyncRoot, "run-ab", "status.json"), {
-				runId: "run-ab",
+			writeJson(path.join(asyncRoot, "run-aaaa-2", "status.json"), {
+				runId: "run-aaaa-2",
 				mode: "single",
 				state: "running",
 				startedAt: 100,
 				steps: [{ agent: "worker", status: "running" }],
 			});
 
+			assert.throws(
+				() => resolveAsyncResumeTarget({ id: "run-aaaa" }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") }),
+				/Ambiguous async run id prefix 'run-aaaa' matched: run-aaaa-1, run-aaaa-2/,
+			);
 			assert.throws(
 				() => resolveAsyncResumeTarget({ id: "run-a" }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") }),
-				/Ambiguous async run id prefix 'run-a' matched: run-aa, run-ab/,
+				/at least 8 characters/,
 			);
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });