@selesai/code 0.13.15 → 0.13.18

package/dist/extensions/pi-subagents/test/unit/recursion-guard.test.ts

@@ -2,7 +2,7 @@ import { describe, it, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
 import {
 	checkSubagentDepth,
-	getSubagentDepthEnv,
+	resolveChildDepth,
 	DEFAULT_SUBAGENT_MAX_DEPTH,
 	normalizeMaxSubagentDepth,
 	normalizeMaxSubagentSpawnsPerSession,
@@ -13,21 +13,13 @@ import {
 	resolveCurrentMaxSubagentDepth,
 } from "../../src/shared/types.ts";
 
-let savedDepth: string | undefined;
-let savedMaxDepth: string | undefined;
 let savedMaxSpawns: string | undefined;
 
 beforeEach(() => {
-	savedDepth = process.env.SELESAI_SUBAGENT_DEPTH;
-	savedMaxDepth = process.env.SELESAI_SUBAGENT_MAX_DEPTH;
 	savedMaxSpawns = process.env.SELESAI_SUBAGENT_MAX_SPAWNS_PER_SESSION;
 });
 
 afterEach(() => {
-	if (savedDepth === undefined) delete process.env.SELESAI_SUBAGENT_DEPTH;
-	else process.env.SELESAI_SUBAGENT_DEPTH = savedDepth;
-	if (savedMaxDepth === undefined) delete process.env.SELESAI_SUBAGENT_MAX_DEPTH;
-	else process.env.SELESAI_SUBAGENT_MAX_DEPTH = savedMaxDepth;
 	if (savedMaxSpawns === undefined) delete process.env.SELESAI_SUBAGENT_MAX_SPAWNS_PER_SESSION;
 	else process.env.SELESAI_SUBAGENT_MAX_SPAWNS_PER_SESSION = savedMaxSpawns;
 });
@@ -100,18 +92,16 @@ describe("resolveMaxSubagentSpawnsPerSession", () => {
 });
 
 describe("resolveCurrentMaxSubagentDepth", () => {
-	it("uses env when present", () => {
-		process.env.SELESAI_SUBAGENT_MAX_DEPTH = "5";
-		assert.equal(resolveCurrentMaxSubagentDepth(1), 5);
+	it("uses the executor's own child runtime max when present", () => {
+		assert.equal(resolveCurrentMaxSubagentDepth(1, { depth: 1, maxDepth: 5 }), 5);
 	});
 
-	it("falls back to config when env is absent", () => {
-		delete process.env.SELESAI_SUBAGENT_MAX_DEPTH;
+	it("falls back to config for a top-level parent", () => {
 		assert.equal(resolveCurrentMaxSubagentDepth(1), 1);
+		assert.equal(resolveCurrentMaxSubagentDepth(1, { depth: 1 }), 1);
 	});
 
-	it("falls back to default when neither env nor config is valid", () => {
-		delete process.env.SELESAI_SUBAGENT_MAX_DEPTH;
+	it("falls back to default when neither runtime nor config is valid", () => {
 		assert.equal(resolveCurrentMaxSubagentDepth(undefined), 2);
 		assert.equal(resolveCurrentMaxSubagentDepth(-1), 2);
 	});
@@ -150,116 +140,75 @@ describe("resolveChildMaxSubagentDepth", () => {
 
 describe("checkSubagentDepth", () => {
 	it("not blocked at depth=0, max=2", () => {
-		process.env.SELESAI_SUBAGENT_DEPTH = "0";
-		process.env.SELESAI_SUBAGENT_MAX_DEPTH = "2";
-		const result = checkSubagentDepth();
+		const result = checkSubagentDepth(2);
 		assert.equal(result.blocked, false);
 		assert.equal(result.depth, 0);
 		assert.equal(result.maxDepth, 2);
 	});
 
-	it("uses config max depth when env is absent", () => {
-		process.env.SELESAI_SUBAGENT_DEPTH = "1";
-		delete process.env.SELESAI_SUBAGENT_MAX_DEPTH;
-		const result = checkSubagentDepth(1);
+	it("uses config max depth when the runtime carries none", () => {
+		const result = checkSubagentDepth(1, { depth: 1 });
 		assert.equal(result.blocked, true);
 		assert.equal(result.maxDepth, 1);
 	});
 
 	it("not blocked at depth=1, max=2", () => {
-		process.env.SELESAI_SUBAGENT_DEPTH = "1";
-		process.env.SELESAI_SUBAGENT_MAX_DEPTH = "2";
-		assert.equal(checkSubagentDepth().blocked, false);
+		assert.equal(checkSubagentDepth(undefined, { depth: 1, maxDepth: 2 }).blocked, false);
 	});
 
 	it("blocks at depth=1, max=1 after one nested level", () => {
-		process.env.SELESAI_SUBAGENT_DEPTH = "1";
-		process.env.SELESAI_SUBAGENT_MAX_DEPTH = "1";
-		assert.equal(checkSubagentDepth().blocked, true);
+		assert.equal(checkSubagentDepth(undefined, { depth: 1, maxDepth: 1 }).blocked, true);
 	});
 
 	it("blocked at depth=2, max=2", () => {
-		process.env.SELESAI_SUBAGENT_DEPTH = "2";
-		process.env.SELESAI_SUBAGENT_MAX_DEPTH = "2";
-		const result = checkSubagentDepth();
+		const result = checkSubagentDepth(undefined, { depth: 2, maxDepth: 2 });
 		assert.equal(result.blocked, true);
 		assert.equal(result.depth, 2);
 		assert.equal(result.maxDepth, 2);
 	});
 
 	it("blocked at depth=3, max=2", () => {
-		process.env.SELESAI_SUBAGENT_DEPTH = "3";
-		process.env.SELESAI_SUBAGENT_MAX_DEPTH = "2";
-		assert.equal(checkSubagentDepth().blocked, true);
+		assert.equal(checkSubagentDepth(undefined, { depth: 3, maxDepth: 2 }).blocked, true);
 	});
 
 	it("blocked at depth=0, max=0 (disables subagent entirely)", () => {
-		process.env.SELESAI_SUBAGENT_DEPTH = "0";
-		process.env.SELESAI_SUBAGENT_MAX_DEPTH = "0";
-		assert.equal(checkSubagentDepth().blocked, true);
+		assert.equal(checkSubagentDepth(0).blocked, true);
 	});
 
-	it("defaults to depth=0, max=2 when env vars unset", () => {
-		delete process.env.SELESAI_SUBAGENT_DEPTH;
-		delete process.env.SELESAI_SUBAGENT_MAX_DEPTH;
+	it("defaults to depth=0, max=2 for a top-level parent", () => {
 		const result = checkSubagentDepth();
 		assert.equal(result.blocked, false);
 		assert.equal(result.depth, 0);
 		assert.equal(result.maxDepth, 2);
 	});
 
-	it("not blocked when depth is invalid (NaN)", () => {
-		process.env.SELESAI_SUBAGENT_DEPTH = "garbage";
-		process.env.SELESAI_SUBAGENT_MAX_DEPTH = "2";
-		assert.equal(checkSubagentDepth().blocked, false);
+	it("not blocked when the runtime depth is invalid (NaN)", () => {
+		assert.equal(checkSubagentDepth(undefined, { depth: Number.NaN, maxDepth: 2 }).blocked, false);
 	});
 });
 
-describe("getSubagentDepthEnv", () => {
-	it("increments from depth=0", () => {
-		process.env.SELESAI_SUBAGENT_DEPTH = "0";
-		delete process.env.SELESAI_SUBAGENT_MAX_DEPTH;
-		const env = getSubagentDepthEnv();
-		assert.equal(env.SELESAI_SUBAGENT_DEPTH, "1");
-		assert.equal(env.SELESAI_SUBAGENT_MAX_DEPTH, "2");
+describe("resolveChildDepth", () => {
+	it("increments from a top-level parent", () => {
+		assert.deepEqual(resolveChildDepth(), { depth: 1, maxDepth: 2 });
 	});
 
 	it("increments from depth=1", () => {
-		process.env.SELESAI_SUBAGENT_DEPTH = "1";
-		delete process.env.SELESAI_SUBAGENT_MAX_DEPTH;
-		const env = getSubagentDepthEnv();
-		assert.equal(env.SELESAI_SUBAGENT_DEPTH, "2");
-		assert.equal(env.SELESAI_SUBAGENT_MAX_DEPTH, "2");
+		assert.deepEqual(resolveChildDepth(undefined, { depth: 1 }), { depth: 2, maxDepth: 2 });
 	});
 
 	it("uses provided max depth override", () => {
-		process.env.SELESAI_SUBAGENT_DEPTH = "0";
-		delete process.env.SELESAI_SUBAGENT_MAX_DEPTH;
-		const env = getSubagentDepthEnv(1);
-		assert.equal(env.SELESAI_SUBAGENT_DEPTH, "1");
-		assert.equal(env.SELESAI_SUBAGENT_MAX_DEPTH, "1");
+		assert.deepEqual(resolveChildDepth(1), { depth: 1, maxDepth: 1 });
 	});
 
-	it("respects inherited SELESAI_SUBAGENT_MAX_DEPTH when override is absent", () => {
-		process.env.SELESAI_SUBAGENT_DEPTH = "0";
-		process.env.SELESAI_SUBAGENT_MAX_DEPTH = "5";
-		const env = getSubagentDepthEnv();
-		assert.equal(env.SELESAI_SUBAGENT_DEPTH, "1");
-		assert.equal(env.SELESAI_SUBAGENT_MAX_DEPTH, "5");
+	it("respects the inherited runtime max when override is absent", () => {
+		assert.deepEqual(resolveChildDepth(undefined, { depth: 0, maxDepth: 5 }), { depth: 1, maxDepth: 5 });
 	});
 
-	it("uses the explicit child override even when a looser inherited env max exists", () => {
-		process.env.SELESAI_SUBAGENT_DEPTH = "0";
-		process.env.SELESAI_SUBAGENT_MAX_DEPTH = "5";
-		const env = getSubagentDepthEnv(1);
-		assert.equal(env.SELESAI_SUBAGENT_DEPTH, "1");
-		assert.equal(env.SELESAI_SUBAGENT_MAX_DEPTH, "1");
+	it("uses the explicit child override even when a looser inherited max exists", () => {
+		assert.deepEqual(resolveChildDepth(1, { depth: 0, maxDepth: 5 }), { depth: 1, maxDepth: 1 });
 	});
 
-	it("falls back to depth=1 when env var is invalid (NaN)", () => {
-		process.env.SELESAI_SUBAGENT_DEPTH = "not-a-number";
-		delete process.env.SELESAI_SUBAGENT_MAX_DEPTH;
-		const env = getSubagentDepthEnv();
-		assert.equal(env.SELESAI_SUBAGENT_DEPTH, "1");
+	it("falls back to depth=1 when the runtime depth is invalid (NaN)", () => {
+		assert.equal(resolveChildDepth(undefined, { depth: Number.NaN }).depth, 1);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/render-helpers.test.ts

@@ -312,7 +312,7 @@ test("workflow checklist does not map child-local result indexes onto graph node
 	assert.match(text, /✗ Writer · writer · failed/);
 });
 
-test("collapsed workflow widgets lead with checklist phases while expanded widgets keep child detail", () => {
+test("collapsed async workflow widgets render compact lane rows while expanded widgets keep child detail", () => {
 	const now = 50_000;
 	const workflowGraph = {
 		runId: "workflow-collapsed",
@@ -354,11 +354,12 @@ test("collapsed workflow widgets lead with checklist phases while expanded widge
 	const collapsed = buildWidgetLines([job], theme, 240).join("\n");
 	assert.match(collapsed, /1\/5 done · 1 active · 3 queued/);
 	assert.match(collapsed, /✓ inventory/);
-	assert.match(collapsed, /writers 1 active · 1 queued/);
-	assert.match(collapsed, /◦ reviews 1 queued/);
-	assert.match(collapsed, /◦ gates 1 queued/);
-	assert.match(collapsed, /bottleneck/);
-	assert.match(collapsed, /Press configured-expand-key for live detail · Ctrl\+Alt\+F Fleet/);
+	assert.match(collapsed, /writer-a · writer · active/);
+	assert.match(collapsed, /writer-b · writer · queued/);
+	assert.match(collapsed, /review · reviewer · queued/);
+	assert.match(collapsed, /gate · reviewer · queued/);
+	assert.doesNotMatch(collapsed, /bottleneck/);
+	assert.match(collapsed, /Press configured-expand-key for details · Ctrl\+Alt\+F Fleet/);
 	assert.equal((collapsed.match(/1\/5 done · 1 active · 3 queued/g) ?? []).length, 1);
 	assert.doesNotMatch(collapsed, /Step \d\/\d|task:|workspace:|ref:|out(?:put)?:/i);
 
@@ -381,7 +382,9 @@ test("collapsed workflow widgets lead with checklist phases while expanded widge
 			{ index: 1, agent: "scout", status: "running" },
 		],
 	} as AsyncJobState], theme, 240).join("\n");
-	assert.match(generic, /Workflow 2 active/);
+	assert.match(generic, /id: workflow · 0\/2 done · 2 active/);
+	assert.match(generic, /step-1 · reviewer · active · reviewer/);
+	assert.match(generic, /step-2 · scout · active · scout/);
 });
 
 test("compact foreground workflow results use checklist phases instead of child rows", () => {
@@ -636,4 +639,4 @@ test("main-window renderer config caps only collapsed rich result rows", () => {
 
 	assert.ok(expanded.length > 3);
 	assert.doesNotMatch(expanded.join("\n"), /rows hidden/);
-});
+});

package/dist/extensions/pi-subagents/test/unit/result-files.test.ts

@@ -41,7 +41,7 @@ describe("result file indexes", () => {
 			fs.rmSync(path.join(resultsDir, "missing.json"));
 			fs.writeFileSync(path.join(resultsDir, "unindexed.json"), JSON.stringify({ id: "unindexed", sessionId: "session-a" }), "utf-8");
 
-			assert.equal(cleanupResultIndexes(resultsDir, Date.now() + 86_400_001, 86_400_000), 3);
+			assert.equal(cleanupResultIndexes(resultsDir, Date.now() + 86_400_001, 86_400_000) > 0, true);
 
 			assert.deepEqual(resultFilesForSession(resultsDir, "session-a"), ["kept.json"]);
 			assert.equal(fs.existsSync(path.join(resultsDir, "kept.json")), true);
@@ -498,4 +498,4 @@ describe("result file indexes", () => {
 			fs.rmSync(resultsDir, { recursive: true, force: true });
 		}
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/retained-nested-route-tracker.test.ts

@@ -0,0 +1,175 @@
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { afterEach, describe, it } from "node:test";
+import { retainLiveForegroundNestedRoute } from "../../src/integrations/pi-web-session-liveness.ts";
+import { createRetainedNestedRouteTracker } from "../../src/runs/background/retained-nested-route-tracker.ts";
+import { createNestedRoute, writeNestedEvent } from "../../src/runs/shared/nested-events.ts";
+import type { SubagentState } from "../../src/shared/types.ts";
+
+const routeRoots: string[] = [];
+
+class Watcher extends EventEmitter implements fs.FSWatcher {
+	close() { this.emit("close"); }
+	ref() { return this; }
+	unref() { return this; }
+}
+
+function route(rootRunId: string) {
+	const value = createNestedRoute(rootRunId);
+	routeRoots.push(path.dirname(value.eventSink));
+	return value;
+}
+
+function writeState(value: ReturnType<typeof route>, state: "running" | "complete", ts: number): void {
+	writeNestedEvent(value, {
+		type: state === "running" ? "subagent.nested.updated" : "subagent.nested.completed",
+		ts,
+		parentRunId: value.rootRunId,
+		child: {
+			id: "nested-child",
+			parentRunId: value.rootRunId,
+			depth: 1,
+			path: [{ runId: value.rootRunId }],
+			state,
+			agent: "worker",
+			lastUpdate: ts,
+		},
+	});
+}
+
+async function waitFor(check: () => boolean, timeoutMs = 1000): Promise<void> {
+	const deadline = Date.now() + timeoutMs;
+	while (!check() && Date.now() < deadline) await new Promise((resolve) => setTimeout(resolve, 5));
+	assert.equal(check(), true, "condition did not become true before timeout");
+}
+
+afterEach(() => {
+	for (const root of routeRoots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe("retained foreground nested route tracker", () => {
+	it("releases retained liveness after the nested descendant completes", async () => {
+		const state: Pick<SubagentState, "retainedForegroundNestedRoutes"> = {};
+		const nestedRoute = route("retained-root");
+		writeState(nestedRoute, "running", 100);
+		assert.equal(retainLiveForegroundNestedRoute(state, nestedRoute), true);
+
+		const tracker = createRetainedNestedRouteTracker(state, { platform: "win32", pollIntervalMs: 10 });
+		try {
+			tracker.track(nestedRoute.rootRunId);
+			writeState(nestedRoute, "complete", 200);
+			await waitFor(() => !state.retainedForegroundNestedRoutes?.has(nestedRoute.rootRunId));
+		} finally {
+			tracker.clear();
+		}
+	});
+
+	it("keeps the route through the handoff race until the first tracker refresh", async () => {
+		const state: Pick<SubagentState, "retainedForegroundNestedRoutes"> = {};
+		const nestedRoute = route("handoff-root");
+		writeState(nestedRoute, "running", 100);
+		assert.equal(retainLiveForegroundNestedRoute(state, nestedRoute), true);
+		writeState(nestedRoute, "complete", 200);
+
+		const tracker = createRetainedNestedRouteTracker(state, { platform: "win32", pollIntervalMs: 60_000 });
+		try {
+			tracker.track(nestedRoute.rootRunId);
+			assert.equal(state.retainedForegroundNestedRoutes?.has(nestedRoute.rootRunId), true);
+			await waitFor(() => !state.retainedForegroundNestedRoutes?.has(nestedRoute.rootRunId));
+		} finally {
+			tracker.clear();
+		}
+	});
+
+	it("keeps polling after a native watcher error", async () => {
+		const state: Pick<SubagentState, "retainedForegroundNestedRoutes"> = {};
+		const nestedRoute = route("watch-error-root");
+		writeState(nestedRoute, "running", 100);
+		assert.equal(retainLiveForegroundNestedRoute(state, nestedRoute), true);
+
+		const watcher = new Watcher();
+		const tracker = createRetainedNestedRouteTracker(state, {
+			platform: "linux",
+			pollIntervalMs: 10,
+			watch: () => watcher,
+		});
+		try {
+			tracker.track(nestedRoute.rootRunId);
+			watcher.emit("error", new Error("watch failed"));
+			writeState(nestedRoute, "complete", 200);
+			await waitFor(() => !state.retainedForegroundNestedRoutes?.has(nestedRoute.rootRunId));
+		} finally {
+			tracker.clear();
+		}
+	});
+
+	it("refreshes every retained route instead of stopping at the first live one", async () => {
+		const state: Pick<SubagentState, "retainedForegroundNestedRoutes"> = {};
+		const liveRoute = route("multi-live-root");
+		const terminalRoute = route("multi-terminal-root");
+		writeState(liveRoute, "running", 100);
+		writeState(terminalRoute, "running", 100);
+		assert.equal(retainLiveForegroundNestedRoute(state, liveRoute), true);
+		assert.equal(retainLiveForegroundNestedRoute(state, terminalRoute), true);
+
+		const tracker = createRetainedNestedRouteTracker(state, { platform: "win32", pollIntervalMs: 10 });
+		try {
+			tracker.track(liveRoute.rootRunId);
+			tracker.track(terminalRoute.rootRunId);
+			writeState(terminalRoute, "complete", 200);
+			await waitFor(() => !state.retainedForegroundNestedRoutes?.has(terminalRoute.rootRunId));
+			assert.equal(state.retainedForegroundNestedRoutes?.has(liveRoute.rootRunId), true);
+		} finally {
+			tracker.clear();
+		}
+	});
+
+	it("refreshes promptly from native watch events", (t) => {
+		t.mock.timers.enable({ apis: ["setTimeout"] });
+		const state: Pick<SubagentState, "retainedForegroundNestedRoutes"> = {};
+		const nestedRoute = route("watched-root");
+		writeState(nestedRoute, "running", 100);
+		assert.equal(retainLiveForegroundNestedRoute(state, nestedRoute), true);
+
+		let notify: (() => void) | undefined;
+		let closed = 0;
+		const watcher = new Watcher();
+		watcher.on("close", () => { closed += 1; });
+		const tracker = createRetainedNestedRouteTracker(state, {
+			platform: "linux",
+			pollIntervalMs: 60_000,
+			// SAFETY: the tracker uses only fs.watch(path, listener), not the options overloads.
+			watch: ((_path: fs.PathLike, listener: fs.WatchListener<string>) => {
+				notify = () => listener("rename", "event.json");
+				return watcher;
+			}) as typeof fs.watch,
+		});
+		try {
+			tracker.track(nestedRoute.rootRunId);
+			t.mock.timers.tick(25);
+			assert.equal(state.retainedForegroundNestedRoutes?.has(nestedRoute.rootRunId), true);
+			writeState(nestedRoute, "complete", 200);
+			notify?.();
+			t.mock.timers.tick(25);
+			assert.equal(state.retainedForegroundNestedRoutes?.has(nestedRoute.rootRunId), false);
+			assert.equal(closed, 1);
+		} finally {
+			tracker.clear();
+		}
+	});
+
+	it("clears every retained route during session teardown", () => {
+		const state: Pick<SubagentState, "retainedForegroundNestedRoutes"> = {};
+		const nestedRoute = route("cleared-root");
+		writeState(nestedRoute, "running", 100);
+		assert.equal(retainLiveForegroundNestedRoute(state, nestedRoute), true);
+
+		const tracker = createRetainedNestedRouteTracker(state, { platform: "win32", pollIntervalMs: 60_000 });
+		tracker.track(nestedRoute.rootRunId);
+		tracker.clear();
+
+		assert.equal(state.retainedForegroundNestedRoutes?.size, 0);
+	});
+});

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

@@ -4,7 +4,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { describe, it } from "node:test";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
-import { consumeStopRequestPayload, stopRequestPath } from "../../src/runs/background/control-channel.ts";
+import { consumeStopRequestPayload, stopRequestPath, stopRequestsDir } from "../../src/runs/background/control-channel.ts";
 import {
 	SUBAGENT_RPC_PROTOCOL_VERSION,
 	SUBAGENT_RPC_READY_EVENT,
@@ -957,10 +957,17 @@ describe("subagent extension RPC bridge", () => {
 				state: "running",
 				startedAt: 100,
 				lastUpdate: 100,
-				steps: [{ agent: "worker", status: "running", workflowKey: "slow", startedAt: 100 }],
+				steps: [
+					{ agent: "worker", status: "running", childId: "child-slow", workflowKey: "slow", startedAt: 100 },
+					{ agent: "worker", status: "completed", workflowKey: "done", startedAt: 100, endedAt: 120 },
+				],
 			}, null, 2), "utf-8");
 			const controller = new AbortController();
-			const state = { workflowControllers: new Map([["workflow-run-stop", controller]]) } as SubagentState;
+			const calls: Array<{ childId: string; message?: string }> = [];
+			const state = {
+				workflowControllers: new Map([["workflow-run-stop", controller]]),
+				workflowChildStops: new Map([["workflow-run-stop", (childId: string, message?: string) => { calls.push({ childId, message }); return true; }]]),
+			} as SubagentState;
 			const bridge = registerSubagentRpcBridge({
 				events,
 				getContext: () => ctx(),
@@ -976,6 +983,7 @@ describe("subagent extension RPC bridge", () => {
 			assert.equal((reply as { data: { runId?: string; state?: string; childId?: string } }).data.runId, "workflow-run-stop");
 			assert.equal((reply as { data: { state?: string } }).data.state, "stopping");
 			assert.equal((reply as { data: { childId?: string } }).data.childId, undefined);
+			assert.deepEqual(calls, [{ childId: "child-slow", message: "Workflow stopped by RPC." }]);
 			assert.equal(controller.signal.aborted, true);
 			assert.equal(controller.signal.reason instanceof Error ? controller.signal.reason.message : String(controller.signal.reason), "Workflow stopped by RPC.");
 			assert.equal(fs.existsSync(stopRequestPath(asyncDir)), false);
@@ -1029,7 +1037,7 @@ describe("subagent extension RPC bridge", () => {
 		}
 	});
 
-	it("stops reload-recovered workflows through the durable control channel", async () => {
+	for (const scenario of ["no-state", "empty-maps", "child-no-state", "child-controller-only", "child-callback-false", "run-callback-only"] as const) it(`rejects workflow stop without the required live control: ${scenario}`, async () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-rpc-stop-workflow-"));
 		try {
 			const events = new FakeEvents();
@@ -1037,6 +1045,14 @@ describe("subagent extension RPC bridge", () => {
 			const resultsDir = path.join(root, "results");
 			const asyncDir = path.join(asyncRoot, "workflow-run");
 			let killCalls = 0;
+			const controller = new AbortController();
+			const calls: string[] = [];
+			const stopChild = (childId: string) => { calls.push(childId); return false; };
+			const childId = scenario.startsWith("child-") ? "worker" : undefined;
+			const state = scenario === "no-state" || scenario === "child-no-state" ? undefined : {
+				workflowControllers: new Map(scenario === "child-controller-only" || scenario === "child-callback-false" ? [["workflow-run", controller]] : []),
+				workflowChildStops: new Map(scenario === "child-callback-false" || scenario === "run-callback-only" ? [["workflow-run", stopChild]] : []),
+			} as SubagentState;
 			fs.mkdirSync(asyncDir, { recursive: true });
 			fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({
 				runId: "workflow-run",
@@ -1046,10 +1062,15 @@ describe("subagent extension RPC bridge", () => {
 				pid: 4242,
 				startedAt: 100,
 				lastUpdate: 100,
-				steps: [{ agent: "worker", status: "running", startedAt: 100 }],
+				steps: [
+					{ workflowKey: "worker", agent: "worker", status: "running", startedAt: 100 },
+					{ workflowKey: "sibling", agent: "worker", status: "running", startedAt: 100 },
+				],
 			}, null, 2), "utf-8");
+			const statusBefore = fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8");
 			const bridge = registerSubagentRpcBridge({
 				events,
+				state,
 				getContext: () => ctx(),
 				execute: async () => assert.fail("stop should not call executor"),
 				asyncDirRoot: asyncRoot,
@@ -1061,13 +1082,18 @@ describe("subagent extension RPC bridge", () => {
 				now: () => 150,
 			});
 
-			const reply = await request(events, "stop-workflow", "stop", { id: "workflow-run" });
+			const reply = await request(events, "stop-workflow", "stop", { id: "workflow-run", ...(childId ? { childId } : {}) });
 
-			assert.equal(reply.success, true);
-			assert.equal((reply as { data: { runId?: string; state?: string; message?: string } }).data.runId, "workflow-run");
-			assert.equal((reply as { data: { state?: string } }).data.state, "stopping");
-			assert.match((reply as { data: { message?: string } }).data.message ?? "", /Stop requested for async run workflow-run/);
-			assert.equal(consumeStopRequestPayload(asyncDir)?.type, "stop");
+			assert.equal(reply.success, false);
+			assert.equal((reply as { error: { code: string } }).error.code, "invalid_state");
+			assert.match((reply as { error: { message: string } }).error.message,
+				scenario === "child-callback-false" ? /not available to stop/ : childId ? /no live stop callback/ : /no live run controller/);
+			assert.equal(fs.existsSync(stopRequestPath(asyncDir)), false);
+			assert.equal(fs.existsSync(stopRequestsDir(asyncDir)), false);
+			assert.equal(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8"), statusBefore);
+			assert.equal(events.emitted.some(({ event }) => event === SUBAGENT_CHILD_STATUS_EVENT), false);
+			assert.equal(controller.signal.aborted, false);
+			assert.deepEqual(calls, scenario === "child-callback-false" ? ["worker"] : []);
 			assert.equal(killCalls, 0);
 
 			bridge.dispose();
@@ -1121,4 +1147,4 @@ describe("subagent extension RPC bridge", () => {
 			fs.rmSync(root, { recursive: true, force: true });
 		}
 	});
-});
+});

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

@@ -8,8 +8,6 @@ import {
 	claimRunFanoutBatch,
 	claimRunFanoutBatchWithCommit,
 	createRunFanoutBudget,
-	decodeRunFanoutBudgetDescriptor,
-	encodeRunFanoutBudgetDescriptor,
 	getRunFanoutBudgetSnapshot,
 	RunFanoutLimitError,
 	validateRunFanoutBudgetDescriptor,
@@ -120,8 +118,7 @@ describe("run fan-out budget", () => {
 	it("persists claims and rejects the responsible next path at the exact cap", () => {
 		const descriptor = budget(2);
 		assert.deepEqual(claimRunFanoutBatch(descriptor, ["tasks[0]", "tasks[1]"]), { used: 2, limit: 2, remaining: 0 });
-		const restored = decodeRunFanoutBudgetDescriptor(encodeRunFanoutBudgetDescriptor(descriptor));
-		assert.deepEqual(getRunFanoutBudgetSnapshot(restored!), { used: 2, limit: 2, remaining: 0 });
+		assert.deepEqual(getRunFanoutBudgetSnapshot(descriptor), { used: 2, limit: 2, remaining: 0 });
 		assert.throws(() => claimRunFanoutBatch(descriptor, ["tasks[2]"]), (error: unknown) => {
 			assert.ok(error instanceof RunFanoutLimitError);
 			assert.equal(error.rejection.path, "tasks[2]");
@@ -188,4 +185,4 @@ describe("run fan-out budget", () => {
 		directories.push(linked);
 		assert.throws(() => validateRunFanoutBudgetDescriptor({ ...descriptor, directory: linked }), /resolves outside/);
 	});
-});
+});