@selesai/code 0.13.15 → 0.13.18

package/dist/extensions/pi-subagents/test/unit/workflow-receipt.test.ts

@@ -6,7 +6,7 @@ import { afterEach, describe, it } from "node:test";
 import { buildWorkflowReceipt, readWorkflowReceipt, resolveWorkflowReceiptResume, workflowReceiptPath, writeWorkflowReceipt } from "../../src/workflows/workflow-receipt.ts";
 import { externalCliReceiptMetadata, resolveExternalCliRunnerStatus } from "../../src/runs/shared/external-cli-contract.ts";
 import type { WorkflowScriptChildResult } from "../../src/workflows/scripted-workflow.ts";
-import type { HostStepNodeV1 } from "../../src/shared/types.ts";
+import type { HostStepNode } from "../../src/shared/types.ts";
 import { parseWorkflowChildSummary, workflowChildSummary } from "../../src/workflows/workflow-child-summary.ts";
 
 const roots: string[] = [];
@@ -39,7 +39,7 @@ function child(key: string, overrides: Partial<WorkflowScriptChildResult> = {}):
 	};
 }
 
-function hostStep(overrides: Partial<HostStepNodeV1> = {}): HostStepNodeV1 {
+function hostStep(overrides: Partial<HostStepNode> = {}): HostStepNode {
 	return {
 		version: 1,
 		kind: "host-step",
@@ -458,4 +458,4 @@ describe("workflow child session names", () => {
 		});
 		assert.throws(() => readWorkflowReceipt(root, "workflow-1"), /sessionName is invalid/);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/workflow-resources.test.ts

@@ -1,5 +1,6 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
+import { registerWorkflowResource, type WorkflowResourceDefinition } from "../../src/api/workflow-resources.ts";
 import {
 	authorizeWorkflowResourceHost,
 	consumeWorkflowResourcePermit,
@@ -8,6 +9,128 @@ import { resolveWorkflowResource } from "../../src/workflows/workflow-resources.
 import { runWorkflowScript, WorkflowScriptError } from "../../src/workflows/scripted-workflow.ts";
 
 describe("named workflow resources", () => {
+	it("scopes registrations by session and snapshots definitions, args and issued grants", () => {
+		const args = { nested: { task: "original" } };
+		const expansion = { script: "return 'original';", hostCommands: [{ key: "check", command: " node check.mjs " }, { key: "other", command: "node other.mjs" }] };
+		const definition: WorkflowResourceDefinition = {
+			name: "acme.check", version: 2,
+			resolve(input) {
+				(input.nested as { task: string }).task = "changed";
+				return expansion;
+			},
+		};
+		const registration = registerWorkflowResource({ sessionId: "one", definition });
+		const other = registerWorkflowResource({ sessionId: "two", definition: { ...definition, resolve: () => ({ script: "return 'two';" }) } });
+		try {
+			definition.version = 99;
+			definition.resolve = () => ({ error: "replacement must not run" });
+			assert.throws(() => registerWorkflowResource({ sessionId: "one", definition }), /already registered/);
+			assert.equal(resolveWorkflowResource("acme.check", args).ok, false);
+			assert.equal(resolveWorkflowResource("acme.check", args, "wrong").ok, false);
+			const resolved = resolveWorkflowResource("acme.check", args, "one");
+			assert.equal(resolved.ok, true);
+			if (!resolved.ok) return;
+			assert.equal(args.nested.task, "original");
+			assert.equal(resolved.resource.provenance.version, 2);
+			expansion.script = "return 'changed';";
+			expansion.hostCommands[0].command = "node changed.mjs";
+			registration.dispose();
+			assert.equal(resolveWorkflowResource("acme.check", args, "one").ok, false);
+			const replacement = registerWorkflowResource({ sessionId: "one", definition: { ...definition, resolve: () => ({ script: "return 'new';" }) } });
+			try {
+				registration.dispose();
+				assert.equal(resolveWorkflowResource("acme.check", {}, "one").ok, true);
+				assert.equal(resolveWorkflowResource("acme.check", {}, "two").ok, true);
+				const consumed = consumeWorkflowResourcePermit(resolved.resource.permit, resolved.resource.script);
+				assert.equal(typeof consumed, "object");
+				assert.equal(resolved.resource.script, "return 'original';");
+				assert.equal(authorizeWorkflowResourceHost(resolved.resource.permit, "check", "node check.mjs"), undefined);
+				assert.equal(authorizeWorkflowResourceHost(resolved.resource.permit, "other", "node other.mjs"), undefined);
+				assert.match(authorizeWorkflowResourceHost(resolved.resource.permit, "check", "node other.mjs")!, /not allowed/);
+				assert.match(authorizeWorkflowResourceHost(resolved.resource.permit, "other", "node check.mjs")!, /not allowed/);
+				assert.match(authorizeWorkflowResourceHost(resolved.resource.permit, "check", "node changed.mjs")!, /not allowed/);
+				assert.match(consumeWorkflowResourcePermit(resolved.resource.permit, resolved.resource.script) as string, /already consumed/);
+			} finally { replacement.dispose(); }
+		} finally { registration.dispose(); other.dispose(); }
+	});
+
+	it("lets trusted validation select fixed commands while task text remains data", async () => {
+		const registration = registerWorkflowResource({ sessionId: "binding", definition: {
+			name: "acme.review-check", version: 1,
+			resolve(args) {
+				if (Object.keys(args).some((key) => key !== "task" && key !== "check") || typeof args.task !== "string" || args.check !== "quick") return { error: "Only task and check=quick are supported." };
+				return { script: `return ${JSON.stringify(args.task)};`, hostCommands: [{ key: "check", command: "node check.mjs --quick" }] };
+			},
+		} });
+		try {
+			const task = `\"); await runs.host("injected", { command: "bad" }); //`;
+			const resolved = resolveWorkflowResource("acme.review-check", { task, check: "quick" }, "binding");
+			assert.equal(resolved.ok, true);
+			if (!resolved.ok) return;
+			const execution = await runWorkflowScript({
+				script: resolved.resource.script,
+				async launch() { throw new Error("No child expected"); },
+				async status() { throw new Error("No status expected"); },
+			});
+			assert.equal(execution.value, task);
+			for (const args of [{ task, check: "quick; bad" }, { task, check: "quick", flags: "--extra" }, { task, check: "quick", command: "bad" }, { task: new Date(), check: "quick" }, { task: "x".repeat(16385), check: "quick" }]) {
+				assert.equal(resolveWorkflowResource("acme.review-check", args, "binding").ok, false);
+			}
+		} finally { registration.dispose(); }
+	});
+
+	it("rejects invalid registrations and protects builtin names", () => {
+		const valid = { sessionId: "validation", definition: { name: "acme.check", version: 1, resolve: () => ({ script: "return true;" }) } };
+		for (const input of [
+			{ ...valid, sessionId: " " },
+			{ ...valid, trusted: true },
+			{ ...valid, definition: { ...valid.definition, name: "run-ci" } },
+			{ ...valid, definition: { ...valid.definition, name: "review" } },
+			{ ...valid, definition: { ...valid.definition, name: "bad name" } },
+			{ ...valid, definition: { ...valid.definition, version: 0 } },
+			{ ...valid, definition: { ...valid.definition, resolve: undefined } },
+			{ ...valid, definition: { ...valid.definition, issuerPackage: "trusted" } },
+		]) assert.throws(() => registerWorkflowResource(input as typeof valid));
+	});
+
+	it("contains throws, async results and malformed expansions without issuing permits", async () => {
+		const invalid = [
+			() => { throw new Error("x".repeat(5000)); },
+			() => Promise.reject(new Error("async rejection")),
+			() => ({ then(resolve: (value: unknown) => void) { resolve({ script: "return true;" }); } }),
+			() => null,
+			() => ({ script: " " }),
+			() => ({ script: "return true;", authority: {} }),
+			() => ({ error: 42 }),
+			() => ({ script: "return true;", hostCommands: { keys: ["a"], commands: ["node a.mjs"] } }),
+			() => ({ script: "return true;", hostCommands: [{ key: "a", command: "node a.mjs" }, { key: "a", command: "node b.mjs" }] }),
+			() => ({ script: "return true;", hostCommands: [{ key: "../a", command: "node a.mjs" }] }),
+			() => ({ script: "return true;", hostCommands: [{ key: "a", command: "node\0a" }] }),
+		];
+		for (const resolve of invalid) {
+			const registration = registerWorkflowResource({ sessionId: "invalid", definition: { name: "acme.invalid", version: 1, resolve: resolve as WorkflowResourceDefinition["resolve"] } });
+			try {
+				const result = resolveWorkflowResource("acme.invalid", {}, "invalid");
+				assert.equal(result.ok, false);
+				assert.equal("resource" in result, false);
+				if (!result.ok) assert.ok(result.error.length <= 4096);
+			} finally { registration.dispose(); }
+		}
+		await new Promise<void>((resolve) => setImmediate(resolve));
+	});
+
+	it("shares registrations across evaluated module copies", async () => {
+		const copy = await import(`../../src/workflows/workflow-resources.ts?copy=registration-test`);
+		const registration = copy.registerWorkflowResource({ sessionId: "copies", definition: { name: "acme.copy", version: 1, resolve: () => ({ script: "return true;" }) } });
+		try {
+			assert.notEqual(copy.resolveWorkflowResource, resolveWorkflowResource);
+			const resolved = resolveWorkflowResource("acme.copy", {}, "copies");
+			assert.equal(resolved.ok, true);
+			if (resolved.ok) assert.equal(typeof consumeWorkflowResourcePermit(resolved.resource.permit, resolved.resource.script), "object");
+		} finally { registration.dispose(); }
+		assert.equal(resolveWorkflowResource("acme.copy", {}, "copies").ok, false);
+	});
+
 	it("resolves and executes an extension-owned named workflow script", async () => {
 		const resolved = resolveWorkflowResource("run-ci", { command: "npm test", timeoutMs: 1_000 });
 		assert.equal(resolved.ok, true);
@@ -85,6 +208,15 @@ describe("named workflow resources", () => {
 		}
 	});
 
+	it("rejects argument validation failures even when the error message is empty", () => {
+		const registration = registerWorkflowResource({ sessionId: "invalid-args", definition: {
+			name: "check-args", version: 1, resolve: () => assert.fail("invalid args reached the resolver"),
+		} });
+		try {
+			assert.deepEqual(resolveWorkflowResource("check-args", { get task() { throw new Error(""); } }, "invalid-args"), { ok: false, error: "" });
+		} finally { registration.dispose(); }
+	});
+
 	it("reports unauthorized raw host execution through the workflow primitive when no host is supplied", async () => {
 		await assert.rejects(
 			runWorkflowScript({
@@ -95,4 +227,4 @@ describe("named workflow resources", () => {
 			(error: unknown) => error instanceof WorkflowScriptError && /runs\.host is unavailable/.test(error.message),
 		);
 	});
-});
+});

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

@@ -5,6 +5,7 @@ import * as path from "node:path";
 import { afterEach, describe, it } from "node:test";
 import { createSubagentExecutor } from "../../src/runs/foreground/subagent-executor.ts";
 import { resolveAsyncResumeTarget } from "../../src/runs/background/async-resume.ts";
+import { parallelHandoffPath } from "../../src/runs/shared/parallel-handoff.ts";
 import { DIRS, type AsyncStatus, type SubagentState } from "../../src/shared/types.ts";
 
 const cleanupRoots: string[] = [];
@@ -65,6 +66,7 @@ function writeRetainedChild(input: {
 	sessionId: string;
 	state?: AsyncStatus["state"];
 	stepStatus?: NonNullable<AsyncStatus["steps"]>[number]["status"];
+	mode?: "single" | "workflow";
 	writeSession?: boolean;
 }): void {
 	const childDir = path.join(DIRS.async, input.childRunId);
@@ -76,7 +78,7 @@ function writeRetainedChild(input: {
 	fs.writeFileSync(path.join(childDir, "status.json"), JSON.stringify({
 		runId: input.childRunId,
 		sessionId: input.sessionId,
-		mode: "single",
+		mode: input.mode ?? "single",
 		state,
 		startedAt: 100,
 		endedAt: state === "complete" ? 200 : undefined,
@@ -86,6 +88,35 @@ function writeRetainedChild(input: {
 	}), "utf-8");
 }
 
+function writeManagedWorktreeHandoff(root: string, childRunId: string): void {
+	const childDir = path.join(DIRS.async, childRunId);
+	const worktreePath = path.join(root, `${childRunId}-worktree`);
+	fs.mkdirSync(worktreePath, { recursive: true });
+	fs.writeFileSync(parallelHandoffPath(childDir), JSON.stringify({
+		version: 1,
+		runId: childRunId,
+		mode: "single",
+		source: "async",
+		cwd: root,
+		createdAt: 100,
+		updatedAt: 200,
+		groups: [{
+			stepIndex: 0,
+			baseCommit: "a".repeat(40),
+			repoRoot: root,
+			children: [{
+				index: 0,
+				taskIndex: 0,
+				agent: "worker",
+				status: "completed",
+				summary: "done",
+				patch: { path: path.join(root, "patch.diff"), branch: "work", changed: false, diffStat: "", filesChanged: 0, insertions: 0, deletions: 0 },
+			}],
+			cleanup: { state: "partial", pruned: false, tasks: [{ index: 0, path: worktreePath, branch: "work", worktreeRemoved: false, branchRemoved: false }] },
+		}],
+	}), "utf-8");
+}
+
 function writeWorkflowStatus(input: {
 	parentRunId: string;
 	childRunId: string;
@@ -175,6 +206,26 @@ describe("workflow keyed resume recovery hint", () => {
 		cleanupRun(childRunId);
 	});
 
+	it("rejects explicit baseRef when resuming a retained managed-worktree child", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-managed-worktree-resume-base-ref-"));
+		cleanupRoots.push(root);
+		const { childRunId } = makeIds("managed-base-ref");
+		writeRetainedChild({ root, childRunId, sessionId: "session-1644", mode: "workflow" });
+		writeManagedWorktreeHandoff(root, childRunId);
+
+		const result = await createExecutor(createState("session-1644"), root).execute(
+			`managed-worktree-resume-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+			{ action: "resume", id: childRunId, message: "Continue", baseRef: "refs/heads/release", worktree: true },
+			new AbortController().signal,
+			undefined,
+			createContext(root),
+		);
+
+		assert.equal(result.isError, true);
+		assert.match(result.content.map((part) => part.text ?? "").join("\n"), /retained managed-worktree children continue in their existing worktree/);
+		cleanupRun(childRunId);
+	});
+
 	it("does not hint when status proof or direct resumability is not safe", async () => {
 		const cases: Array<{
 			name: string;
@@ -362,4 +413,4 @@ describe("workflow keyed resume recovery hint", () => {
 			cleanupRun(childRunId);
 		}
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/worktree-cleanup-plan.test.ts

@@ -30,6 +30,18 @@ function createRepo(prefix: string): string {
 	return repo;
 }
 
+function createHookScript(fileName: string, source: string): string {
+	const hooksDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-cleanup-plan-hook-script-"));
+	const hookPath = path.join(hooksDir, fileName);
+	fs.writeFileSync(hookPath, `#!/usr/bin/env node\n${source}\n`, "utf-8");
+	fs.chmodSync(hookPath, 0o755);
+	return hookPath;
+}
+
+const hookScriptSkip = process.platform === "win32"
+	? "Hook script execution differs on Windows CI environments."
+	: undefined;
+
 function removeGeneratedWorktrees(repo: string, setup: WorktreeSetup | undefined): void {
 	for (const worktree of setup?.worktrees ?? []) {
 		try { execFileSync("git", ["-C", repo, "worktree", "remove", "--force", worktree.path], { stdio: "ignore" }); } catch {}
@@ -101,7 +113,7 @@ function writeManifest(input: {
 			},
 		}],
 	}, null, 2), "utf-8");
-	if (patch.changed) fs.writeFileSync(patch.path, "captured patch\n", "utf-8");
+	if (patch.changed) fs.writeFileSync(patch.path, execFileSync("git", ["-C", worktree.path, "diff", "--binary", baseCommit, "HEAD"], { encoding: "utf-8" }), "utf-8");
 }
 
 function entriesByPath(plan: WorktreeCleanupPlan): Map<string, WorktreeCleanupPlan["entries"][number]> {
@@ -136,12 +148,12 @@ describe("worktree cleanup plan", () => {
 		assert.equal(fallbackCalls, 1);
 	});
 
-	it("builds and persists a deterministic metadata-backed plan without removing worktrees", () => {
+	it("builds and persists a deterministic metadata-backed plan without removing worktrees", async () => {
 		const repo = createRepo("pi-cleanup-plan-safe-");
 		const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-cleanup-plan-base-"));
 		let setup: WorktreeSetup | undefined;
 		try {
-			setup = createWorktrees(repo, "safe", 1, { baseDir });
+			setup = await createWorktrees(repo, "safe", 1, { baseDir });
 			const manifestPath = path.join(repo, ".pi-subagents", "artifacts", "handoff.json");
 			writeManifest({ repo, manifestPath, setup });
 			fs.mkdirSync(path.join(baseDir, "unrelated-directory"));
@@ -182,12 +194,12 @@ describe("worktree cleanup plan", () => {
 		}
 	});
 
-	it("keeps dirty and unowned worktrees out of the removable set", () => {
+	it("keeps dirty and unowned worktrees out of the removable set", async () => {
 		const repo = createRepo("pi-cleanup-plan-unknown-");
 		const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-cleanup-plan-base-"));
 		let setup: WorktreeSetup | undefined;
 		try {
-			setup = createWorktrees(repo, "unknown", 2, { baseDir });
+			setup = await createWorktrees(repo, "unknown", 2, { baseDir });
 			const manifestPath = path.join(repo, ".pi-subagents", "artifacts", "handoff.json");
 			writeManifest({ repo, manifestPath, setup });
 			fs.writeFileSync(path.join(setup.worktrees[0]!.path, "tracked.txt"), "dirty\n", "utf-8");
@@ -211,12 +223,12 @@ describe("worktree cleanup plan", () => {
 		}
 	});
 
-	it("keeps active async ownership and reports missing Git worktrees as stale", () => {
+	it("keeps active async ownership and reports missing Git worktrees as stale", async () => {
 		const repo = createRepo("pi-cleanup-plan-active-");
 		const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-cleanup-plan-base-"));
 		let setup: WorktreeSetup | undefined;
 		try {
-			setup = createWorktrees(repo, "active", 1, { baseDir });
+			setup = await createWorktrees(repo, "active", 1, { baseDir });
 			const asyncDir = path.join(repo, ".pi-subagents", "async", "active-run");
 			const manifestPath = path.join(asyncDir, "handoff.json");
 			writeManifest({ repo, manifestPath, setup, runId: "active-run", source: "async" });
@@ -240,12 +252,12 @@ describe("worktree cleanup plan", () => {
 		}
 	});
 
-	it("requires foreground ownership proof instead of inferring activity from the artifacts directory", () => {
+	it("requires foreground ownership proof instead of inferring activity from the artifacts directory", async () => {
 		const repo = createRepo("pi-cleanup-plan-foreground-");
 		const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-cleanup-plan-base-"));
 		let setup: WorktreeSetup | undefined;
 		try {
-			setup = createWorktrees(repo, "foreground", 1, { baseDir });
+			setup = await createWorktrees(repo, "foreground", 1, { baseDir });
 			const manifestPath = path.join(repo, ".pi-subagents", "artifacts", "handoff.json");
 			writeManifest({ repo, manifestPath, setup, runId: "foreground-run", source: "foreground" });
 			const noProof = buildWorktreeCleanupPlan({ repo, handoffPath: manifestPath, worktreeBaseDir: baseDir, now: 35_000, planId: "foreground-no-proof" });
@@ -263,12 +275,12 @@ describe("worktree cleanup plan", () => {
 		}
 	});
 
-	it("requires a recorded patch or local target ancestry for committed divergence", () => {
+	it("requires a recorded patch or local target ancestry for committed divergence", async () => {
 		const repo = createRepo("pi-cleanup-plan-divergence-");
 		const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-cleanup-plan-base-"));
 		let setup: WorktreeSetup | undefined;
 		try {
-			setup = createWorktrees(repo, "divergence", 1, { baseDir });
+			setup = await createWorktrees(repo, "divergence", 1, { baseDir });
 			const manifestPath = path.join(repo, ".pi-subagents", "artifacts", "handoff.json");
 			writeManifest({ repo, manifestPath, setup });
 			const worktree = setup.worktrees[0]!;
@@ -294,12 +306,39 @@ describe("worktree cleanup plan", () => {
 		}
 	});
 
-	it("keeps stale markers, pending captures, and inconsistent cleanup metadata non-removable", () => {
+	it("does not let trusted external diff hide cleanup-plan divergence", { skip: hookScriptSkip }, async () => {
+		const repo = createRepo("pi-cleanup-plan-external-diff-");
+		const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-cleanup-plan-base-"));
+		const externalDiffPath = createHookScript("external-diff-plan.mjs", "process.exit(0);");
+		let setup: WorktreeSetup | undefined;
+		try {
+			setup = await createWorktrees(repo, "external-diff", 1, { baseDir });
+			const manifestPath = path.join(repo, ".pi-subagents", "artifacts", "handoff.json");
+			writeManifest({ repo, manifestPath, setup });
+			const worktree = setup.worktrees[0]!;
+			fs.writeFileSync(path.join(worktree.path, "unmerged.txt"), "unmerged\n", "utf-8");
+			git(worktree.path, ["add", "unmerged.txt"]);
+			git(worktree.path, ["commit", "-m", "unmerged"]);
+			git(repo, ["config", "diff.external", externalDiffPath]);
+			git(repo, ["config", "diff.trustExitCode", "true"]);
+
+			const plan = buildPlan({ repo, worktreeBaseDir: baseDir, now: 40_000, planId: "external-diff-plan" });
+			assert.equal(plan.entries[0]?.decision, "keep");
+			assert.equal(plan.entries[0]?.state, "ineligible");
+			assert.match(plan.entries[0]?.reasons.join(" ") ?? "", /neither preserved.*nor merged/i);
+		} finally {
+			removeGeneratedWorktrees(repo, setup);
+			fs.rmSync(repo, { recursive: true, force: true });
+			fs.rmSync(baseDir, { recursive: true, force: true });
+		}
+	});
+
+	it("keeps stale markers, pending captures, and inconsistent cleanup metadata non-removable", async () => {
 		const repo = createRepo("pi-cleanup-plan-stale-");
 		const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-cleanup-plan-base-"));
 		let setup: WorktreeSetup | undefined;
 		try {
-			setup = createWorktrees(repo, "stale", 1, { baseDir });
+			setup = await createWorktrees(repo, "stale", 1, { baseDir });
 			const asyncDir = path.join(repo, ".pi-subagents", "async", "stale-run");
 			const manifestPath = path.join(asyncDir, "handoff.json");
 			writeManifest({ repo, manifestPath, setup, runId: "stale-run", source: "async" });
@@ -346,4 +385,173 @@ describe("worktree cleanup plan", () => {
 			fs.rmSync(baseDir, { recursive: true, force: true });
 		}
 	});
-});
+
+	it("treats nested project directory as cleanup containment root", async () => {
+		const repo = createRepo("pi-cleanup-plan-nested-root-");
+		const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-cleanup-plan-nested-base-"));
+		let setup: WorktreeSetup | undefined;
+		try {
+			setup = await createWorktrees(repo, "nested-root", 1, { baseDir });
+			const manifestPath = path.join(repo, ".pi-subagents", "artifacts", "handoff.json");
+			writeManifest({ repo, manifestPath, setup });
+			const plan = buildPlan({ repo, worktreeBaseDir: baseDir, now: 60_000, planId: "nested-root-plan" });
+			assert.equal(plan.baseDirs[0], path.join(baseDir, path.basename(repo)));
+			assert.equal(plan.entries[0]?.decision, "remove");
+			assert.equal(plan.entries[0]?.state, "safe");
+		} finally {
+			removeGeneratedWorktrees(repo, setup);
+			fs.rmSync(repo, { recursive: true, force: true });
+			fs.rmSync(baseDir, { recursive: true, force: true });
+		}
+	});
+
+	it("uses git toplevel parent as default cleanup root when input.repo is a subdirectory", async () => {
+		const repo = createRepo("pi-cleanup-plan-subdir-root-");
+		const previous = process.env.SELESAI_SUBAGENTS_WORKTREE_DIR;
+		delete process.env.SELESAI_SUBAGENTS_WORKTREE_DIR;
+		let setup: WorktreeSetup | undefined;
+		try {
+			fs.mkdirSync(path.join(repo, "packages", "app"), { recursive: true });
+			setup = await createWorktrees(repo, "from-subdir", 1, { provider: "native" });
+			const manifestPath = path.join(repo, ".pi-subagents", "artifacts", "handoff.json");
+			writeManifest({ repo, manifestPath, setup });
+			const plan = buildPlan({ repo: path.join(repo, "packages", "app"), now: 61_500, planId: "subdir-root-plan" });
+			const realRepo = __testables.realpathExisting(repo);
+			assert.equal(plan.baseDirs[0], path.join(path.dirname(realRepo), "worktrees", path.basename(realRepo)));
+			const entry = entriesByPath(plan).get(__testables.realpathExisting(setup.worktrees[0]!.path)) ?? plan.entries[0];
+			assert.equal(entry?.decision, "remove");
+			assert.equal(entry?.state, "safe");
+		} finally {
+			if (previous === undefined) delete process.env.SELESAI_SUBAGENTS_WORKTREE_DIR;
+			else process.env.SELESAI_SUBAGENTS_WORKTREE_DIR = previous;
+			removeGeneratedWorktrees(repo, setup);
+			fs.rmSync(repo, { recursive: true, force: true });
+		}
+	});
+
+	it("marks flat dedicatedRoot leaves ineligible", () => {
+		const repo = createRepo("pi-cleanup-plan-flat-leaf-");
+		const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-cleanup-plan-flat-base-"));
+		const worktreePath = path.join(baseDir, "pi-worktree-flat-0");
+		const branch = "pi-parallel-flat-0";
+		let setup: WorktreeSetup | undefined;
+		try {
+			git(repo, ["worktree", "add", "-b", branch, worktreePath]);
+			setup = {
+				cwd: repo,
+				worktrees: [{
+					path: worktreePath,
+					agentCwd: worktreePath,
+					branch,
+					index: 0,
+					nodeModulesLinked: false,
+					syntheticPaths: [],
+				}],
+				baseCommit: git(repo, ["rev-parse", "HEAD"]),
+			};
+			const manifestPath = path.join(repo, ".pi-subagents", "artifacts", "handoff.json");
+			writeManifest({ repo, manifestPath, setup, preserved: true });
+			const plan = buildPlan({ repo, worktreeBaseDir: baseDir, now: 62_000, planId: "flat-leaf-plan" });
+			const entry = entriesByPath(plan).get(__testables.realpathExisting(worktreePath)) ?? plan.entries[0];
+			assert.equal(entry?.decision, "keep");
+			assert.equal(entry?.state, "ineligible");
+			assert.match(entry?.reasons.join(" ") ?? "", /outside configured base directory|outside the project worktree directory/i);
+		} finally {
+			removeGeneratedWorktrees(repo, setup);
+			fs.rmSync(repo, { recursive: true, force: true });
+			fs.rmSync(baseDir, { recursive: true, force: true });
+		}
+	});
+
+	it("marks checkout-internal worktrees ineligible when base is the repos parent", () => {
+		const repo = createRepo("pi-cleanup-plan-checkout-internal-");
+		const worktreePath = path.join(repo, "pi-worktree-internal-0");
+		const branch = "pi-parallel-internal-0";
+		let setup: WorktreeSetup | undefined;
+		try {
+			git(repo, ["worktree", "add", "-b", branch, worktreePath]);
+			setup = {
+				cwd: repo,
+				worktrees: [{
+					path: worktreePath,
+					agentCwd: worktreePath,
+					branch,
+					index: 0,
+					nodeModulesLinked: false,
+					syntheticPaths: [],
+				}],
+				baseCommit: git(repo, ["rev-parse", "HEAD"]),
+			};
+			const manifestPath = path.join(repo, ".pi-subagents", "artifacts", "handoff.json");
+			writeManifest({ repo, manifestPath, setup, preserved: true });
+			const plan = buildPlan({ repo, worktreeBaseDir: path.dirname(repo), now: 63_000, planId: "checkout-internal-plan" });
+			const entry = entriesByPath(plan).get(__testables.realpathExisting(worktreePath)) ?? plan.entries[0];
+			assert.equal(entry?.decision, "keep");
+			assert.equal(entry?.state, "ineligible");
+			assert.notEqual(entry?.decision, "remove");
+		} finally {
+			removeGeneratedWorktrees(repo, setup);
+			fs.rmSync(repo, { recursive: true, force: true });
+		}
+	});
+
+	it("keeps a worktree whose project directory resolves into Pi extensions", () => {
+		const repo = createRepo("pi-cleanup-plan-extension-project-");
+		const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "pi-cleanup-plan-home-"));
+		const agentDir = path.join(tempHome, ".selesai", "agent");
+		const extensionsDir = path.join(agentDir, "extensions");
+		const baseDir = path.join(tempHome, "worktree-root");
+		const previousAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+		const previousHome = process.env.HOME;
+		const previousUserProfile = process.env.USERPROFILE;
+		const projectDir = path.join(baseDir, path.basename(repo));
+		const worktreePath = path.join(projectDir, "pi-worktree-extension-project-0");
+		const branch = "pi-parallel-extension-project-0";
+		let setup: WorktreeSetup | undefined;
+		try {
+			fs.mkdirSync(extensionsDir, { recursive: true });
+			fs.mkdirSync(baseDir, { recursive: true });
+			fs.symlinkSync(extensionsDir, projectDir, process.platform === "win32" ? "junction" : "dir");
+			process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+			process.env.HOME = tempHome;
+			process.env.USERPROFILE = tempHome;
+
+			git(repo, ["worktree", "add", "-b", branch, worktreePath]);
+			setup = {
+				cwd: repo,
+				worktrees: [{ path: worktreePath, agentCwd: worktreePath, branch, index: 0, nodeModulesLinked: false, syntheticPaths: [] }],
+				baseCommit: git(repo, ["rev-parse", "HEAD"]),
+			};
+			const manifestPath = path.join(repo, ".pi-subagents", "artifacts", "handoff.json");
+			writeManifest({ repo, manifestPath, setup, preserved: true });
+			const plan = buildPlan({ repo, worktreeBaseDir: baseDir, now: 64_000, planId: "extension-project-plan" });
+			const entry = entriesByPath(plan).get(__testables.realpathExisting(worktreePath)) ?? plan.entries[0];
+			assert.equal(entry?.decision, "keep");
+			assert.equal(entry?.state, "ineligible");
+			assert.match(entry?.reasons.join(" ") ?? "", /Pi extensions directory/i);
+		} finally {
+			if (previousAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
+			else process.env.SELESAI_CODING_AGENT_DIR = previousAgentDir;
+			if (previousHome === undefined) delete process.env.HOME;
+			else process.env.HOME = previousHome;
+			if (previousUserProfile === undefined) delete process.env.USERPROFILE;
+			else process.env.USERPROFILE = previousUserProfile;
+			removeGeneratedWorktrees(repo, setup);
+			fs.rmSync(repo, { recursive: true, force: true });
+			fs.rmSync(baseDir, { recursive: true, force: true });
+			fs.rmSync(tempHome, { recursive: true, force: true });
+		}
+	});
+
+	it("rejects empty cleanup worktree base directory", () => {
+		const repo = createRepo("pi-cleanup-plan-empty-base-");
+		try {
+			assert.throws(
+				() => buildWorktreeCleanupPlan({ repo, worktreeBaseDir: "   " }),
+				/worktree base directory cannot be empty/,
+			);
+		} finally {
+			fs.rmSync(repo, { recursive: true, force: true });
+		}
+	});
+});