@selesai/code 0.13.15 → 0.13.18

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

@@ -6,14 +6,11 @@ import { describe, it } from "node:test";
 import {
 	closeSteerInbox,
 	consumeInterruptRequest,
-	consumeSteerAcks,
-	consumeSteerCapabilities,
 	consumeSteerRequests,
 	consumeStopRequest,
 	consumeStopRequestPayload,
 	consumeStopRequestPayloads,
 	deliverInterruptRequest,
-	enqueueStepSteer,
 	interruptRequestPath,
 	MAX_STEER_QUEUE_SIZE,
 	queueRevivalBrief,
@@ -21,16 +18,12 @@ import {
 	requestAsyncInterrupt,
 	requestAsyncSteer,
 	requestAsyncStop,
-	steerAckPathFromDir,
-	steerAcksDir,
+	requestAsyncTimeout,
+	timeoutRequestPath,
 	steerInboxClosedPath,
-	steerCapabilityPath,
 	stopRequestsDir,
-	writeSteerAck,
-	writeSteerCapability,
 	stopRequestPath,
 	steerRequestsDir,
-	stepSteerInboxDir,
 	watchAsyncControlInbox,
 } from "../../src/runs/background/control-channel.ts";
 
@@ -265,19 +258,6 @@ describe("control channel: request file", () => {
 		}
 	});
 
-	it("enqueues a steer request for a specific child inbox", () => {
-		const asyncDir = tmpAsyncDir("pi-control-step-steer-");
-		try {
-			enqueueStepSteer(asyncDir, 2, { type: "steer", id: "s1", ts: 300, message: "focus", targetIndexes: [0, 1] });
-			const request = JSON.parse(fs.readFileSync(path.join(stepSteerInboxDir(asyncDir, 2), fs.readdirSync(stepSteerInboxDir(asyncDir, 2))[0]!), "utf-8"));
-			assert.equal(request.targetIndex, 2);
-			assert.equal(request.targetIndexes, undefined);
-			assert.equal(request.message, "focus");
-		} finally {
-			cleanup(asyncDir);
-		}
-	});
-
 	it("bounds retained revival briefs and keeps them FIFO", () => {
 		const asyncDir = tmpAsyncDir("pi-control-revival-brief-");
 		try {
@@ -308,47 +288,6 @@ describe("control channel: request file", () => {
 		}
 	});
 
-	it("writes strict capabilities and acknowledgments with safe paths", () => {
-		const asyncDir = tmpAsyncDir("pi-control-steer-ack-");
-		try {
-			const capabilityPath = writeSteerCapability(asyncDir, { index: 0, pid: 42, readyAt: 100, supported: true });
-			assert.equal(capabilityPath, steerCapabilityPath(asyncDir, 0));
-			writeSteerAck(asyncDir, { requestId: "../request", index: 0, ts: 101, state: "queued", deliveryStatus: "queued", message: "accepted" });
-			assert.equal(path.dirname(steerAckPathFromDir(steerAcksDir(asyncDir, 0), "../request")), steerAcksDir(asyncDir, 0));
-			assert.deepEqual(consumeSteerCapabilities(asyncDir), [{ type: "steer-capability", protocolVersion: 1, index: 0, pid: 42, readyAt: 100, supported: true }]);
-			assert.deepEqual(consumeSteerAcks(asyncDir), [{ type: "steer-ack", protocolVersion: 1, requestId: "../request", index: 0, ts: 101, state: "queued", deliveryStatus: "queued", message: "accepted" }]);
-			assert.deepEqual(consumeSteerAcks(asyncDir), []);
-		} finally {
-			cleanup(asyncDir);
-		}
-	});
-
-	it("preserves queued and delivered receipts for the same request", () => {
-		const asyncDir = tmpAsyncDir("pi-control-steer-ack-order-");
-		try {
-			writeSteerAck(asyncDir, { requestId: "follow", index: 0, ts: 101, state: "queued", deliveryStatus: "queued", message: "queued" });
-			writeSteerAck(asyncDir, { requestId: "follow", index: 0, ts: 102, state: "delivered", deliveryStatus: "delivered", message: "delivered" });
-			assert.deepEqual(consumeSteerAcks(asyncDir).map((ack) => ack.state), ["queued", "delivered"]);
-		} finally {
-			cleanup(asyncDir);
-		}
-	});
-
-	it("ignores malformed capabilities and acknowledgments", () => {
-		const asyncDir = tmpAsyncDir("pi-control-steer-malformed-");
-		try {
-			fs.mkdirSync(path.join(asyncDir, "control", "steer-capabilities"), { recursive: true });
-			fs.writeFileSync(steerCapabilityPath(asyncDir, 0), JSON.stringify({ type: "steer-capability", protocolVersion: 99 }), "utf-8");
-			fs.mkdirSync(steerAcksDir(asyncDir, 0), { recursive: true });
-			fs.writeFileSync(path.join(steerAcksDir(asyncDir, 0), "bad.json"), JSON.stringify({ type: "steer-ack", protocolVersion: 1, requestId: "", index: 0, ts: 1, state: "delivered", message: "bad" }), "utf-8");
-			fs.writeFileSync(path.join(asyncDir, "control", "steer-acks", "1"), "not a directory", "utf-8");
-			writeSteerAck(asyncDir, { requestId: "valid", index: 2, ts: 2, state: "delivered", message: "accepted" });
-			assert.deepEqual(consumeSteerCapabilities(asyncDir), []);
-			assert.deepEqual(consumeSteerAcks(asyncDir), [{ type: "steer-ack", protocolVersion: 1, requestId: "valid", index: 2, ts: 2, state: "delivered", message: "accepted" }]);
-		} finally {
-			cleanup(asyncDir);
-		}
-	});
 });
 
 describe("control channel: deliverInterruptRequest", () => {
@@ -538,17 +477,23 @@ describe("control channel: watchAsyncControlInbox", () => {
 		try {
 			requestAsyncStop(asyncDir);
 			requestAsyncInterrupt(asyncDir);
+			requestAsyncTimeout(asyncDir);
+			requestAsyncSteer(asyncDir, { id: "all-handlers", message: "guide" });
 			const events: string[] = [];
 			const h = harness();
 			const dispose = watchAsyncControlInbox(asyncDir, {
 				onInterrupt: () => events.push("interrupt"),
 				onStop: () => events.push("stop"),
+				onTimeout: () => events.push("timeout"),
+				onSteer: () => events.push("steer"),
 				fs: h.fsImpl,
 				timers: h.timers,
 				platform: "linux",
 			});
 
-			assert.deepEqual(events, ["stop", "interrupt"]);
+			assert.deepEqual(events, ["stop", "timeout", "interrupt", "steer"]);
+			h.trigger();
+			assert.deepEqual(events, ["stop", "timeout", "interrupt", "steer"], "all-handler runner consumes each request once");
 			dispose();
 		} finally {
 			cleanup(asyncDir);
@@ -627,4 +572,219 @@ describe("control channel: watchAsyncControlInbox", () => {
 			cleanup(asyncDir);
 		}
 	});
-});
+
+	it("consumes a steer request that arrived before the watcher started", () => {
+		const asyncDir = tmpAsyncDir("pi-steer-watch-early-");
+		try {
+			requestAsyncSteer(asyncDir, { message: "queued before install", id: "s1", ts: 1 });
+			const steers: string[] = [];
+			const h = harness();
+			const dispose = watchAsyncControlInbox(asyncDir, { onSteer: (request) => steers.push(request.message), fs: h.fsImpl, timers: h.timers, platform: "linux" });
+			assert.deepEqual(steers, ["queued before install"]);
+			assert.deepEqual(fs.readdirSync(steerRequestsDir(asyncDir)), []);
+			dispose();
+		} finally {
+			cleanup(asyncDir);
+		}
+	});
+
+	it("consumes later requests via the watch event and stops after dispose", () => {
+		const asyncDir = tmpAsyncDir("pi-steer-watch-event-");
+		try {
+			const steers: string[] = [];
+			const h = harness();
+			const dispose = watchAsyncControlInbox(asyncDir, { onSteer: (request) => steers.push(request.message), fs: h.fsImpl, timers: h.timers, platform: "linux" });
+			assert.deepEqual(steers, []);
+
+			requestAsyncSteer(asyncDir, { message: "first", id: "s1", ts: 1 });
+			h.trigger();
+			assert.deepEqual(steers, ["first"]);
+
+			// A spurious event with nothing queued is a no-op.
+			h.trigger();
+			assert.deepEqual(steers, ["first"]);
+
+			dispose();
+			assert.equal(h.closed(), true);
+
+			requestAsyncSteer(asyncDir, { message: "after dispose", id: "s2", ts: 2 });
+			h.trigger();
+			assert.deepEqual(steers, ["first"], "a disposed watcher must not consume further requests");
+		} finally {
+			cleanup(asyncDir);
+		}
+	});
+
+	it("watches only the steer directory, so a stop request stays for its own consumer", () => {
+		const asyncDir = tmpAsyncDir("pi-steer-watch-scope-");
+		try {
+			requestAsyncStop(asyncDir, { source: "test" });
+			requestAsyncInterrupt(asyncDir);
+			requestAsyncTimeout(asyncDir);
+			const steers: string[] = [];
+			const h = harness();
+			const dispose = watchAsyncControlInbox(asyncDir, { onSteer: (request) => steers.push(request.message), fs: h.fsImpl, timers: h.timers, platform: "linux" });
+			h.trigger();
+			assert.deepEqual(steers, []);
+			assert.equal(h.watchedDir(), fs.realpathSync.native(steerRequestsDir(asyncDir)));
+			assert.equal(fs.readdirSync(stopRequestsDir(asyncDir)).length, 1, "a stop request must not be consumed by the steer watcher");
+			assert.equal(fs.existsSync(interruptRequestPath(asyncDir)), true);
+			assert.equal(fs.existsSync(timeoutRequestPath(asyncDir)), true);
+			dispose();
+		} finally {
+			cleanup(asyncDir);
+		}
+	});
+
+	it("keeps watching when a consumer throws", () => {
+		const asyncDir = tmpAsyncDir("pi-steer-watch-throws-");
+		try {
+			const seen: string[] = [];
+			const failures: string[] = [];
+			const h = harness();
+			const dispose = watchAsyncControlInbox(asyncDir, {
+				onError: (_error, phase, request) => failures.push(`${phase}:${request?.id}`),
+				onSteer: (request) => {
+					seen.push(request.message);
+					if (request.message === "boom") throw new Error("consumer failed");
+				},
+				fs: h.fsImpl,
+				timers: h.timers,
+				platform: "linux",
+			});
+
+			requestAsyncSteer(asyncDir, { message: "boom", id: "s1", ts: 1 });
+			requestAsyncSteer(asyncDir, { message: "still delivered", id: "s2", ts: 2 });
+			h.trigger();
+
+			assert.deepEqual(seen, ["boom", "still delivered"], "a throwing consumer must not kill the watcher");
+			assert.deepEqual(failures, ["callback:s1"]);
+			dispose();
+		} finally {
+			cleanup(asyncDir);
+		}
+	});
+});
+
+describe("control inbox diagnostics and active-owner cost", () => {
+	for (const operation of ["read", "remove"] as const) it(`retries stop request ${operation} failures without losing readable siblings`, () => {
+		const asyncDir = tmpAsyncDir("pi-stop-retry-");
+		const denied = Object.assign(new Error("denied"), { code: "EACCES" });
+		const pending = requestAsyncStop(asyncDir, { childId: "retry" });
+		requestAsyncStop(asyncDir, { childId: "ready" });
+		const seen: string[] = [], failures: unknown[] = [];
+		let failing = true, tick = () => {};
+		const dispose = watchAsyncControlInbox(asyncDir, {
+			onStop: (request) => seen.push(request.childId!),
+			onError: (error, phase) => { assert.equal(phase, "scan"); failures.push(error); },
+			platform: "darwin",
+			fs: { ...fs, readFileSync: ((...args: Parameters<typeof fs.readFileSync>) => {
+				if (failing && operation === "read" && args[0] === pending) throw denied;
+				return fs.readFileSync(...args);
+			}) as typeof fs.readFileSync, rmSync: (target, options) => {
+				if (failing && operation === "remove" && target === pending) throw denied;
+				fs.rmSync(target, options);
+			} },
+			timers: { setInterval: ((handler: () => void) => { tick = handler; return { unref() {} }; }) as unknown as typeof setInterval, clearInterval() {} },
+		});
+		try {
+			assert.deepEqual(seen, ["ready"]);
+			assert.deepEqual(failures, [denied]);
+			assert.equal(fs.existsSync(pending), true);
+			failing = false;
+			tick();
+			assert.deepEqual(seen, ["ready", "retry"]);
+			assert.equal(fs.existsSync(pending), false);
+			tick();
+			assert.deepEqual(seen, ["ready", "retry"]);
+		} finally { dispose(); cleanup(asyncDir); }
+	});
+
+	it("reports scan/read/install failures, retains retryable files, and distinguishes healthy watch fallback", () => {
+		const asyncDir = tmpAsyncDir("pi-steer-diagnostics-");
+		const failures: string[] = [];
+		const seen: string[] = [];
+		let tick: () => void = () => {};
+		let fault: "scan" | "read" | "none" = "scan";
+		const denied = Object.assign(new Error("denied"), { code: "EACCES" });
+		const dispose = watchAsyncControlInbox(asyncDir, {
+			onSteer: (request) => seen.push(request.id),
+			onError: (_error, phase) => failures.push(phase),
+			platform: "linux",
+			fs: {
+				...fs,
+				mkdirSync: (() => { throw denied; }) as typeof fs.mkdirSync,
+				readdirSync: ((...args: Parameters<typeof fs.readdirSync>) => { if (fault === "scan") throw denied; return fs.readdirSync(...args); }) as typeof fs.readdirSync,
+				readFileSync: ((...args: Parameters<typeof fs.readFileSync>) => { if (fault === "read") throw denied; return fs.readFileSync(...args); }) as typeof fs.readFileSync,
+				watch: (() => { throw new Error("native watch unavailable"); }) as typeof fs.watch,
+			},
+			timers: {
+				setInterval: ((handler: () => void) => { tick = handler; return { unref() {} }; }) as unknown as typeof setInterval,
+				clearInterval: (() => {}) as typeof clearInterval,
+			},
+		});
+		try {
+			requestAsyncSteer(asyncDir, { id: "retry", message: "retry" });
+			tick();
+			assert.deepEqual(failures, ["install", "scan", "scan"]);
+			assert.equal(fs.readdirSync(steerRequestsDir(asyncDir)).length, 1);
+			fault = "read";
+			tick();
+			assert.equal(failures.at(-1), "scan");
+			assert.equal(fs.readdirSync(steerRequestsDir(asyncDir)).length, 1);
+			fault = "none";
+			tick();
+			assert.deepEqual(seen, ["retry"]);
+			assert.deepEqual(fs.readdirSync(steerRequestsDir(asyncDir)), []);
+			assert.equal(failures.length, 4, "healthy fallback does not report consumption failure");
+		} finally { dispose(); cleanup(asyncDir); }
+	});
+
+	for (const mode of ["native", "fallback", "portable"]) for (const owners of [1, 8]) it(`measures bounded empty-inbox ${mode} and cleanup for ${owners} active owners`, async (t) => {
+		const asyncDir = tmpAsyncDir("pi-steer-cost-");
+		const handles = new Set<ReturnType<typeof setInterval>>();
+		const watchers = new Set<fs.FSWatcher>();
+		const watchedDirs: string[] = [];
+		const disposers: Array<() => void> = [];
+		let scans = 0;
+		let scanMs = 0;
+		const cpuStart = process.cpuUsage();
+		const start = performance.now();
+		try {
+			for (let index = 0; index < owners; index++) disposers.push(watchAsyncControlInbox(path.join(asyncDir, String(index)), {
+				onSteer() {}, platform: mode === "portable" ? "darwin" : "linux",
+				fs: { ...fs, readdirSync: ((...args: Parameters<typeof fs.readdirSync>) => {
+					const before = performance.now();
+					try { return fs.readdirSync(...args); } finally { scans++; scanMs += performance.now() - before; }
+				}) as typeof fs.readdirSync, watch: ((target: string, listener: fs.WatchListener<string>) => {
+					watchedDirs.push(target);
+					const watcher = fs.watch(target, listener);
+					watchers.add(watcher);
+					const close = watcher.close.bind(watcher);
+					watcher.close = () => { watchers.delete(watcher); close(); };
+					if (mode === "fallback") queueMicrotask(() => watcher.emit("error", new Error("watch unavailable")));
+					return watcher;
+				}) as typeof fs.watch },
+				timers: {
+					setInterval: ((handler: () => void, delay: number) => { const handle = setInterval(handler, delay); handles.add(handle); return handle; }) as typeof setInterval,
+					clearInterval: ((handle: ReturnType<typeof setInterval>) => { handles.delete(handle); clearInterval(handle); }) as typeof clearInterval,
+				},
+			}));
+			await new Promise((resolve) => setTimeout(resolve, 1_100));
+			const elapsed = performance.now() - start;
+			const cpu = process.cpuUsage(cpuStart);
+			assert.ok(scans >= owners && scans <= owners * 6, `bounded scans: ${scans}`);
+			assert.equal(handles.size, owners);
+			assert.equal(watchers.size, mode === "portable" ? 0 : owners);
+			assert.equal(watchedDirs.length, mode === "portable" ? 0 : owners, "only one directory watched per steer owner");
+			assert.ok(watchedDirs.every((dir) => dir.endsWith("steer-requests")));
+			for (const dispose of disposers) { dispose(); dispose(); }
+			assert.equal(handles.size, 0, "all real polling intervals cleared");
+			assert.equal(watchers.size, 0, "all native watchers closed");
+			const finalScans = scans;
+			await new Promise((resolve) => setTimeout(resolve, 300));
+			assert.equal(scans, finalScans, "no scans after owner cleanup");
+			t.diagnostic(JSON.stringify({ mode, owners, elapsedMs: +elapsed.toFixed(2), scans, scanMs: +scanMs.toFixed(3), processCpuMs: (cpu.user + cpu.system) / 1000, remainingTimers: handles.size, remainingWatchers: watchers.size }));
+		} finally { for (const dispose of disposers) dispose(); cleanup(asyncDir); }
+	});
+});

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

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
-import * as fs from "node:fs";
-import { afterEach, describe, it } from "node:test";
+import * as os from "node:os";
+import { describe, it } from "node:test";
 import { launchBindingDigest } from "../../src/shared/launch-contract.ts";
 import {
 	MAX_EXTENSION_BINDING_NAMESPACES,
@@ -10,29 +10,22 @@ import {
 	normalizeExtensionBindings,
 	omitExtensionBindingsEnv,
 } from "../../src/runs/shared/extension-bindings.ts";
-import { buildPiArgs } from "../../src/runs/shared/pi-args.ts";
+import { buildInProcessChildLaunch } from "../../src/runs/shared/child-launch.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> {
+function childEnv(extensionBindings?: ExtensionBindings, host: "parent" | "runner" = "runner"): Record<string, string | undefined> {
 	const normalizedExtensionBindings = normalizeExtensionBindings(extensionBindings)?.value;
-	const result = buildPiArgs({
-		baseArgs: [],
-		task: "test",
+	const launch = buildInProcessChildLaunch({
+		host,
+		cwd: os.tmpdir(),
+		childAgentName: "worker",
+		childIndex: 0,
 		sessionEnabled: false,
 		inheritProjectContext: false,
+		inheritGlobalContext: false,
 		inheritSkills: false,
 		extensionBindings: normalizedExtensionBindings,
 	});
-	if (result.tempDir) tempDirs.push(result.tempDir);
-	return result.env;
+	return launch.session.processEnv ?? {};
 }
 
 describe("extension bindings", () => {
@@ -58,10 +51,12 @@ describe("extension bindings", () => {
 		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);
+	it("sets canonical child env for the runner host and clears it when omitted", () => {
+		const omitted = childEnv();
+		assert.equal(Object.hasOwn(omitted, SELESAI_SUBAGENT_EXTENSION_BINDINGS_ENV), true);
+		assert.equal(omitted[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}}');
+		assert.deepEqual(childEnv({ "child/1": true }, "parent"), {}, "the parent host never writes child environment values");
 	});
 
 	it("removes ambient bindings from external runner environments", () => {
@@ -76,4 +71,4 @@ describe("extension bindings", () => {
 		assert.notEqual(first, omitted);
 		assert.notEqual(first, second);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/fleet-status.test.ts

@@ -178,6 +178,16 @@ describe("below-editor subagent FleetView", () => {
 			assert.ok(compactLines[0]!.includes("↓/← to inspect"));
 			assert.ok(visibleWidth(compactLines[0]!) <= 80);
 
+			state.activeAsyncCapacity = { used: 0, limit: 0 };
+			const unlimitedIdleSummary = component.render(80)[0]!;
+			assert.match(unlimitedIdleSummary, /7 active agents/);
+			assert.doesNotMatch(unlimitedIdleSummary, /Async runs 0\/∞/);
+			state.activeAsyncCapacity = { used: 2, limit: 0 };
+			assert.match(component.render(80)[0]!, /Async runs 2\/∞/);
+			state.activeAsyncCapacity = { used: 0, limit: 4 };
+			assert.match(component.render(80)[0]!, /Async runs 0\/4/);
+			state.activeAsyncCapacity = { used: 2, limit: 4 };
+
 			assert.deepEqual(fleet.handleKey("\x1b[B"), { consume: true });
 			const expandedLines = component.render(80);
 			assert.ok(expandedLines.some((line) => line.includes("> main")));
@@ -1374,4 +1384,4 @@ describe("below-editor subagent FleetView", () => {
 			fleet.dispose();
 		}
 	});
-});
+});

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

@@ -44,6 +44,7 @@ function writeAsyncRun(root: string, input: {
 	state?: "running" | "complete" | "failed";
 	mode?: "single" | "parallel" | "workflow";
 	lastUpdate?: number;
+	startedAt?: number;
 	agents?: string[];
 	contexts?: Array<"fresh" | "fork">;
 	models?: string[];
@@ -63,7 +64,7 @@ function writeAsyncRun(root: string, input: {
 		sessionId: input.sessionId ?? "session-current",
 		mode: input.mode ?? (agents.length > 1 ? "parallel" : "single"),
 		state,
-		startedAt: 100,
+		startedAt: input.startedAt ?? 100,
 		lastUpdate: input.lastUpdate ?? 200,
 		currentStep: 0,
 		steps: agents.map((agent, index) => ({
@@ -446,6 +447,29 @@ describe("native subagent fleet", () => {
 		}
 	});
 
+	it("keeps tracked missing-start rows stable across opposing heartbeat updates", () => {
+		const state = stateForTest();
+		state.fleetJobs = new Map();
+		for (const [id, startedAt, status] of [
+			["known", 100, "running"], ["unknown-b", undefined, "running"], ["unknown-a", undefined, "queued"],
+		] as const) {
+			state.fleetJobs.set(id, {
+				asyncId: id, asyncDir: `/tmp/${id}`, sessionId: "session-current", status, startedAt,
+			});
+		}
+		for (const direction of [1, -1]) {
+			let heartbeat = 500;
+			for (const job of state.fleetJobs.values()) job.updatedAt = heartbeat += direction * 10;
+			const snapshot = collectFleetSnapshot(state);
+			assert.equal(snapshot.error, undefined);
+			assert.deepEqual(snapshot.items.map((item) => item.key), ["async:unknown-a", "async:unknown-b", "async:known"]);
+			for (const item of snapshot.items) {
+				const job = state.fleetJobs.get(item.runId)!;
+				assert.equal(item.run?.startedAt, job.startedAt ?? job.updatedAt);
+			}
+		}
+	});
+
 	it("keeps tracked active workflows ahead of older failed terminal history", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-history-"));
 		try {
@@ -627,8 +651,8 @@ describe("native subagent fleet", () => {
 		});
 		const snapshot = collectFleetSnapshot(state);
 		assert.deepEqual(snapshot.items.map((item) => item.key), [
-			"foreground-active:child-2:0",
 			"foreground-active:child-1:0",
+			"foreground-active:child-2:0",
 			"async:unrelated",
 			"async:workflow-1",
 		]);
@@ -697,6 +721,26 @@ describe("native subagent fleet", () => {
 		assert.ok(!snapshot.items.some((item) => item.runId === "terminal-0"));
 	});
 
+	it("orders active runs by start time so the roster stays stable while they emit", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-active-order-"));
+		try {
+			writeAsyncRun(root, { id: "worker-b", startedAt: 200, lastUpdate: 900 });
+			writeAsyncRun(root, { id: "worker-a", startedAt: 100, lastUpdate: 500 });
+			const state = stateForTest();
+			const keys = () => collectFleetSnapshot(state, { asyncDirRoot: root, resultsDir: path.join(root, "results") }).items.map((item) => item.key);
+			// First refresh: the run created first stays on top, even though worker-b emitted most recently.
+			assert.deepEqual(keys(), ["async:worker-a:0", "async:worker-b:0"]);
+			// Later activity on worker-b must not reorder the roster.
+			writeAsyncRun(root, { id: "worker-b", startedAt: 200, lastUpdate: 1500 });
+			assert.deepEqual(keys(), ["async:worker-a:0", "async:worker-b:0"]);
+			// A run started later still lands after the earlier ones.
+			writeAsyncRun(root, { id: "worker-c", startedAt: 300, lastUpdate: 300 });
+			assert.deepEqual(keys(), ["async:worker-a:0", "async:worker-b:0", "async:worker-c:0"]);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("accepts default Fleet navigation from Kitty CSI-u input", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-kitty-default-"));
 		try {
@@ -1783,4 +1827,4 @@ describe("native subagent fleet", () => {
 			fs.rmSync(root, { recursive: true, force: true });
 		}
 	});
-});
+});

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

@@ -0,0 +1,74 @@
+import { it } from "node:test";
+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 { steerWorkflowRun } from "../../src/runs/foreground/workflow-foreground-steering.ts";
+import { closeSteerInbox, steerRequestsDir } from "../../src/runs/background/control-channel.ts";
+import { currentCompletionOwnerId } from "../../src/shared/completion-owner.ts";
+import type { SubagentState } from "../../src/shared/types.ts";
+
+it("foreign admission refuses invalid authority, identities, ownership, status and projected targets without writes", async () => {
+	const root = fs.mkdtempSync(path.join(os.tmpdir(), "foreign-workflow-"));
+	const runId = "workflow-run";
+	const asyncDir = path.join(root, runId);
+	fs.mkdirSync(asyncDir);
+	const baseline = { runId, mode: "workflow", state: "running", sessionId: "parent-file", completionOwnerId: "foreign-owner", steps: [{ status: "running", workflowKey: "A" }] };
+	const makeState = (): SubagentState => ({ baseCwd: root, currentSessionId: "parent-file", asyncJobs: new Map(), foregroundControls: new Map(), lastForegroundControlId: null });
+	const control = (id: string): any => ({ runId: id, parentWorkflowRunId: runId, sessionId: "parent-file", activeChildren: new Map([[0, { steer: async () => ({ state: "delivered" }) }]]) });
+	try {
+		const cases: Array<{ name: string; status?: object; state?: (s: SubagentState) => void; index?: number }> = [
+			{ name: "missing session", state: s => { s.currentSessionId = null; } },
+			{ name: "wrong session", state: s => { s.currentSessionId = "other"; } },
+			{ name: "wrong run", status: { runId: "other" } },
+			{ name: "non-workflow", status: { mode: "single" } },
+			...(["complete", "failed", "partial", "paused", "stopped"] as const).map(state => ({ name: state, status: { state } })),
+			{ name: "missing owner", status: { completionOwnerId: undefined } },
+			{ name: "invalid owner", status: { completionOwnerId: 123 } },
+			{ name: "blank owner", status: { completionOwnerId: " " } },
+			{ name: "local orphan", status: { completionOwnerId: currentCompletionOwnerId() } },
+			{ name: "configured local orphan", status: { completionOwnerId: "configured" }, state: s => { s.completionOwnerId = "configured"; } },
+			{ name: "contradictory control", state: s => { s.foregroundControls.set("A", control("A")); } },
+			{ name: "local empty controller", state: s => { s.workflowControllers = new Map([[runId, new AbortController()]]); } },
+			{ name: "local ambiguity", state: s => { s.workflowControllers = new Map([[runId, new AbortController()]]); s.foregroundControls.set("A", control("A")); s.foregroundControls.set("B", control("B")); } },
+			...[NaN, Infinity, -1, 0.5, 1].map(index => ({ name: `invalid index ${index}`, index })),
+			{ name: "terminal child", index: 0, status: { steps: [{ status: "complete", workflowKey: "A" }] } },
+			{ name: "missing projected key", index: 0, status: { steps: [{ status: "running" }] } },
+		];
+		for (const test of cases) {
+			const statusText = JSON.stringify({ ...baseline, ...test.status });
+			fs.writeFileSync(path.join(asyncDir, "status.json"), statusText);
+			const state = makeState(); test.state?.(state);
+			const result = await steerWorkflowRun({ state, runId, asyncDir, message: "steer", index: test.index, ackTimeoutMs: 0 });
+			assert.equal(result.isError, true, test.name);
+			assert.equal(fs.readFileSync(path.join(asyncDir, "status.json"), "utf8"), statusText, test.name);
+			assert.equal(fs.existsSync(steerRequestsDir(asyncDir)), false, test.name);
+		}
+		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify(baseline));
+		const local = makeState(); local.workflowControllers = new Map([[runId, new AbortController()]]); local.foregroundControls.set("A", control("A"));
+		const badLocalIndex = await steerWorkflowRun({ state: local, runId, asyncDir, message: "local", index: 1, ackTimeoutMs: 0 });
+		assert.equal(badLocalIndex.isError, true);
+		assert.equal(fs.existsSync(steerRequestsDir(asyncDir)), false);
+		closeSteerInbox(asyncDir, "complete");
+		const closed = await steerWorkflowRun({ state: makeState(), runId, asyncDir, message: "closed", ackTimeoutMs: 0 });
+		assert.equal(closed.isError, true);
+		assert.match((closed.content[0] as any).text, /no longer accepts steering/);
+	} finally { fs.rmSync(root, { recursive: true, force: true }); }
+});
+
+it("explicit projected pending index stays addressed and queued without fabricating delivery or changing the owner ledger", async () => {
+	const root = fs.mkdtempSync(path.join(os.tmpdir(), "foreign-pending-"));
+	const runId = "workflow-run";
+	const asyncDir = path.join(root, runId); fs.mkdirSync(asyncDir);
+	try {
+		const status = JSON.stringify({ runId, mode: "workflow", state: "queued", sessionId: "parent", completionOwnerId: "foreign", steps: [{ status: "complete", workflowKey: "A" }, { status: "pending", workflowKey: "B" }] });
+		fs.writeFileSync(path.join(asyncDir, "status.json"), status);
+		const state: SubagentState = { baseCwd: root, currentSessionId: "parent", asyncJobs: new Map(), foregroundControls: new Map(), lastForegroundControlId: null };
+		const result = await steerWorkflowRun({ state, runId, asyncDir, message: "next", index: 1, mode: "follow_up", ackTimeoutMs: 0 });
+		assert.equal(result.details.steering?.state, "pending");
+		assert.deepEqual(result.details.steering?.targets, [{ index: 1, state: "pending" }]);
+		const request = JSON.parse(fs.readFileSync(path.join(steerRequestsDir(asyncDir), fs.readdirSync(steerRequestsDir(asyncDir))[0]!), "utf8"));
+		assert.equal(request.targetIndex, 1); assert.equal(request.targetIndexes, undefined); assert.equal(request.mode, "follow_up");
+		assert.equal(fs.readFileSync(path.join(asyncDir, "status.json"), "utf8"), status);
+	} finally { fs.rmSync(root, { recursive: true, force: true }); }
+});