@selesai/code 0.5.19 → 0.5.21

package/dist/extensions/pi-subagents/test/unit/atomic-json.test.ts

@@ -7,14 +7,23 @@ class FakeFs {
 	files = new Map<string, string>();
 	madeDirs: string[] = [];
 	renameCalls = 0;
+	failMkdirCodes: string[] = [];
 	failRenameCodes: string[] = [];
+	writeOptions = new Map<string, unknown>();
 
 	mkdirSync(dirPath: string): void {
 		this.madeDirs.push(dirPath);
+		const failureCode = this.failMkdirCodes.shift();
+		if (failureCode) {
+			const error = new Error(`mkdir failed with ${failureCode}`) as NodeJS.ErrnoException;
+			error.code = failureCode;
+			throw error;
+		}
 	}
 
-	writeFileSync(filePath: string, contents: string): void {
+	writeFileSync(filePath: string, contents: string, options?: unknown): void {
 		this.files.set(filePath, contents);
+		this.writeOptions.set(filePath, options);
 	}
 
 	renameSync(sourcePath: string, targetPath: string): void {
@@ -65,6 +74,37 @@ describe("writeAtomicJson", () => {
 		assert.equal(fakeFs.files.size, 1);
 	});
 
+	it("retries transient directory creation failures before writing", () => {
+		const fakeFs = new FakeFs();
+		fakeFs.failMkdirCodes = ["EPERM", "EACCES"];
+		const waits: number[] = [];
+		const writeAtomicJson = createWriter(fakeFs, waits);
+		const targetPath = path.join("/tmp", "status.json");
+
+		writeAtomicJson(targetPath, { state: "running" });
+
+		assert.equal(fakeFs.renameCalls, 1);
+		assert.deepEqual(waits, [1, 2]);
+		assert.deepEqual(fakeFs.madeDirs, [path.dirname(targetPath), path.dirname(targetPath), path.dirname(targetPath)]);
+		assert.equal(fakeFs.files.get(targetPath), JSON.stringify({ state: "running" }, null, 2));
+	});
+
+	it("writes the temporary descriptor with the requested private mode", () => {
+		const fakeFs = new FakeFs();
+		const writeAtomicJson = createAtomicJsonWriter({
+			fs: fakeFs as any,
+			now: () => 12345,
+			pid: 678,
+			random: () => 0.5,
+			mode: 0o600,
+		});
+		const targetPath = path.join("/tmp", "recovery-descriptor.json");
+
+		writeAtomicJson(targetPath, { sourceRunId: "run" });
+
+		assert.deepEqual([...fakeFs.writeOptions.values()], [{ encoding: "utf-8", mode: 0o600 }]);
+	});
+
 	it("uses longer default retries for transient Windows rename locks", () => {
 		const fakeFs = new FakeFs();
 		fakeFs.failRenameCodes = ["EPERM", "EPERM", "EPERM", "EPERM", "EPERM", "EPERM"];

package/dist/extensions/pi-subagents/test/unit/auto-drain.test.ts

@@ -0,0 +1,79 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { drainOutstandingWork } from "../../src/runs/background/auto-drain.ts";
+import type { Details, SubagentState } from "../../src/shared/types.ts";
+
+function state(sessionId: string | null = "session-a"): SubagentState {
+	return { currentSessionId: sessionId } as SubagentState;
+}
+
+function waitResult(text: string, isError = false) {
+	return {
+		content: [{ type: "text" as const, text }],
+		...(isError ? { isError: true } : {}),
+		details: { mode: "management" as const, results: [] } satisfies Details,
+	};
+}
+
+describe("headless background-work auto-drain", () => {
+	it("is a no-op when the exact session has no work", async () => {
+		let waited = false;
+		await drainOutstandingWork({
+			state: state(),
+			hasWork: () => false,
+			wait: async () => { waited = true; return waitResult("unexpected"); },
+		});
+		assert.equal(waited, false);
+	});
+
+	it("loops until work added while draining is also gone", async () => {
+		let checks = 0;
+		const waits: Array<{ all?: boolean; timeoutMs?: number; stopOnAttention?: boolean; failOnFailedRuns?: boolean }> = [];
+		await drainOutstandingWork({
+			state: state(),
+			timeoutMs: 1000,
+			now: () => checks * 10,
+			hasWork: () => checks++ < 2,
+			wait: async (params, _signal, deps) => {
+				waits.push({ ...params, stopOnAttention: deps.stopOnAttention, failOnFailedRuns: deps.failOnFailedRuns });
+				return waitResult("done");
+			},
+		});
+		assert.equal(waits.length, 2);
+		assert.ok(waits.every((entry) => entry.all === true && entry.stopOnAttention === false && entry.failOnFailedRuns === true));
+		assert.ok((waits[1]!.timeoutMs ?? 0) < (waits[0]!.timeoutMs ?? 0), "each wait must share one absolute deadline");
+	});
+
+	it("preserves wait errors instead of treating them as a successful drain", async () => {
+		await assert.rejects(() => drainOutstandingWork({
+			state: state(),
+			hasWork: () => true,
+			wait: async () => waitResult("provider 'patty' snapshot failed", true),
+		}), /Auto-drain failed.*provider 'patty' snapshot failed/);
+	});
+
+	it("propagates work-discovery errors", async () => {
+		await assert.rejects(() => drainOutstandingWork({
+			state: state(),
+			hasWork: () => { throw new Error("provider reconcile failed"); },
+		}), /provider reconcile failed/);
+	});
+
+	it("enforces one absolute timeout across repeated drains", async () => {
+		let clock = 0;
+		await assert.rejects(() => drainOutstandingWork({
+			state: state(),
+			timeoutMs: 100,
+			now: () => clock,
+			hasWork: () => true,
+			wait: async () => {
+				clock = 101;
+				return waitResult("first batch done");
+			},
+		}), /timed out after 100ms.*session 'session-a'/);
+	});
+
+	it("fails without a session identity", async () => {
+		await assert.rejects(() => drainOutstandingWork({ state: state(null) }), /without an active session identity/);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/background-work.test.ts

@@ -0,0 +1,285 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, describe, it } from "node:test";
+import {
+	BACKGROUND_WORK_REGISTRY_KEY,
+	listBackgroundWorkProviders,
+	listBackgroundWorkWakeChannels,
+	registerBackgroundWorkProvider,
+	snapshotBackgroundWork,
+	type BackgroundWorkSnapshot,
+} from "../../src/api/background-work.ts";
+import { waitForSubagents, type SubagentWaitDeps } from "../../src/runs/background/subagent-wait.ts";
+import type { SubagentState } from "../../src/shared/types.ts";
+
+function clearRegistry(): void {
+	delete (globalThis as Record<PropertyKey, unknown>)[Symbol.for(BACKGROUND_WORK_REGISTRY_KEY)];
+}
+
+afterEach(clearRegistry);
+
+function makeState(sessionId = "session-a"): SubagentState {
+	return {
+		baseCwd: "",
+		currentSessionId: sessionId,
+		asyncJobs: new Map(),
+		foregroundControls: new Map(),
+		lastForegroundControlId: null,
+		cleanupTimers: new Map(),
+		lastUiContext: null,
+		poller: null,
+		completionSeen: new Map(),
+		watcher: null,
+		watcherRestartTimer: null,
+		resultFileCoalescer: { schedule: () => false, clear: () => {} },
+	} as SubagentState;
+}
+
+function writeStatus(root: string, id: string, state: string, sessionId = "session-a"): void {
+	const dir = path.join(root, id);
+	fs.mkdirSync(dir, { recursive: true });
+	const now = Date.now();
+	fs.writeFileSync(path.join(dir, "status.json"), JSON.stringify({
+		runId: id,
+		mode: "single",
+		state,
+		sessionId,
+		startedAt: now,
+		lastUpdate: now,
+		pid: 999999,
+		steps: [{ agent: "worker", status: state }],
+	}));
+}
+
+function waitDeps(root: string, state: SubagentState, backgroundWork: SubagentWaitDeps["backgroundWork"], sleep: () => Promise<void>): SubagentWaitDeps {
+	return {
+		state,
+		backgroundWork,
+		sleep,
+		pollIntervalMs: 250,
+		asyncDirRoot: path.join(root, "runs"),
+		resultsDir: path.join(root, "results"),
+		kill: () => true,
+	};
+}
+
+function textOf(result: { content: Array<{ type: string; text?: string }> }): string {
+	return result.content.map((part) => part.text ?? "").join("");
+}
+
+function snapshot(providers: string[], items: BackgroundWorkSnapshot["items"]): BackgroundWorkSnapshot {
+	return { providers, items };
+}
+
+describe("background-work provider protocol", () => {
+	it("replaces registrations safely across reloads and scopes snapshots to one session", () => {
+		let context: { sessionId: string; nowMs: number } | undefined;
+		const disposeOld = registerBackgroundWorkProvider({
+			name: "patty",
+			listActiveWork: () => [{ id: "old", sessionId: "session-a" }],
+		});
+		const replacement = {
+			name: "patty",
+			wakeChannels: ["patty:finished"],
+			reconcile: (value: { sessionId: string; nowMs: number }) => { context = value; },
+			listActiveWork: () => [
+				{ id: "mine", sessionId: "session-a" },
+				{ id: "theirs", sessionId: "session-b" },
+			],
+		};
+		const disposeReplacement = registerBackgroundWorkProvider(replacement);
+		disposeOld();
+
+		assert.deepEqual(listBackgroundWorkProviders(), [replacement]);
+		assert.deepEqual(listBackgroundWorkWakeChannels(), ["patty:finished"]);
+		assert.deepEqual(snapshotBackgroundWork("session-a", 42), {
+			providers: ["patty"],
+			items: [{ provider: "patty", id: "mine", sessionId: "session-a" }],
+		});
+		assert.deepEqual(context, { sessionId: "session-a", nowMs: 42 });
+
+		disposeReplacement();
+		assert.deepEqual(listBackgroundWorkProviders(), []);
+	});
+
+	it("validates provider metadata and work items strictly", () => {
+		assert.throws(() => registerBackgroundWorkProvider({ name: " patty", listActiveWork: () => [] }), /leading or trailing/);
+		assert.throws(() => registerBackgroundWorkProvider({ name: "patty", listActiveWork: () => [], wakeChannels: ["done", "done"] }), /duplicates/);
+
+		registerBackgroundWorkProvider({
+			name: "patty",
+			listActiveWork: () => [{ id: "job", sessionId: "session-a", extra: true } as never],
+		});
+		assert.throws(() => snapshotBackgroundWork("session-a"), /unknown fields: extra/);
+		clearRegistry();
+
+		registerBackgroundWorkProvider({
+			name: "patty",
+			listActiveWork: () => [
+				{ id: "job", sessionId: "session-a" },
+				{ id: "job", sessionId: "session-a" },
+			],
+		});
+		assert.throws(() => snapshotBackgroundWork("session-a"), /duplicate item 'job'/);
+	});
+
+	it("preserves list and reconcile errors with provider context", () => {
+		registerBackgroundWorkProvider({
+			name: "broken-reconcile",
+			reconcile: () => { throw new Error("pid probe failed"); },
+			listActiveWork: () => [],
+		});
+		assert.throws(() => snapshotBackgroundWork("session-a"), /broken-reconcile.*pid probe failed/);
+		clearRegistry();
+
+		registerBackgroundWorkProvider({
+			name: "broken-list",
+			listActiveWork: () => { throw new Error("registry unavailable"); },
+		});
+		assert.throws(() => snapshotBackgroundWork("session-a"), /broken-list.*registry unavailable/);
+	});
+
+	it("discovers wake channels without reconciling or listing work", () => {
+		let called = false;
+		registerBackgroundWorkProvider({
+			name: "patty",
+			wakeChannels: ["patty:finished"],
+			reconcile: () => { called = true; },
+			listActiveWork: () => { called = true; return []; },
+		});
+		assert.deepEqual(listBackgroundWorkWakeChannels(), ["patty:finished"]);
+		assert.equal(called, false);
+	});
+});
+
+describe("subagent_wait with background-work providers", () => {
+	it("detects completion when another item replaces it at the same count", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-provider-replace-"));
+		try {
+			let stage = 0;
+			const backgroundWork = {
+				wakeChannels: () => [],
+				snapshot: () => stage === 0
+					? snapshot(["patty"], [{ provider: "patty", id: "job-a", sessionId: "session-a" }])
+					: snapshot(["patty"], [{ provider: "patty", id: "job-b", sessionId: "session-a" }]),
+			};
+			const result = await waitForSubagents({}, undefined, waitDeps(root, makeState(), backgroundWork, async () => { stage = 1; }));
+			assert.equal(result.isError, undefined);
+			assert.match(textOf(result), /1 of 1 item\(s\) finished/);
+			assert.match(textOf(result), /provider item\(s\) finished/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("waits for both initial async and provider identities in all mode", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-provider-mixed-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			writeStatus(asyncRoot, "run-a", "running");
+			let stage = 0;
+			const backgroundWork = {
+				wakeChannels: () => [],
+				snapshot: () => snapshot(["patty"], stage < 2 ? [{ provider: "patty", id: "job-a", sessionId: "session-a" }] : []),
+			};
+			const result = await waitForSubagents({ all: true }, undefined, waitDeps(root, makeState(), backgroundWork, async () => {
+				stage += 1;
+				if (stage === 1) writeStatus(asyncRoot, "run-a", "complete");
+			}));
+			assert.equal(result.isError, undefined);
+			assert.match(textOf(result), /1 async run\(s\) and 1 provider item\(s\).*done/s);
+			assert.equal(stage, 2);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("fails closed when a provider disappears or its snapshot throws", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-provider-missing-"));
+		try {
+			let calls = 0;
+			const disappeared = await waitForSubagents({}, undefined, waitDeps(root, makeState(), {
+				wakeChannels: () => [],
+				snapshot: () => calls++ === 0
+					? snapshot(["patty"], [{ provider: "patty", id: "job-a", sessionId: "session-a" }])
+					: snapshot([], []),
+			}, async () => {}));
+			assert.equal(disappeared.isError, true);
+			assert.match(textOf(disappeared), /provider 'patty' disappeared/);
+
+			const failed = await waitForSubagents({}, undefined, waitDeps(root, makeState(), {
+				wakeChannels: () => [],
+				snapshot: () => { throw new Error("provider registry failed"); },
+			}, async () => {}));
+			assert.equal(failed.isError, true);
+			assert.match(textOf(failed), /provider registry failed/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("can continue through needs-attention while draining", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-provider-attention-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			writeStatus(asyncRoot, "run-a", "running");
+			const statusPath = path.join(asyncRoot, "run-a", "status.json");
+			const status = JSON.parse(fs.readFileSync(statusPath, "utf-8"));
+			fs.writeFileSync(statusPath, JSON.stringify({ ...status, activityState: "needs_attention" }));
+			let polls = 0;
+			const result = await waitForSubagents({ all: true }, undefined, {
+				...waitDeps(root, makeState(), { wakeChannels: () => [], snapshot: () => snapshot([], []) }, async () => {
+					polls += 1;
+					writeStatus(asyncRoot, "run-a", "complete");
+				}),
+				stopOnAttention: false,
+			});
+			assert.equal(result.isError, undefined);
+			assert.equal(polls, 1);
+			assert.match(textOf(result), /done/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("wakes on a provider channel instead of the poll interval", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-provider-event-"));
+		try {
+			let active = true;
+			const handlers = new Map<string, Array<(data: unknown) => void>>();
+			const events = {
+				on(channel: string, handler: (data: unknown) => void) {
+					const channelHandlers = handlers.get(channel) ?? [];
+					channelHandlers.push(handler);
+					handlers.set(channel, channelHandlers);
+					return () => handlers.set(channel, (handlers.get(channel) ?? []).filter((candidate) => candidate !== handler));
+				},
+				emit(channel: string) {
+					for (const handler of handlers.get(channel) ?? []) handler(undefined);
+				},
+			};
+			const backgroundWork = {
+				wakeChannels: () => ["patty:finished"],
+				snapshot: () => snapshot(["patty"], active ? [{ provider: "patty", id: "job-a", sessionId: "session-a" }] : []),
+			};
+			const promise = waitForSubagents({}, undefined, {
+				...waitDeps(root, makeState(), backgroundWork, async (ms?: number, signal?: AbortSignal) => {
+					await new Promise<void>((resolve) => {
+						const timer = setTimeout(resolve, ms ?? 10_000);
+						signal?.addEventListener("abort", () => { clearTimeout(timer); resolve(); }, { once: true });
+					});
+				}),
+				events,
+				pollIntervalMs: 10_000,
+			});
+			setTimeout(() => { active = false; events.emit("patty:finished"); }, 15);
+			const result = await promise;
+			assert.equal(result.isError, undefined);
+			assert.match(textOf(result), /provider item\(s\) finished/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+});

package/dist/extensions/pi-subagents/test/unit/capability-ceiling-pi-args.test.ts

@@ -0,0 +1,84 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { buildPiArgs } from "../../src/runs/shared/pi-args.ts";
+
+describe("capability ceiling child launch enforcement", () => {
+	const base = {
+		baseArgs: [] as string[],
+		task: "test",
+		sessionEnabled: false,
+		inheritProjectContext: false,
+		inheritSkills: false,
+	};
+
+	it("intersects declared tools and preserves structured output as an internal tool", () => {
+		const { args, env } = buildPiArgs({
+			...base,
+			tools: ["read", "write", "subagent"],
+			capabilityCeiling: { version: 1, allowedTools: ["read", "structured_output"], denyExtensions: false, sources: ["test"] },
+			structuredOutput: { schema: {}, schemaPath: "/tmp/schema.json", outputPath: "/tmp/output.json" },
+		});
+		assert.deepEqual(args.slice(args.indexOf("--tools") + 1, args.indexOf("--tools") + 2), ["read,structured_output"]);
+		assert.equal(env.SELESAI_SUBAGENT_CAPABILITY_CEILING_V1 !== undefined, true);
+		assert.equal(args.includes("write"), false);
+		assert.equal(args.includes("subagent"), false);
+	});
+
+	it("allows a valid empty intersection and denies configured extensions", () => {
+		const { args } = buildPiArgs({
+			...base,
+			tools: ["read", "/tmp/provider.ts"],
+			extensions: ["/tmp/extension.ts"],
+			capabilityCeiling: { version: 1, allowedTools: [], denyExtensions: true, sources: ["plan"] },
+		});
+		assert.ok(args.includes("--no-tools"));
+		assert.ok(args.includes("--no-extensions"));
+		assert.equal(args.includes("/tmp/provider.ts"), false);
+		assert.equal(args.includes("/tmp/extension.ts"), false);
+	});
+
+	it("restricts omitted tool declarations without requiring every allowed name", () => {
+		const { args, env } = buildPiArgs({
+			...base,
+			capabilityCeiling: { version: 1, allowedTools: ["read", "grep"], denyExtensions: true, sources: ["plan"] },
+		});
+		assert.ok(args.includes("--tools"));
+		assert.ok(args.includes("grep,read"));
+		assert.equal(env.SELESAI_SUBAGENT_REQUIRED_TOOLS, undefined);
+	});
+
+
+	it("does not report retained extension paths as removed tools", () => {
+		const { capabilityAudit } = buildPiArgs({
+			...base,
+			tools: ["read", "/tmp/provider.ts"],
+			extensions: ["/tmp/extension.ts"],
+			capabilityCeiling: { version: 1, allowedTools: ["read"], denyExtensions: false, sources: ["plan"] },
+		});
+		assert.deepEqual(capabilityAudit?.requestedTools, ["read"]);
+		assert.deepEqual(capabilityAudit?.removedTools, []);
+		assert.equal(capabilityAudit?.removedExtensionCount, 0);
+	});
+
+	it("counts denied extension entries without exposing them as tool names", () => {
+		const { capabilityAudit } = buildPiArgs({
+			...base,
+			tools: ["read", "/tmp/provider.ts"],
+			extensions: ["/tmp/extension.ts"],
+			subagentOnlyExtensions: ["/tmp/child-only.ts"],
+			capabilityCeiling: { version: 1, allowedTools: ["read"], denyExtensions: true, sources: ["plan"] },
+		});
+		assert.deepEqual(capabilityAudit?.requestedTools, ["read"]);
+		assert.deepEqual(capabilityAudit?.removedTools, []);
+		assert.equal(capabilityAudit?.removedExtensionCount, 3);
+	});
+
+	it("fails closed when lazy skills require a denied read tool", () => {
+		assert.throws(() => buildPiArgs({
+			...base,
+			tools: ["grep"],
+			requireReadTool: true,
+			capabilityCeiling: { version: 1, allowedTools: ["grep"], denyExtensions: false, sources: ["plan"] },
+		}), /excludes required tool 'read'/);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/capability-ceiling.test.ts

@@ -0,0 +1,68 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+	decodeSubagentCapabilityCeiling,
+	encodeSubagentCapabilityCeiling,
+	intersectSubagentCapabilityCeilings,
+	resolveCurrentSubagentCapabilityCeiling,
+	parseSubagentCapabilityCeiling,
+	registerSubagentCapabilityCeiling,
+	resolveSubagentCapabilityCeiling,
+} from "../../src/api/capability-ceiling.ts";
+
+describe("subagent capability ceiling", () => {
+	it("intersects active registrations for an exact session", () => {
+		const sessionId = `cap-${Date.now()}-${Math.random()}`;
+		const first = registerSubagentCapabilityCeiling({ sessionId, source: "plan", ceiling: { allowedTools: ["read", "grep", "write"] } });
+		const second = registerSubagentCapabilityCeiling({ sessionId, source: "review", ceiling: { allowedTools: ["read", "grep"], denyExtensions: true } });
+		assert.deepEqual(resolveSubagentCapabilityCeiling(sessionId), {
+			version: 1,
+			allowedTools: ["grep", "read"],
+			denyExtensions: true,
+			sources: ["plan", "review"],
+		});
+		assert.equal(resolveSubagentCapabilityCeiling(`${sessionId}-other`), undefined);
+		second.dispose();
+		first.dispose();
+	});
+
+	it("keeps explicit empty allowlists distinct from unrestricted state", () => {
+		const ceiling = intersectSubagentCapabilityCeilings({ version: 1, allowedTools: [], denyExtensions: false, sources: ["test"] });
+		assert.deepEqual(ceiling?.allowedTools, []);
+		assert.equal(intersectSubagentCapabilityCeilings(), undefined);
+	});
+
+	it("rejects malformed policy and disposed updates", () => {
+		assert.throws(() => registerSubagentCapabilityCeiling({ sessionId: "x", source: "x", ceiling: {} }), /allowedTools or denyExtensions/);
+		const handle = registerSubagentCapabilityCeiling({ sessionId: "disposed", source: "test", ceiling: { denyExtensions: true } });
+		handle.dispose();
+		assert.throws(() => handle.update({ allowedTools: ["read"] }), /disposed/);
+	});
+
+	it("round-trips inherited policy and rejects malformed payloads", () => {
+		const input = { version: 1 as const, allowedTools: ["read"], denyExtensions: true, sources: ["plan"] };
+		assert.deepEqual(decodeSubagentCapabilityCeiling(encodeSubagentCapabilityCeiling(input)), input);
+		assert.throws(() => decodeSubagentCapabilityCeiling("not-base64-json"), /Invalid inherited capability ceiling/);
+		assert.throws(() => parseSubagentCapabilityCeiling({ version: 1, allowedTools: ["read"], denyExtensions: true }), /sources/);
+		assert.throws(() => parseSubagentCapabilityCeiling({ version: 2, allowedTools: ["read"], denyExtensions: true, sources: ["plan"] }), /version/);
+	});
+
+	it("combines inherited process policy with exact-session registrations", () => {
+		const previous = process.env.SELESAI_SUBAGENT_CAPABILITY_CEILING_V1;
+		const sessionId = `current-${Date.now()}-${Math.random()}`;
+		const handle = registerSubagentCapabilityCeiling({ sessionId, source: "local", ceiling: { allowedTools: ["grep", "read"] } });
+		try {
+			process.env.SELESAI_SUBAGENT_CAPABILITY_CEILING_V1 = encodeSubagentCapabilityCeiling({ version: 1, allowedTools: ["read", "write"], denyExtensions: true, sources: ["ancestor"] });
+			assert.deepEqual(resolveCurrentSubagentCapabilityCeiling(sessionId), {
+				version: 1,
+				allowedTools: ["read"],
+				denyExtensions: true,
+				sources: ["ancestor", "local"],
+			});
+		} finally {
+			handle.dispose();
+			if (previous === undefined) delete process.env.SELESAI_SUBAGENT_CAPABILITY_CEILING_V1;
+			else process.env.SELESAI_SUBAGENT_CAPABILITY_CEILING_V1 = previous;
+		}
+	});
+});