@selesai/code 0.13.11 → 0.13.13

package/dist/extensions/pi-subagents/test/unit/doctor.test.ts

@@ -1,201 +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 { describe, it } from "node:test";
-import { buildDoctorReport } from "../../src/extension/doctor.ts";
-import type { AgentConfig, ChainConfig } from "../../src/agents/agents.ts";
-import type { SubagentState } from "../../src/shared/types.ts";
-
-function makeState(cwd: string): SubagentState {
-	return {
-		baseCwd: cwd,
-		currentSessionId: "session-current",
-		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: () => {} },
-	};
-}
-
-function makeAgent(name: string, source: AgentConfig["source"]): AgentConfig {
-	return {
-		name,
-		description: `${name} agent`,
-		systemPrompt: "Prompt",
-		systemPromptMode: "replace",
-		inheritProjectContext: false,
-		inheritSkills: false,
-		source,
-		filePath: `/tmp/${name}.md`,
-	};
-}
-
-function makeChain(name: string, source: ChainConfig["source"]): ChainConfig {
-	return {
-		name,
-		description: `${name} chain`,
-		source,
-		filePath: `/tmp/${name}.chain.md`,
-		steps: [{ agent: "worker", task: "Work" }],
-	};
-}
-
-describe("buildDoctorReport", () => {
-	it("formats a bounded successful environment summary", () => {
-		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-doctor-success-"));
-		try {
-			const state = makeState(root);
-			state.subagentSpawns = {
-				sessionId: "session-abc123",
-				count: 3,
-				configuredLimit: 4,
-				granted: 1,
-				grantHistory: [{ sessionId: "session-abc123", amount: 1, grantedAt: 0, previousLimit: 4, limit: 5 }],
-			};
-			const paths = {
-				tempRootDir: path.join(root, "temp-root"),
-				asyncDir: path.join(root, "async"),
-				resultsDir: path.join(root, "results"),
-				chainRunsDir: path.join(root, "chains"),
-			};
-			for (const dir of Object.values(paths)) fs.mkdirSync(dir, { recursive: true });
-
-			const report = buildDoctorReport({
-				cwd: root,
-				config: { defaultSessionDir: "~/subagent-sessions", intercomBridge: { mode: "always" }, maxSubagentSpawnsPerSession: 4, maxActiveAsyncRunsPerSession: 2 },
-				state,
-				currentSessionFile: path.join(root, "sessions", "parent.jsonl"),
-				currentSessionId: "session-abc123",
-				orchestratorTarget: "subagent-chat-abc123",
-				expandTilde: (value) => value.replace(/^~\//, `${root}/home/`),
-				paths,
-				deps: {
-					isAsyncAvailable: () => true,
-					discoverAgentsAll: () => ({
-						builtin: [makeAgent("builtin-a", "builtin")],
-						user: [makeAgent("user-a", "user")],
-						project: [makeAgent("project-a", "project"), makeAgent("project-b", "project")],
-						agentDiagnostics: [{ source: "project", filePath: path.join(root, ".selesai", "agents", "broken.md"), name: "broken", error: "invalid runner" }],
-						chains: [makeChain("user-flow", "user"), makeChain("project-flow", "project")],
-						userDir: path.join(root, "home", ".agents"),
-						projectDir: path.join(root, ".selesai", "agents"),
-						userChainDir: path.join(root, "home", ".selesai", "agent", "chains"),
-						projectChainDir: path.join(root, ".selesai", "chains"),
-						userSettingsPath: path.join(root, "home", ".selesai", "agent", "settings.json"),
-						projectSettingsPath: path.join(root, ".selesai", "settings.json"),
-					}),
-					discoverAvailableSkills: () => [
-						{ name: "project-skill", source: "project" },
-						{ name: "package-skill", source: "user-package" },
-					],
-					diagnoseIntercomBridge: () => ({
-						active: true,
-						mode: "always",
-						wantsIntercom: true,
-						supervisorChannelAvailable: true,
-						extensionDir: "native:pi-subagents-supervisor-channel",
-						orchestratorTarget: "subagent-chat-abc123",
-					}),
-				},
-			});
-
-			assert.match(report, /^Subagents doctor report/);
-			assert.ok(report.includes(`- cwd: ${root}`));
-			assert.match(report, /- async support: available/);
-			assert.match(report, /- configured session dir: .*subagent-sessions/);
-			assert.match(report, /- current session file: .*parent\.jsonl/);
-			assert.match(report, /- temp root: ok /);
-			assert.match(report, /- agents: total 4 \(builtin 1, package 0, user 1, project 2\)/);
-			assert.match(report, /- invalid agent broken \(project\): invalid runner/);
-			assert.match(report, /Spawn budget\n- usage: 3\/5 used, 2 remaining \(configured 4; granted 1; grant allowance 3\)/);
-			assert.match(report, /- recent grants: \+1 at 1970-01-01T00:00:00\.000Z \(4 → 5\)/);
-			assert.match(report, /new parent session resets usage and grants; compaction does not/);
-			assert.match(report, /Run fan-out budget\n- configured limit: 64 \(default\)/);
-			assert.match(report, /cumulative claims are never released; a new top-level run creates a new budget/);
-			assert.match(report, /Active async capacity\n- usage: 0\/2 used/);
-			assert.match(report, /terminal state plus matching observed process-terminal proof, or abandoned-timeout for failed runs with a dead runner PID and stale activity when enabled; false keeps unknown-proof slots/);
-			assert.match(report, /Workflow script\n- helpers: runs\.run, runs\.all, runs\.steer, runs\.status, runs\.ref\/refs, emit, console/);
-			assert.match(report, /if runs\.all is missing, reload or update pi-subagents; await Promise\.all\(\[runs\.run\(\.\.\.\)\]\) is also supported/);
-			assert.match(report, /- skills: total 2 \(project 1, user-package 1\)/);
-			assert.match(report, /- bridge: active/);
-			assert.match(report, /- supervisor channel: available \(native:pi-subagents-supervisor-channel\)/);
-			assert.doesNotMatch(report, /Companion packages/);
-		} finally {
-			fs.rmSync(root, { recursive: true, force: true });
-		}
-	});
-
-	it("reports the effective source when the run fan-out environment value is invalid", () => {
-		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-doctor-fanout-source-"));
-		const previous = process.env.SELESAI_SUBAGENT_MAX_SPAWNS_PER_RUN;
-		try {
-			process.env.SELESAI_SUBAGENT_MAX_SPAWNS_PER_RUN = "invalid";
-			const report = buildDoctorReport({
-				cwd: root,
-				config: { maxSubagentSpawnsPerRun: 12 },
-				state: makeState(root),
-				deps: {
-					isAsyncAvailable: () => true,
-					discoverAgentsAll: () => ({ builtin: [], user: [], project: [], chains: [], userDir: root, projectDir: root, userChainDir: root, projectChainDir: root, userSettingsPath: path.join(root, "user.json"), projectSettingsPath: path.join(root, "project.json") }),
-					discoverAvailableSkills: () => [],
-					diagnoseIntercomBridge: () => ({ active: false, mode: "off", wantsIntercom: false, supervisorChannelAvailable: false, extensionDir: "none" }),
-				},
-			});
-			assert.match(report, /Run fan-out budget\n- configured limit: 12 \(config\)/);
-		} finally {
-			if (previous === undefined) delete process.env.SELESAI_SUBAGENT_MAX_SPAWNS_PER_RUN;
-			else process.env.SELESAI_SUBAGENT_MAX_SPAWNS_PER_RUN = previous;
-			fs.rmSync(root, { recursive: true, force: true });
-		}
-	});
-
-	it("keeps reporting when a directory or discovery check fails", () => {
-		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-doctor-failure-"));
-		try {
-			const asyncPath = path.join(root, "async-file");
-			fs.writeFileSync(asyncPath, "not a directory");
-			const report = buildDoctorReport({
-				cwd: root,
-				config: {},
-				state: makeState(root),
-				paths: {
-					tempRootDir: root,
-					asyncDir: asyncPath,
-					resultsDir: path.join(root, "missing-results"),
-					chainRunsDir: path.join(root, "missing-chains"),
-				},
-				deps: {
-					isAsyncAvailable: () => false,
-					discoverAgentsAll: () => {
-						throw new Error("discovery exploded");
-					},
-					discoverAvailableSkills: () => [],
-					diagnoseIntercomBridge: () => ({
-						active: false,
-						mode: "fork-only",
-						wantsIntercom: false,
-						supervisorChannelAvailable: true,
-						extensionDir: "native:pi-subagents-supervisor-channel",
-						reason: "bridge mode is fork-only and context is not fork",
-					}),
-				},
-			});
-
-			assert.match(report, /- async support: unavailable/);
-			assert.match(report, /- async runs: failed .*Error: not a directory:/);
-			assert.match(report, /- results: missing /);
-			assert.match(report, /- agents: failed — Error: discovery exploded/);
-			assert.match(report, /- skills: total 0 \(none\)/);
-			assert.match(report, /- bridge: inactive \(bridge mode is fork-only and context is not fork\)/);
-		} finally {
-			fs.rmSync(root, { recursive: true, force: true });
-		}
-	});
-});

package/dist/extensions/pi-subagents/test/unit/dynamic-fanout.test.ts

@@ -1,219 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { ChainOutputValidationError, validateChainOutputBindings, validateChainOutputBindingsWithContext } from "../../src/runs/shared/chain-outputs.ts";
-import {
-	DynamicFanoutError,
-	collectDynamicResults,
-	materializeDynamicParallelStep,
-	resolveJsonPointer,
-	validateDynamicCollection,
-	validateDynamicStepShape,
-} from "../../src/runs/shared/dynamic-fanout.ts";
-import type { ChainStep } from "../../src/shared/settings.ts";
-import type { ChainOutputMap, SingleResult } from "../../src/shared/types.ts";
-
-const outputs: ChainOutputMap = {
-	targets: {
-		text: "{\"items\":[{\"path\":\"src/a.ts\"},{\"path\":\"src/b.ts\"}]}",
-		structured: { items: [{ path: "src/a.ts" }, { path: "src/b.ts" }] },
-		agent: "scout",
-		stepIndex: 0,
-	},
-};
-
-describe("dynamic fanout helpers", () => {
-	it("resolves JSON Pointers and materializes item templates", () => {
-		assert.deepEqual(resolveJsonPointer({ items: [1, 2] }, "/items/1", "path"), 2);
-		const step: ChainStep = {
-			expand: { from: { output: "targets", path: "/items" }, item: "target", key: "/path", maxItems: 4 },
-			parallel: { agent: "reviewer", task: "Review {target.path}", label: "Review {target.path}" },
-			collect: { as: "reviews" },
-		};
-		const materialized = materializeDynamicParallelStep(step, outputs, 1);
-		assert.deepEqual(materialized.items.map((item) => item.key), ["src/a.ts", "src/b.ts"]);
-		assert.deepEqual(materialized.parallel.map((task) => task.task), ["Review src/a.ts", "Review src/b.ts"]);
-		assert.deepEqual(materialized.parallel.map((task) => task.label), ["Review src/a.ts", "Review src/b.ts"]);
-	});
-
-	it("rejects missing structured sources, over-limit arrays, duplicate keys, colliding ids, and bad templates", () => {
-		const base: ChainStep = {
-			expand: { from: { output: "targets", path: "/items" }, item: "target", key: "/path", maxItems: 4 },
-			parallel: { agent: "reviewer", task: "Review {target.path}" },
-			collect: { as: "reviews" },
-		};
-		assert.throws(
-			() => materializeDynamicParallelStep({ ...base, expand: { ...base.expand, maxItems: 1 } }, outputs, 1),
-			/exceeding maxItems/,
-		);
-		assert.throws(
-			() => materializeDynamicParallelStep(base, { targets: { text: "plain", agent: "scout", stepIndex: 0 } }, 1),
-			/requires structured output/,
-		);
-		assert.throws(
-			() => materializeDynamicParallelStep(base, { targets: { ...outputs.targets, structured: { items: [{ path: "x" }, { path: "x" }] } } }, 1),
-			/duplicate item key/,
-		);
-		assert.throws(
-			() => materializeDynamicParallelStep(base, { targets: { ...outputs.targets, structured: { items: [{ path: "a/b" }, { path: "a-b" }] } } }, 1),
-			/colliding item id/,
-		);
-		assert.throws(
-			() => materializeDynamicParallelStep({ ...base, parallel: { agent: "reviewer", task: "Review {other.path}" } }, outputs, 1),
-			/Unsupported template reference/,
-		);
-		assert.throws(
-			() => materializeDynamicParallelStep({ ...base, parallel: { agent: "reviewer", task: "Review {target[path]}" } }, outputs, 1),
-			/Invalid item reference/,
-		);
-		assert.throws(
-			() => materializeDynamicParallelStep({ ...base, parallel: { agent: "reviewer", task: "Review {target.path" } }, outputs, 1),
-			/Invalid item reference/,
-		);
-	});
-
-	it("allows config maxItems defaults and handles empty arrays deterministically", () => {
-		const base: ChainStep = {
-			expand: { from: { output: "targets", path: "/items" }, item: "target", key: "/path" },
-			parallel: { agent: "reviewer", task: "Review {target.path}" },
-			collect: { as: "reviews" },
-		};
-		const materialized = materializeDynamicParallelStep(base, outputs, 1, { maxItems: 4 });
-		assert.equal(materialized.parallel.length, 2);
-		assert.doesNotThrow(() => validateChainOutputBindings([
-			{ agent: "scout", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
-			base,
-		], { maxItems: 4 }));
-		const empty = materializeDynamicParallelStep(base, { targets: { ...outputs.targets, structured: { items: [] } } }, 1, { maxItems: 4 });
-		assert.equal(empty.parallel.length, 0);
-		assert.throws(
-			() => materializeDynamicParallelStep({ ...base, expand: { ...base.expand, onEmpty: "fail" } }, { targets: { ...outputs.targets, structured: { items: [] } } }, 1, { maxItems: 4 }),
-			/source array is empty/,
-		);
-	});
-
-	it("rejects malformed dynamic-like shapes before they can run as static parallel", () => {
-		const malformed = [
-			{
-				expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
-				parallel: [{ agent: "reviewer", task: "Review" }],
-				collect: { as: "reviews" },
-			},
-			{
-				expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
-				parallel: { agent: "reviewer", task: "Review {item.path}" },
-			},
-			{
-				expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
-				parallel: { agent: "reviewer", task: "Review {item.path}" },
-				collect: { as: "reviews" },
-				when: "later",
-			},
-			{
-				expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
-				parallel: { agent: "reviewer", task: "Review {item.path}", as: "child" },
-				collect: { as: "reviews" },
-			},
-		] as ChainStep[];
-
-		for (const step of malformed) {
-			assert.throws(
-				() => validateChainOutputBindings([{ agent: "scout", task: "Return targets", as: "targets", outputSchema: { type: "object" } }, step]),
-				ChainOutputValidationError,
-			);
-		}
-	});
-
-	it("accepts a runner-injected parentSessionId on the parallel template but keeps it out of user-facing validation", () => {
-		// Regression: the async runner threads parentSessionId onto the dynamic parallel
-		// template for permission-system forwarding. It must pass runner-internal validation
-		// (allowRunnerFields) without leaking into the user-facing dynamic field whitelist.
-		const runnerStep = {
-			expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
-			parallel: { agent: "reviewer", task: "Review {item.path}", parentSessionId: "session-parent" },
-			collect: { as: "reviews" },
-		} as unknown as Parameters<typeof validateDynamicStepShape>[0];
-		assert.doesNotThrow(() => validateDynamicStepShape(runnerStep, 1, { allowRunnerFields: true }));
-		assert.throws(
-			() => validateDynamicStepShape(runnerStep, 1),
-			(error: unknown) => error instanceof DynamicFanoutError && /parentSessionId/.test(error.message),
-		);
-	});
-
-	it("accepts fast and toolBudget on dynamic parallel templates", () => {
-		const step = {
-			expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
-			parallel: { agent: "reviewer", task: "Review {item.path}", fast: true, toolBudget: { hard: 3 } },
-			collect: { as: "reviews" },
-		} as unknown as Parameters<typeof validateDynamicStepShape>[0];
-
-		assert.doesNotThrow(() => validateDynamicStepShape(step, 1));
-		assert.deepEqual(materializeDynamicParallelStep(step, outputs, 1).parallel.map((item) => item.fast), [true, true]);
-	});
-
-	it("validates source ordering and collect name collisions", () => {
-		const chain: ChainStep[] = [
-			{ agent: "scout", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
-			{
-				expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
-				parallel: { agent: "reviewer", task: "Review {item.path}" },
-				collect: { as: "targets" },
-			},
-		];
-		assert.throws(() => validateChainOutputBindings(chain), ChainOutputValidationError);
-		assert.throws(
-			() => validateChainOutputBindings([chain[1]!]),
-			/unknown output 'targets'/,
-		);
-	});
-
-	it("validates appended steps against prior and reserved output names", () => {
-		assert.doesNotThrow(() => validateChainOutputBindingsWithContext([
-			{ agent: "worker", task: "Use {outputs.targets}", as: "summary" },
-		], {}, { priorOutputNames: ["targets"], startStepIndex: 2 }));
-		assert.throws(
-			() => validateChainOutputBindingsWithContext([
-				{ agent: "worker", task: "Use {outputs.missing}" },
-			], {}, { priorOutputNames: ["targets"], startStepIndex: 2 }),
-			/Unknown chain output reference '\{outputs\.missing\}' at step 3/,
-		);
-		assert.throws(
-			() => validateChainOutputBindingsWithContext([
-				{ agent: "worker", task: "Use {previous}", as: "targets" },
-			], {}, { priorOutputNames: ["targets"], startStepIndex: 2 }),
-			/Duplicate chain output name 'targets'/,
-		);
-		assert.doesNotThrow(() => validateChainOutputBindingsWithContext([
-			{
-				expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
-				parallel: { agent: "reviewer", task: "Review {item.path}" },
-				collect: { as: "reviews" },
-			},
-		], {}, { priorOutputNames: ["targets"], startStepIndex: 2 }));
-	});
-
-	it("collects ordered child result records and validates aggregate schema", async () => {
-		const step: ChainStep = {
-			expand: { from: { output: "targets", path: "/items" }, key: "/path", maxItems: 4 },
-			parallel: { agent: "reviewer", task: "Review {item.path}" },
-			collect: { as: "reviews" },
-		};
-		const materialized = materializeDynamicParallelStep(step, outputs, 1);
-		const result = (agent: string, structuredOutput: unknown): SingleResult => ({
-			agent,
-			task: "t",
-			index: 0,
-			exitCode: 0,
-			messages: [],
-			usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
-			finalOutput: "ok",
-			structuredOutput,
-		});
-		const timedOut = { ...result("reviewer", { ok: "b" }), exitCode: 1, error: "Subagent timed out after 300ms.", timedOut: true };
-		const collected = collectDynamicResults(step, materialized.items, [result("reviewer", { ok: "a" }), timedOut]);
-		assert.deepEqual(collected.map((item) => item.key), ["src/a.ts", "src/b.ts"]);
-		assert.deepEqual(collected.map((item) => item.structured), [{ ok: "a" }, { ok: "b" }]);
-		assert.equal(collected[1]?.timedOut, true);
-		await assert.doesNotReject(validateDynamicCollection({ type: "array", minItems: 2 }, collected));
-		await assert.rejects(validateDynamicCollection({ type: "object" }, collected), DynamicFanoutError);
-	});
-});

package/dist/extensions/pi-subagents/test/unit/ensure-accessible-dir.test.ts

@@ -1,125 +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 { describe, it } from "node:test";
-import { ensureAccessibleDir } from "../../src/shared/accessible-dir.ts";
-import { DIRS } from "../../src/shared/types.ts";
-
-class FakeFs {
-	created: string[] = [];
-	blockedMkdir = new Set<string>();
-	blockedAccess = new Set<string>();
-
-	mkdirSync(dirPath: string): void {
-		if (this.blockedMkdir.has(dirPath)) {
-			const error = new Error("mkdir blocked") as NodeJS.ErrnoException;
-			error.code = "EPERM";
-			throw error;
-		}
-		this.created.push(dirPath);
-	}
-
-	accessSync(dirPath: string): void {
-		if (this.blockedAccess.has(dirPath)) {
-			const error = new Error("access blocked") as NodeJS.ErrnoException;
-			error.code = "EPERM";
-			throw error;
-		}
-	}
-}
-
-function fakeOptions(fakeFs: FakeFs) {
-	return {
-		fs: fakeFs,
-		pid: 12345,
-		retryDirectoryErrors: true,
-		retryDelaysMs: [] as readonly number[],
-		wait: () => {},
-	};
-}
-
-describe("ensureAccessibleDir", () => {
-	it("returns the requested path when it is usable", () => {
-		const fakeFs = new FakeFs();
-		const dirPath = "/tmp/pi-subagents-ok/results";
-
-		const result = ensureAccessibleDir(dirPath, fakeOptions(fakeFs));
-
-		assert.equal(result, dirPath);
-		assert.deepEqual(fakeFs.created, [dirPath]);
-	});
-
-	it("falls back to a pid-scoped sibling when mkdir is persistently blocked", () => {
-		const fakeFs = new FakeFs();
-		const dirPath = "/tmp/pi-subagents-mkdir-eperm/results";
-		fakeFs.blockedMkdir.add(dirPath);
-
-		const result = ensureAccessibleDir(dirPath, fakeOptions(fakeFs));
-
-		assert.equal(result, `${dirPath}-12345`);
-		assert.deepEqual(fakeFs.created, [`${dirPath}-12345`]);
-	});
-
-	it("falls back to a pid-scoped sibling when access is persistently blocked", () => {
-		const fakeFs = new FakeFs();
-		const dirPath = "/tmp/pi-subagents-access-eperm/results";
-		fakeFs.blockedAccess.add(dirPath);
-
-		const result = ensureAccessibleDir(dirPath, fakeOptions(fakeFs));
-
-		assert.equal(result, `${dirPath}-12345`);
-		assert.deepEqual(fakeFs.created, [dirPath, `${dirPath}-12345`]);
-	});
-
-	it("does not delete existing primary directory contents when falling back", () => {
-		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-accessible-dir-"));
-		try {
-			const dirPath = path.join(root, "async-subagent-runs");
-			const statusPath = path.join(dirPath, "run-1", "status.json");
-			fs.mkdirSync(path.dirname(statusPath), { recursive: true });
-			fs.writeFileSync(statusPath, "{}", "utf-8");
-
-			const fsImpl = {
-				mkdirSync: fs.mkdirSync,
-				accessSync(target: string, mode?: number): void {
-					if (target === dirPath) {
-						const error = new Error("access blocked") as NodeJS.ErrnoException;
-						error.code = "EPERM";
-						throw error;
-					}
-					fs.accessSync(target, mode);
-				},
-			};
-
-			const result = ensureAccessibleDir(dirPath, {
-				fs: fsImpl,
-				pid: 12345,
-				retryDirectoryErrors: true,
-				retryDelaysMs: [] as readonly number[],
-				wait: () => {},
-			});
-
-			assert.equal(result, `${dirPath}-12345`);
-			assert.equal(fs.readFileSync(statusPath, "utf-8"), "{}");
-		} finally {
-			fs.rmSync(root, { recursive: true, force: true });
-		}
-	});
-});
-
-describe("DIRS", () => {
-	it("allows runtime reassignment for live async and results paths", () => {
-		const originalResults = DIRS.results;
-		const originalAsync = DIRS.async;
-		try {
-			DIRS.results = "/tmp/fallback-results";
-			DIRS.async = "/tmp/fallback-async";
-			assert.equal(DIRS.results, "/tmp/fallback-results");
-			assert.equal(DIRS.async, "/tmp/fallback-async");
-		} finally {
-			DIRS.results = originalResults;
-			DIRS.async = originalAsync;
-		}
-	});
-});

package/dist/extensions/pi-subagents/test/unit/extension-bindings.test.ts

@@ -1,79 +0,0 @@
-import assert from "node:assert/strict";
-import * as fs from "node:fs";
-import { afterEach, describe, it } from "node:test";
-import { launchBindingDigest } from "../../src/shared/launch-contract.ts";
-import {
-	MAX_EXTENSION_BINDING_NAMESPACES,
-	MAX_EXTENSION_BINDINGS_BYTES,
-	SELESAI_SUBAGENT_EXTENSION_BINDINGS_ENV,
-	type ExtensionBindings,
-	normalizeExtensionBindings,
-	omitExtensionBindingsEnv,
-} from "../../src/runs/shared/extension-bindings.ts";
-import { buildPiArgs } from "../../src/runs/shared/pi-args.ts";
-
-const originalBindingEnv = process.env[SELESAI_SUBAGENT_EXTENSION_BINDINGS_ENV];
-const tempDirs: string[] = [];
-
-afterEach(() => {
-	if (originalBindingEnv === undefined) delete process.env[SELESAI_SUBAGENT_EXTENSION_BINDINGS_ENV];
-	else process.env[SELESAI_SUBAGENT_EXTENSION_BINDINGS_ENV] = originalBindingEnv;
-	for (const dir of tempDirs.splice(0)) fs.rmSync(dir, { recursive: true, force: true });
-});
-
-function childEnv(extensionBindings?: ExtensionBindings): Record<string, string | undefined> {
-	const normalizedExtensionBindings = normalizeExtensionBindings(extensionBindings)?.value;
-	const result = buildPiArgs({
-		baseArgs: [],
-		task: "test",
-		sessionEnabled: false,
-		inheritProjectContext: false,
-		inheritSkills: false,
-		extensionBindings: normalizedExtensionBindings,
-	});
-	if (result.tempDir) tempDirs.push(result.tempDir);
-	return result.env;
-}
-
-describe("extension bindings", () => {
-	it("canonicalizes bounded namespaced JSON and isolates it from caller mutation", () => {
-		const input = { "shepherd.dispatch/1": { writeScope: ["src/a.ts"], role: "coder" } };
-		const normalized = normalizeExtensionBindings(input)!;
-		assert.equal(normalized.json, '{"shepherd.dispatch/1":{"role":"coder","writeScope":["src/a.ts"]}}');
-		input["shepherd.dispatch/1"].role = "reviewer";
-		assert.equal(normalized.json.includes("reviewer"), false);
-		assert.equal(Object.isFrozen(normalized.value), true);
-	});
-
-	it("rejects malformed, oversized, and unsafe values", () => {
-		assert.throws(() => normalizeExtensionBindings({ invalid: true }), /namespace/);
-		assert.throws(() => normalizeExtensionBindings(Object.fromEntries(Array.from({ length: MAX_EXTENSION_BINDING_NAMESPACES + 1 }, (_, index) => [`pkg${index}\/1`, true]))), /at most/);
-		assert.throws(() => normalizeExtensionBindings({ "pkg/1": "x".repeat(MAX_EXTENSION_BINDINGS_BYTES) }), /maximum/);
-		assert.throws(() => normalizeExtensionBindings({ "pkg/1": Number.NaN }), /finite/);
-		const cyclic: Record<string, unknown> = { "pkg/1": {} };
-		(cyclic["pkg/1"] as Record<string, unknown>).self = cyclic;
-		assert.throws(() => normalizeExtensionBindings(cyclic), /cycles/);
-		const accessor = Object.create(null) as Record<string, unknown>;
-		Object.defineProperty(accessor, "pkg/1", { enumerable: true, get: () => true });
-		assert.throws(() => normalizeExtensionBindings(accessor), /data property/);
-	});
-
-	it("sets canonical child-only env and clears inherited authority when omitted", () => {
-		process.env[SELESAI_SUBAGENT_EXTENSION_BINDINGS_ENV] = '{"parent/1":true}';
-		assert.equal(childEnv()[SELESAI_SUBAGENT_EXTENSION_BINDINGS_ENV], undefined);
-		assert.equal(childEnv({ "child/1": { z: 1, a: 2 } })[SELESAI_SUBAGENT_EXTENSION_BINDINGS_ENV], '{"child/1":{"a":2,"z":1}}');
-	});
-
-	it("removes ambient bindings from external runner environments", () => {
-		assert.deepEqual(omitExtensionBindingsEnv({ KEEP_ME: "yes", [SELESAI_SUBAGENT_EXTENSION_BINDINGS_ENV]: "secret" }), { KEEP_ME: "yes" });
-	});
-
-	it("changes launch provenance only when the binding changes", () => {
-		const base = { definitionDigest: "definition", task: "task", inheritProjectContext: false, inheritSkills: false };
-		const omitted = launchBindingDigest(base);
-		const first = launchBindingDigest({ ...base, extensionBindings: normalizeExtensionBindings({ "policy/1": { role: "coder" } })!.value });
-		const second = launchBindingDigest({ ...base, extensionBindings: normalizeExtensionBindings({ "policy/1": { role: "reviewer" } })!.value });
-		assert.notEqual(first, omitted);
-		assert.notEqual(first, second);
-	});
-});

package/dist/extensions/pi-subagents/test/unit/extension-context.test.ts

@@ -1,27 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { withCachedUiContext } from "../../src/shared/extension-context.ts";
-
-describe("cached extension UI context", () => {
-	it("clears a context replaced by session reload and returns no UI result", () => {
-		let cleared = false;
-		const result = withCachedUiContext({
-			get hasUI() {
-				throw new Error("This extension ctx is stale after session replacement or reload.");
-			},
-		} as never, () => {
-			cleared = true;
-		}, () => "unreachable");
-
-		assert.equal(result, undefined);
-		assert.equal(cleared, true);
-	});
-
-	it("does not hide non-stale context errors", () => {
-		assert.throws(() => withCachedUiContext({
-			get hasUI() {
-				throw new Error("UI bridge unavailable");
-			},
-		} as never, () => {}, () => "unreachable"), /UI bridge unavailable/);
-	});
-});