@selesai/code 0.9.11 → 0.9.12

package/dist/extensions/pi-subagents/test/unit/control-channel.test.ts

@@ -10,6 +10,8 @@ import {
 	consumeSteerCapabilities,
 	consumeSteerRequests,
 	consumeStopRequest,
+	consumeStopRequestPayload,
+	consumeStopRequestPayloads,
 	deliverInterruptRequest,
 	enqueueStepSteer,
 	interruptRequestPath,
@@ -23,6 +25,7 @@ import {
 	steerAcksDir,
 	steerInboxClosedPath,
 	steerCapabilityPath,
+	stopRequestsDir,
 	writeSteerAck,
 	writeSteerCapability,
 	stopRequestPath,
@@ -59,19 +62,81 @@ describe("control channel: request file", () => {
 		const asyncDir = tmpAsyncDir("pi-control-stop-");
 		try {
 			const requestPath = requestAsyncStop(asyncDir, { source: "test" }, { now: () => 1234 });
-			assert.equal(requestPath, stopRequestPath(asyncDir));
+			assert.equal(path.dirname(requestPath), stopRequestsDir(asyncDir));
 			const data = JSON.parse(fs.readFileSync(requestPath, "utf-8"));
 			assert.equal(data.type, "stop");
 			assert.equal(data.ts, 1234);
 			assert.equal(data.source, "test");
 			assert.equal(consumeStopRequest(asyncDir), true);
-			assert.equal(fs.existsSync(stopRequestPath(asyncDir)), false);
+			assert.equal(fs.existsSync(requestPath), false);
 			assert.equal(consumeStopRequest(asyncDir), false);
 		} finally {
 			cleanup(asyncDir);
 		}
 	});
 
+	it("keeps concurrent stop requests instead of replacing the first one", () => {
+		const asyncDir = tmpAsyncDir("pi-control-stop-queue-");
+		try {
+			requestAsyncStop(asyncDir, { source: "test", targetIndex: 1, childId: "slow" }, { now: () => 1234 });
+			requestAsyncStop(asyncDir, { source: "test", targetIndex: 2, childId: "review" }, { now: () => 1235 });
+
+			assert.deepEqual(consumeStopRequestPayloads(asyncDir), [
+				{ type: "stop", ts: 1234, source: "test", targetIndex: 1, childId: "slow" },
+				{ type: "stop", ts: 1235, source: "test", targetIndex: 2, childId: "review" },
+			]);
+			assert.deepEqual(consumeStopRequestPayloads(asyncDir), []);
+		} finally {
+			cleanup(asyncDir);
+		}
+	});
+
+	it("writes and consumes a child-scoped stop request", () => {
+		const asyncDir = tmpAsyncDir("pi-control-child-stop-");
+		try {
+			requestAsyncStop(asyncDir, { source: "test", targetIndex: 2, childId: "review" }, { now: () => 1234 });
+
+			assert.deepEqual(consumeStopRequestPayload(asyncDir), {
+				type: "stop",
+				ts: 1234,
+				source: "test",
+				targetIndex: 2,
+				childId: "review",
+			});
+			assert.deepEqual(consumeStopRequestPayloads(asyncDir), []);
+		} finally {
+			cleanup(asyncDir);
+		}
+	});
+
+	it("drops malformed stop files instead of widening them to run-level stops", () => {
+		const asyncDir = tmpAsyncDir("pi-control-stop-malformed-");
+		try {
+			fs.mkdirSync(stopRequestsDir(asyncDir), { recursive: true });
+			const requestPath = path.join(stopRequestsDir(asyncDir), "0000000001234-bad.json");
+			fs.writeFileSync(requestPath, "{ not json", "utf-8");
+
+			assert.deepEqual(consumeStopRequestPayloads(asyncDir), []);
+			assert.equal(fs.existsSync(requestPath), false);
+		} finally {
+			cleanup(asyncDir);
+		}
+	});
+
+	it("drops invalid child-scoped stop fields instead of widening to a run stop", () => {
+		const asyncDir = tmpAsyncDir("pi-control-stop-invalid-child-");
+		try {
+			fs.mkdirSync(stopRequestsDir(asyncDir), { recursive: true });
+			const requestPath = path.join(stopRequestsDir(asyncDir), "0000000001234-bad-child.json");
+			fs.writeFileSync(requestPath, JSON.stringify({ type: "stop", targetIndex: -1, childId: "bad\nchild" }), "utf-8");
+
+			assert.deepEqual(consumeStopRequestPayloads(asyncDir), []);
+			assert.equal(fs.existsSync(requestPath), false);
+		} finally {
+			cleanup(asyncDir);
+		}
+	});
+
 	it("keeps the request type authoritative even for untyped callers", () => {
 		const asyncDir = tmpAsyncDir("pi-control-write-type-");
 		try {
@@ -377,7 +442,7 @@ describe("control channel: watchAsyncControlInbox", () => {
 		try {
 			const nativeDir = path.join(path.dirname(asyncDir), "native-control-path");
 			const h = harness(nativeDir);
-			const dispose = watchAsyncControlInbox(asyncDir, { onInterrupt() {}, fs: h.fsImpl, timers: h.timers });
+			const dispose = watchAsyncControlInbox(asyncDir, { onInterrupt() {}, fs: h.fsImpl, timers: h.timers, platform: "linux" });
 			assert.equal(h.watchedDir(), nativeDir);
 			dispose();
 		} finally {
@@ -389,7 +454,7 @@ describe("control channel: watchAsyncControlInbox", () => {
 		const asyncDir = tmpAsyncDir("pi-control-watch-no-poll-");
 		try {
 			const h = harness();
-			const dispose = watchAsyncControlInbox(asyncDir, { onInterrupt() {}, fs: h.fsImpl, timers: h.timers });
+			const dispose = watchAsyncControlInbox(asyncDir, { onInterrupt() {}, fs: h.fsImpl, timers: h.timers, platform: "linux" });
 			assert.deepEqual(h.intervalDelays(), [5000]);
 			dispose();
 		} finally {
@@ -401,7 +466,7 @@ describe("control channel: watchAsyncControlInbox", () => {
 		const asyncDir = tmpAsyncDir("pi-control-watch-fallback-");
 		try {
 			const h = harness();
-			const dispose = watchAsyncControlInbox(asyncDir, { onInterrupt() {}, fs: h.fsImpl, timers: h.timers });
+			const dispose = watchAsyncControlInbox(asyncDir, { onInterrupt() {}, fs: h.fsImpl, timers: h.timers, platform: "linux" });
 			h.triggerError();
 			h.triggerError();
 			assert.deepEqual(h.intervalDelays(), [5000, 250]);
@@ -411,13 +476,26 @@ describe("control channel: watchAsyncControlInbox", () => {
 		}
 	});
 
+	it("uses portable polling without native watchers on Darwin", () => {
+		const asyncDir = tmpAsyncDir("pi-control-watch-darwin-");
+		try {
+			const h = harness();
+			const dispose = watchAsyncControlInbox(asyncDir, { onInterrupt() {}, fs: h.fsImpl, timers: h.timers, platform: "darwin" });
+			assert.equal(h.watchedDir(), undefined);
+			assert.deepEqual(h.intervalDelays(), [250]);
+			dispose();
+		} finally {
+			cleanup(asyncDir);
+		}
+	});
+
 	it("fires on a request that arrived before the watcher started", () => {
 		const asyncDir = tmpAsyncDir("pi-control-watch-early-");
 		try {
 			requestAsyncInterrupt(asyncDir);
 			let fired = 0;
 			const h = harness();
-			const dispose = watchAsyncControlInbox(asyncDir, { onInterrupt: () => fired++, fs: h.fsImpl, timers: h.timers });
+			const dispose = watchAsyncControlInbox(asyncDir, { onInterrupt: () => fired++, fs: h.fsImpl, timers: h.timers, platform: "linux" });
 			assert.equal(fired, 1);
 			assert.equal(fs.existsSync(interruptRequestPath(asyncDir)), false);
 			dispose();
@@ -431,7 +509,7 @@ describe("control channel: watchAsyncControlInbox", () => {
 		try {
 			let fired = 0;
 			const h = harness();
-			const dispose = watchAsyncControlInbox(asyncDir, { onInterrupt: () => fired++, fs: h.fsImpl, timers: h.timers });
+			const dispose = watchAsyncControlInbox(asyncDir, { onInterrupt: () => fired++, fs: h.fsImpl, timers: h.timers, platform: "linux" });
 			assert.equal(fired, 0);
 
 			requestAsyncInterrupt(asyncDir);
@@ -467,6 +545,7 @@ describe("control channel: watchAsyncControlInbox", () => {
 				onStop: () => events.push("stop"),
 				fs: h.fsImpl,
 				timers: h.timers,
+				platform: "linux",
 			});
 
 			assert.deepEqual(events, ["stop", "interrupt"]);
@@ -476,6 +555,27 @@ describe("control channel: watchAsyncControlInbox", () => {
 		}
 	});
 
+	it("delivers stop payloads to the watcher", () => {
+		const asyncDir = tmpAsyncDir("pi-control-watch-child-stop-");
+		try {
+			requestAsyncStop(asyncDir, { targetIndex: 1, childId: "slow" });
+			const stops: Array<{ targetIndex?: number; childId?: string }> = [];
+			const h = harness();
+			const dispose = watchAsyncControlInbox(asyncDir, {
+				onInterrupt() {},
+				onStop: (request) => stops.push({ targetIndex: request.targetIndex, childId: request.childId }),
+				fs: h.fsImpl,
+				timers: h.timers,
+				platform: "linux",
+			});
+
+			assert.deepEqual(stops, [{ targetIndex: 1, childId: "slow" }]);
+			dispose();
+		} finally {
+			cleanup(asyncDir);
+		}
+	});
+
 	it("delivers steer requests without firing interrupt", () => {
 		const asyncDir = tmpAsyncDir("pi-control-watch-steer-");
 		try {
@@ -487,6 +587,7 @@ describe("control channel: watchAsyncControlInbox", () => {
 				onSteer: (request) => steers.push({ message: request.message, targetIndex: request.targetIndex }),
 				fs: h.fsImpl,
 				timers: h.timers,
+				platform: "linux",
 			});
 
 			requestAsyncSteer(asyncDir, { message: "go narrower", targetIndex: 0, id: "s", ts: 1 });
@@ -510,6 +611,7 @@ describe("control channel: watchAsyncControlInbox", () => {
 				onSteer: (request) => steers.push(request.message),
 				fs: h.fsImpl,
 				timers: h.timers,
+				platform: "linux",
 			});
 
 			const watchedSteerDir = fs.realpathSync.native(steerRequestsDir(asyncDir));

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

@@ -84,7 +84,7 @@ describe("subagents.defaultExtensions", () => {
 		);
 		assert.deepEqual(
 			agents.find((agent) => agent.name === "explicit")?.extensions,
-			["./explicit.ts"],
+			[path.join(tempProject, ".selesai", "agents", "explicit.ts")],
 		);
 		assert.deepEqual(
 			agents.find((agent) => agent.name === "disabled")?.extensions,
@@ -117,7 +117,7 @@ describe("subagents.defaultExtensions", () => {
 		);
 		assert.deepEqual(
 			agents.find((agent) => agent.name === "explicit")?.extensions,
-			["./frontmatter.ts"],
+			[path.join(tempProject, ".selesai", "agents", "frontmatter.ts")],
 		);
 	});
 

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

@@ -82,6 +82,7 @@ describe("buildDoctorReport", () => {
 						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"),
@@ -112,7 +113,7 @@ describe("buildDoctorReport", () => {
 			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, /- chains: total 2 \(builtin 0, package 0, user 1, project 1\)/);
+			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/);
@@ -120,6 +121,8 @@ describe("buildDoctorReport", () => {
 			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, /missing or unknown cleanup proof retains capacity/);
+			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\)/);
@@ -188,7 +191,7 @@ describe("buildDoctorReport", () => {
 			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\/chains: failed — Error: discovery exploded/);
+			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 {

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

@@ -139,14 +139,15 @@ describe("dynamic fanout helpers", () => {
 		);
 	});
 
-	it("accepts toolBudget on dynamic parallel templates", () => {
+	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}", toolBudget: { hard: 3 } },
+			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", () => {

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

@@ -0,0 +1,79 @@
+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/external-cli-runner.test.ts

@@ -4,6 +4,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { afterEach, describe, it } from "node:test";
 import { buildExternalCliPrompt, runExternalCli } from "../../src/runs/shared/external-cli-runner.ts";
+import { SELESAI_SUBAGENT_EXTENSION_BINDINGS_ENV } from "../../src/runs/shared/extension-bindings.ts";
 
 const tempDirs: string[] = [];
 function tempDir(): string {
@@ -16,6 +17,27 @@ afterEach(() => {
 });
 
 describe("external CLI runner", () => {
+	it("clears ambient extension bindings from the external process", async () => {
+		const dir = tempDir();
+		const previous = process.env[SELESAI_SUBAGENT_EXTENSION_BINDINGS_ENV];
+		process.env[SELESAI_SUBAGENT_EXTENSION_BINDINGS_ENV] = '{"shepherd.dispatch/1":{"role":"coder"}}';
+		try {
+			const result = await runExternalCli({
+				command: process.execPath,
+				args: ["-e", `process.stdout.write(process.env.${SELESAI_SUBAGENT_EXTENSION_BINDINGS_ENV} ?? "unset")`],
+				cwd: dir,
+				prompt: "x",
+				asyncDir: dir,
+				stepIndex: 0,
+			});
+			assert.equal(result.exitCode, 0);
+			assert.equal(result.output, "unset");
+		} finally {
+			if (previous === undefined) delete process.env[SELESAI_SUBAGENT_EXTENSION_BINDINGS_ENV];
+			else process.env[SELESAI_SUBAGENT_EXTENSION_BINDINGS_ENV] = previous;
+		}
+	});
+
 	it("delivers the combined prompt only through stdin and preserves argv", async () => {
 		const dir = tempDir();
 		const prompt = buildExternalCliPrompt("Follow exactly.", "Review $HOME; echo nope");