@selesai/code 0.13.12 → 0.13.13

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

@@ -1,83 +0,0 @@
-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, windowElapsed = false) {
-	return {
-		content: [{ type: "text" as const, text }],
-		...(isError ? { isError: true } : {}),
-		details: {
-			mode: "management" as const,
-			results: [],
-			...(windowElapsed ? { wait: { reason: "window_elapsed" as const, timedOut: true as const, activeRunIds: ["run-a"], activeProviderItems: [] } } : {}),
-		} 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; failOnAttention?: 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, failOnAttention: deps.failOnAttention });
-				return waitResult("done");
-			},
-		});
-		assert.equal(waits.length, 2);
-		assert.ok(waits.every((entry) => entry.all === true && entry.stopOnAttention === false && entry.failOnFailedRuns === true && entry.failOnAttention === 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("keeps its absolute deadline strict after a non-error wait window elapses", async () => {
-		let clock = 0;
-		await assert.rejects(() => drainOutstandingWork({
-			state: state(),
-			timeoutMs: 100,
-			now: () => clock,
-			hasWork: () => true,
-			wait: async () => {
-				clock = 101;
-				return waitResult("Wait window elapsed; work remains active.", false, true);
-			},
-		}), /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-process-options.test.ts

@@ -1,17 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { backgroundProcessOptions } from "../../src/runs/shared/background-process-options.ts";
-
-test("Windows background runners stay hidden without requesting a new console", () => {
-	assert.deepEqual(backgroundProcessOptions("win32"), {
-		detached: false,
-		windowsHide: true,
-	});
-});
-
-test("background runners remain detached on Unix", () => {
-	assert.deepEqual(backgroundProcessOptions("linux"), {
-		detached: true,
-		windowsHide: true,
-	});
-});

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

@@ -1,365 +0,0 @@
-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 BackgroundWorkListContext,
-	type BackgroundWorkSnapshot,
-} from "../../src/api/background-work.ts";
-import { updateActiveRunIndex } from "../../src/runs/background/active-run-index.ts";
-import { waitForSubagents, type SubagentWaitDeps } from "../../src/runs/background/subagent-wait.ts";
-import type { AsyncStatus, 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: AsyncStatus["state"], 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 }],
-	}));
-	updateActiveRunIndex(dir, 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("passes an optional session context while preserving legacy providers and exact filtering", () => {
-		let listContext: BackgroundWorkListContext | undefined;
-		let legacyCalled = false;
-		registerBackgroundWorkProvider({
-			name: "legacy",
-			listActiveWork: () => {
-				legacyCalled = true;
-				return [{ id: "legacy-job", sessionId: "session-a" }];
-			},
-		});
-		registerBackgroundWorkProvider({
-			name: "scoped",
-			listActiveWork: (context) => {
-				if (!context) throw new Error("expected background-work list context");
-				listContext = context;
-				return [
-					{ id: "mine", sessionId: context.sessionId },
-					{ id: "theirs", sessionId: "session-b" },
-				];
-			},
-		});
-
-		assert.deepEqual(snapshotBackgroundWork("session-a", 42), {
-			providers: ["legacy", "scoped"],
-			items: [
-				{ provider: "legacy", id: "legacy-job", sessionId: "session-a" },
-				{ provider: "scoped", id: "mine", sessionId: "session-a" },
-			],
-		});
-		assert.equal(legacyCalled, true);
-		assert.deepEqual(listContext, { sessionId: "session-a", nowMs: 42 });
-	});
-
-	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("validates scoped provider results before filtering them", () => {
-		registerBackgroundWorkProvider({
-			name: "scoped",
-			listActiveWork: () => [{ id: "job", sessionId: "session-a", extra: true } as never],
-		});
-		assert.throws(() => snapshotBackgroundWork("session-a"), /unknown fields: extra/);
-
-		clearRegistry();
-		registerBackgroundWorkProvider({
-			name: "scoped",
-			listActiveWork: (context) => {
-				if (!context) throw new Error("expected background-work list context");
-				return [
-					{ id: "job", sessionId: context.sessionId },
-					{ id: "job", sessionId: context.sessionId },
-				];
-			},
-		});
-		assert.throws(() => snapshotBackgroundWork("session-a"), /duplicate item 'job'/);
-	});
-
-	it("accepts path-like session ids up to the bound and rejects longer ids", () => {
-		const longSessionId = `${"/nested/".repeat(511)}xsession`;
-		const overBoundSessionId = `${longSessionId}x`;
-		assert.equal(longSessionId.length, 4_096);
-
-		registerBackgroundWorkProvider({
-			name: "patty",
-			listActiveWork: () => [{ id: "job", sessionId: longSessionId }],
-		});
-		assert.deepEqual(snapshotBackgroundWork(longSessionId), {
-			providers: ["patty"],
-			items: [{ provider: "patty", id: "job", sessionId: longSessionId }],
-		});
-		assert.throws(() => snapshotBackgroundWork(overBoundSessionId), /at most 4096 characters/);
-
-		clearRegistry();
-		registerBackgroundWorkProvider({
-			name: "patty",
-			listActiveWork: () => [{ id: "job", sessionId: overBoundSessionId }],
-		});
-		assert.throws(() => snapshotBackgroundWork("session-a"), /at most 4096 characters/);
-	});
-
-	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("bg_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-agent-allowlist.test.ts

@@ -1,102 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { handleList } from "../../src/agents/agent-management.ts";
-import type { AgentConfig } from "../../src/agents/agents.ts";
-import { resolveSubagentLaunchContract } from "../../src/api/preflight.ts";
-import {
-	decodeSubagentCapabilityCeiling,
-	encodeSubagentCapabilityCeiling,
-	intersectSubagentCapabilityCeilings,
-	parseSubagentCapabilityCeiling,
-	registerSubagentCapabilityCeiling,
-} from "../../src/api/capability-ceiling.ts";
-import { runSync } from "../../src/runs/foreground/execution.ts";
-import { buildPiArgs } from "../../src/runs/shared/pi-args.ts";
-
-function agent(name: string): AgentConfig {
-	return {
-		name,
-		description: `${name} agent`,
-		systemPrompt: `${name} prompt`,
-		systemPromptMode: "replace",
-		inheritProjectContext: false,
-		inheritSkills: false,
-		source: "project",
-		filePath: `/tmp/${name}.md`,
-	};
-}
-
-describe("capability ceiling agent allowlist", () => {
-	it("parses, round-trips, and intersects allowedAgents", () => {
-		const parsed = parseSubagentCapabilityCeiling({ version: 1, allowedAgents: ["worker", "reviewer", "worker"], denyExtensions: false, sources: ["plan"] });
-		assert.deepEqual(parsed.allowedAgents, ["reviewer", "worker"]);
-		assert.deepEqual(decodeSubagentCapabilityCeiling(encodeSubagentCapabilityCeiling(parsed)), parsed);
-
-		assert.deepEqual(intersectSubagentCapabilityCeilings(
-			{ version: 1, allowedAgents: ["worker", "reviewer"], denyExtensions: false, sources: ["outer"] },
-			{ version: 1, allowedAgents: ["reviewer", "scout"], denyExtensions: true, sources: ["inner"] },
-		), {
-			version: 1,
-			allowedAgents: ["reviewer"],
-			denyExtensions: true,
-			sources: ["inner", "outer"],
-		});
-
-		assert.deepEqual(intersectSubagentCapabilityCeilings(
-			{ version: 1, allowedTools: ["read"], denyExtensions: false, sources: ["tools-only"] },
-			{ version: 1, allowedAgents: [], denyExtensions: false, sources: ["none"] },
-		)?.allowedAgents, []);
-	});
-
-	it("marks non-allowlisted agents as restricted in list output", () => {
-		const sessionId = `allowlist-list-${Date.now()}-${Math.random()}`;
-		const handle = registerSubagentCapabilityCeiling({ sessionId, source: "plan-mode", ceiling: { allowedAgents: ["reviewer"] } });
-		try {
-			const result = handleList({}, { cwd: process.cwd(), currentSessionId: sessionId, modelRegistry: { getAvailable: () => [] } });
-			const text = result.content[0]?.text ?? "";
-			assert.match(text, /Executable agents:/);
-			assert.match(text, /- reviewer /);
-			assert.match(text, /Restricted agents \(not executable in this session; capability ceiling: plan-mode\):/);
-			assert.match(text, /- worker /);
-		} finally {
-			handle.dispose();
-		}
-	});
-
-	it("rejects a non-allowlisted agent in preflight launch resolution", async () => {
-		const result = await resolveSubagentLaunchContract({
-			agent: "worker",
-			cwd: process.cwd(),
-			capabilityCeiling: { version: 1, allowedAgents: ["reviewer"], denyExtensions: false, sources: ["plan-mode"] },
-		});
-		assert.equal(result.ok, false);
-		assert.equal(result.code, "restricted_agent");
-		assert.match(result.message, /does not allow agent 'worker'/);
-		assert.match(result.message, /Allowed agents: reviewer/);
-	});
-
-	it("rejects a non-allowlisted foreground launch before spawning", async () => {
-		const result = await runSync(process.cwd(), [agent("worker"), agent("reviewer")], "worker", "Do work", {
-			capabilityCeiling: { version: 1, allowedAgents: ["reviewer"], denyExtensions: false, sources: ["plan-mode"] },
-		});
-		assert.equal(result.exitCode, 1);
-		assert.match(result.error ?? "", /does not allow agent 'worker'/);
-		assert.deepEqual(result.capabilityCeiling?.allowedAgents, ["reviewer"]);
-	});
-
-	it("includes allowedAgents in propagated launch env and audit metadata", () => {
-		const { env, capabilityAudit } = buildPiArgs({
-			baseArgs: [],
-			task: "Review",
-			sessionEnabled: false,
-			inheritProjectContext: false,
-			inheritSkills: false,
-			childAgentName: "reviewer",
-			capabilityCeiling: { version: 1, allowedAgents: ["reviewer"], allowedTools: ["read"], denyExtensions: true, sources: ["plan-mode"] },
-		});
-		assert.equal(capabilityAudit?.agentAllowed, true);
-		assert.deepEqual(capabilityAudit?.agentRestrictionSources, ["plan-mode"]);
-		assert.ok(env.SELESAI_SUBAGENT_CAPABILITY_CEILING_V1);
-		assert.deepEqual(decodeSubagentCapabilityCeiling(env.SELESAI_SUBAGENT_CAPABILITY_CEILING_V1)?.allowedAgents, ["reviewer"]);
-	});
-});

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

@@ -1,84 +0,0 @@
-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'/);
-	});
-});