@selesai/code 0.8.4 → 0.8.6

package/dist/extensions/pi-subagents/test/unit/active-async-capacity.test.ts

@@ -0,0 +1,317 @@
+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 {
+	acquireActiveAsyncCapacity,
+	ActiveAsyncCapacityError,
+	getActiveAsyncCapacitySnapshot,
+	transferActiveAsyncCapacity,
+} from "../../src/runs/background/active-async-capacity.ts";
+
+function tempRoot(): string {
+	return fs.mkdtempSync(path.join(os.tmpdir(), "active-async-capacity-"));
+}
+
+function writeJson(filePath: string, value: unknown): void {
+	fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	fs.writeFileSync(filePath, JSON.stringify(value));
+}
+
+function observedProof(runId: string, runnerProcessInstanceId: string) {
+	return {
+		version: 1,
+		state: "observed",
+		runId,
+		runnerProcessInstanceId,
+		observedAt: 300,
+		instances: [{
+			kind: "runner",
+			processInstanceId: runnerProcessInstanceId,
+			closeObservedAt: 300,
+			exitCode: 0,
+			signal: null,
+		}],
+	};
+}
+
+describe("active async capacity", () => {
+	it("admits exactly to the limit and rolls back only its own unstarted slot", () => {
+		const rootDir = tempRoot();
+		try {
+			const first = acquireActiveAsyncCapacity({ sessionId: "session-a", limit: 1, runId: "run-a", kind: "runner", asyncDir: path.join(rootDir, "run-a") }, { rootDir, token: () => "token-a" });
+			assert.ok(first);
+			assert.deepEqual(getActiveAsyncCapacitySnapshot("session-a", 1, { rootDir }), { used: 1, limit: 1 });
+			assert.throws(
+				() => acquireActiveAsyncCapacity({ sessionId: "session-a", limit: 1, runId: "run-b", kind: "runner", asyncDir: path.join(rootDir, "run-b") }, { rootDir, token: () => "token-b" }),
+				(error: unknown) => error instanceof ActiveAsyncCapacityError && error.message === "Active async run capacity exhausted: 1/1 used.",
+			);
+			assert.equal(first.rollback(), true);
+			assert.deepEqual(getActiveAsyncCapacitySnapshot("session-a", 1, { rootDir }), { used: 0, limit: 1 });
+		} finally {
+			fs.rmSync(rootDir, { recursive: true, force: true });
+		}
+	});
+
+	it("counts corrupt slot metadata as occupied", () => {
+		const rootDir = tempRoot();
+		try {
+			// Create a valid occupied slot, then corrupt only its owner metadata.
+			const handle = acquireActiveAsyncCapacity({ sessionId: "session-corrupt", limit: 1, runId: "run-a", kind: "runner", asyncDir: path.join(rootDir, "run-a") }, { rootDir });
+			assert.ok(handle);
+			fs.writeFileSync(path.join(rootDir, handle.owner.ownerSessionKey, "slot-0", "owner.json"), "not json");
+			assert.deepEqual(getActiveAsyncCapacitySnapshot("session-corrupt", 1, { rootDir }), { used: 1, limit: 1 });
+			assert.throws(() => acquireActiveAsyncCapacity({ sessionId: "session-corrupt", limit: 1, runId: "run-b", kind: "runner", asyncDir: path.join(rootDir, "run-b") }, { rootDir }), ActiveAsyncCapacityError);
+		} finally {
+			fs.rmSync(rootDir, { recursive: true, force: true });
+		}
+	});
+
+	it("uses the injected clock for reservation and start timestamps", () => {
+		const rootDir = tempRoot();
+		let now = 100;
+		try {
+			const runner = acquireActiveAsyncCapacity({ sessionId: "session-clock", limit: 2, runId: "runner", kind: "runner", asyncDir: path.join(rootDir, "runner") }, { rootDir, now: () => now });
+			assert.ok(runner);
+			assert.equal(runner.owner.reservedAt, 100);
+			now = 200;
+			runner.markStarted("runner-process");
+			assert.equal(runner.owner.runnerStartedAt, 200);
+
+			now = 300;
+			const workflow = acquireActiveAsyncCapacity({ sessionId: "session-clock", limit: 2, runId: "workflow", kind: "workflow", asyncDir: path.join(rootDir, "workflow") }, { rootDir, now: () => now });
+			assert.ok(workflow);
+			workflow.markWorkflowStarted();
+			assert.equal(workflow.owner.runnerStartedAt, 300);
+		} finally {
+			fs.rmSync(rootDir, { recursive: true, force: true });
+		}
+	});
+
+	it("does not roll back when runner start was recorded only in memory", () => {
+		const rootDir = tempRoot();
+		try {
+			const handle = acquireActiveAsyncCapacity({ sessionId: "session-a", limit: 1, runId: "run-a", kind: "runner", asyncDir: path.join(rootDir, "runs", "run-a") }, { rootDir });
+			assert.ok(handle);
+			handle.owner.runnerProcessInstanceId = "runner-a";
+			handle.owner.runnerStartedAt = Date.now();
+
+			assert.equal(handle.rollback(), false);
+			assert.deepEqual(getActiveAsyncCapacitySnapshot("session-a", 1, { rootDir }), { used: 1, limit: 1 });
+		} finally {
+			fs.rmSync(rootDir, { recursive: true, force: true });
+		}
+	});
+
+	it("retains active and unknown runner proof, then releases matching observed proof", () => {
+		const rootDir = tempRoot();
+		const asyncDir = path.join(rootDir, "runs", "run-a");
+		try {
+			const handle = acquireActiveAsyncCapacity({ sessionId: "session-a", limit: 2, runId: "run-a", kind: "runner", asyncDir }, { rootDir });
+			assert.ok(handle);
+			handle.markStarted("runner-a");
+			writeJson(path.join(asyncDir, "status.json"), { runId: "run-a", sessionId: "session-a", mode: "single", state: "running", startedAt: 100, processTerminal: { version: 1, state: "pending", runId: "run-a", runnerProcessInstanceId: "runner-a" } });
+			assert.deepEqual(getActiveAsyncCapacitySnapshot("session-a", 2, { rootDir }), { used: 1, limit: 2 });
+			writeJson(path.join(asyncDir, "status.json"), { runId: "run-a", sessionId: "session-a", mode: "single", state: "complete", startedAt: 100, processTerminal: { version: 1, state: "unknown", runId: "run-a", runnerProcessInstanceId: "runner-a", reason: "process-tree-unverified" } });
+			writeJson(path.join(asyncDir, "process-terminal.json"), { version: 1, state: "unknown", runId: "run-a", runnerProcessInstanceId: "runner-a", reason: "process-tree-unverified" });
+			assert.deepEqual(getActiveAsyncCapacitySnapshot("session-a", 2, { rootDir }), { used: 1, limit: 2 });
+			writeJson(path.join(asyncDir, "process-terminal.json"), observedProof("run-a", "runner-a"));
+			assert.deepEqual(getActiveAsyncCapacitySnapshot("session-a", 2, { rootDir }), { used: 0, limit: 2 });
+		} finally {
+			fs.rmSync(rootDir, { recursive: true, force: true });
+		}
+	});
+
+	it("does not delete a slot recreated while a terminal owner is released", () => {
+		const rootDir = tempRoot();
+		const asyncDir = path.join(rootDir, "runs", "run-a");
+		try {
+			const handle = acquireActiveAsyncCapacity({ sessionId: "session-a", limit: 1, runId: "run-a", kind: "runner", asyncDir }, { rootDir, token: () => "token-a" });
+			assert.ok(handle);
+			handle.markStarted("runner-a");
+			writeJson(path.join(asyncDir, "status.json"), { runId: "run-a", sessionId: "session-a", mode: "single", state: "complete", startedAt: 100 });
+			writeJson(path.join(asyncDir, "process-terminal.json"), observedProof("run-a", "runner-a"));
+
+			let replacement: ReturnType<typeof acquireActiveAsyncCapacity>;
+			assert.deepEqual(getActiveAsyncCapacitySnapshot("session-a", 1, {
+				rootDir,
+				afterSlotRename: () => {
+					replacement = acquireActiveAsyncCapacity({ sessionId: "session-a", limit: 1, runId: "run-b", kind: "runner", asyncDir: path.join(rootDir, "runs", "run-b") }, { rootDir, token: () => "token-b" });
+				},
+			}), { used: 1, limit: 1 });
+			assert.equal(replacement!.owner.runId, "run-b");
+			assert.deepEqual(getActiveAsyncCapacitySnapshot("session-a", 1, { rootDir }), { used: 1, limit: 1 });
+		} finally {
+			fs.rmSync(rootDir, { recursive: true, force: true });
+		}
+	});
+
+	it("does not delete a slot recreated during pre-start rollback", () => {
+		const rootDir = tempRoot();
+		try {
+			const first = acquireActiveAsyncCapacity({ sessionId: "session-a", limit: 1, runId: "run-a", kind: "runner", asyncDir: path.join(rootDir, "runs", "run-a") }, {
+				rootDir,
+				token: () => "token-a",
+				afterSlotRename: () => {
+					const replacement = acquireActiveAsyncCapacity({ sessionId: "session-a", limit: 1, runId: "run-b", kind: "runner", asyncDir: path.join(rootDir, "runs", "run-b") }, { rootDir, token: () => "token-b" });
+					assert.ok(replacement);
+				},
+			});
+			assert.ok(first);
+			assert.equal(first.rollback(), true);
+			assert.deepEqual(getActiveAsyncCapacitySnapshot("session-a", 1, { rootDir }), { used: 1, limit: 1 });
+			assert.equal(first.rollback(), false);
+		} finally {
+			fs.rmSync(rootDir, { recursive: true, force: true });
+		}
+	});
+
+	it("releases a transferred failure that never started", () => {
+		const rootDir = tempRoot();
+		const sourceDir = path.join(rootDir, "runs", "source");
+		const failedDir = path.join(rootDir, "runs", "failed-revival");
+		try {
+			const source = acquireActiveAsyncCapacity({ sessionId: "session-a", limit: 1, runId: "source", kind: "runner", asyncDir: sourceDir }, { rootDir });
+			assert.ok(source);
+			source.markStarted("source-runner");
+			writeJson(path.join(sourceDir, "status.json"), { runId: "source", sessionId: "session-a", mode: "single", state: "paused", startedAt: 100 });
+			const transferred = transferActiveAsyncCapacity({ sessionId: "session-a", limit: 1, sourceRunId: "source", runId: "failed-revival", asyncDir: failedDir }, { rootDir });
+			assert.ok(transferred);
+			transferred.markStarted("failed-runner");
+			writeJson(path.join(failedDir, "status.json"), { runId: "failed-revival", sessionId: "session-a", mode: "single", state: "failed", startedAt: 200, error: "Failed before startup proceed", processTerminal: { version: 1, state: "not-started", runId: "failed-revival", runnerProcessInstanceId: "failed-runner" } });
+
+			assert.deepEqual(getActiveAsyncCapacitySnapshot("session-a", 1, { rootDir }), { used: 0, limit: 1 });
+		} finally {
+			fs.rmSync(rootDir, { recursive: true, force: true });
+		}
+	});
+
+	it("does not restore old source proof after a transferred runner starts", () => {
+		const rootDir = tempRoot();
+		const sourceDir = path.join(rootDir, "runs", "source");
+		const revivedDir = path.join(rootDir, "runs", "revived");
+		try {
+			const source = acquireActiveAsyncCapacity({ sessionId: "session-a", limit: 1, runId: "source", kind: "runner", asyncDir: sourceDir }, { rootDir });
+			assert.ok(source);
+			source.markStarted("source-runner");
+			writeJson(path.join(sourceDir, "status.json"), { runId: "source", sessionId: "session-a", mode: "single", state: "complete", startedAt: 100 });
+			writeJson(path.join(sourceDir, "process-terminal.json"), observedProof("source", "source-runner"));
+			const transferred = transferActiveAsyncCapacity({ sessionId: "session-a", limit: 1, sourceRunId: "source", runId: "revived", asyncDir: revivedDir }, { rootDir });
+			assert.ok(transferred);
+			writeJson(path.join(revivedDir, "status.json"), { runId: "revived", sessionId: "session-a", mode: "single", state: "failed", startedAt: 200, processTerminal: { version: 1, state: "not-started", runId: "revived", runnerProcessInstanceId: "revived-runner" } });
+			transferred.markStarted("revived-runner");
+			assert.equal(transferred.rollback(), false);
+
+			assert.deepEqual(getActiveAsyncCapacitySnapshot("session-a", 1, { rootDir }), { used: 1, limit: 1 });
+			writeJson(path.join(revivedDir, "process-terminal.json"), observedProof("revived", "revived-runner"));
+			assert.deepEqual(getActiveAsyncCapacitySnapshot("session-a", 1, { rootDir }), { used: 0, limit: 1 });
+		} finally {
+			fs.rmSync(rootDir, { recursive: true, force: true });
+		}
+	});
+
+	it("transfers a paused reservation without changing usage", () => {
+		const rootDir = tempRoot();
+		const sourceDir = path.join(rootDir, "runs", "source");
+		try {
+			const source = acquireActiveAsyncCapacity({ sessionId: "session-a", limit: 1, runId: "source", kind: "runner", asyncDir: sourceDir }, { rootDir });
+			assert.ok(source);
+			source.markStarted("runner-source");
+			writeJson(path.join(sourceDir, "status.json"), { runId: "source", sessionId: "session-a", mode: "single", state: "paused", startedAt: 100 });
+			const next = transferActiveAsyncCapacity({ sessionId: "session-a", limit: 1, sourceRunId: "source", runId: "next", asyncDir: path.join(rootDir, "runs", "next") }, { rootDir });
+			assert.ok(next);
+			assert.equal(next.owner.sourceRunId, "source");
+			assert.equal(next.owner.generation, 1);
+			assert.deepEqual(getActiveAsyncCapacitySnapshot("session-a", 1, { rootDir }), { used: 1, limit: 1 });
+		} finally {
+			fs.rmSync(rootDir, { recursive: true, force: true });
+		}
+	});
+
+	it("transfers an existing reservation after the cap is disabled", () => {
+		const rootDir = tempRoot();
+		const sourceDir = path.join(rootDir, "runs", "source");
+		try {
+			const source = acquireActiveAsyncCapacity({ sessionId: "session-a", limit: 1, runId: "source", kind: "runner", asyncDir: sourceDir }, { rootDir });
+			assert.ok(source);
+			source.markStarted("runner-source");
+			writeJson(path.join(sourceDir, "status.json"), { runId: "source", sessionId: "session-a", mode: "single", state: "paused", startedAt: 100 });
+			const next = transferActiveAsyncCapacity({ sessionId: "session-a", limit: undefined, sourceRunId: "source", runId: "next", asyncDir: path.join(rootDir, "runs", "next") }, { rootDir });
+			assert.ok(next);
+			assert.equal(next.owner.runId, "next");
+			assert.deepEqual(getActiveAsyncCapacitySnapshot("session-a", undefined, { rootDir }), { used: 1, limit: 0 });
+		} finally {
+			fs.rmSync(rootDir, { recursive: true, force: true });
+		}
+	});
+
+	it("releases terminal workflows only after the controller is gone and async children have observed proof", () => {
+		const rootDir = tempRoot();
+		const asyncRoot = path.join(rootDir, "runs");
+		const workflowDir = path.join(asyncRoot, "workflow");
+		const childDir = path.join(asyncRoot, "child");
+		try {
+			const workflow = acquireActiveAsyncCapacity({ sessionId: "session-a", limit: 1, runId: "workflow", kind: "workflow", asyncDir: workflowDir }, { rootDir });
+			assert.ok(workflow);
+			workflow.markWorkflowStarted();
+			writeJson(path.join(workflowDir, "status.json"), { runId: "workflow", sessionId: "session-a", mode: "workflow", state: "complete", startedAt: 100, steps: [{ agent: "worker", workflowKey: "foreground", async: false, status: "completed" }] });
+			assert.deepEqual(getActiveAsyncCapacitySnapshot("session-a", 1, { rootDir, liveWorkflowRunIds: new Set(["workflow"]) }), { used: 1, limit: 1 });
+			assert.deepEqual(getActiveAsyncCapacitySnapshot("session-a", 1, { rootDir }), { used: 0, limit: 1 });
+
+			const second = acquireActiveAsyncCapacity({ sessionId: "session-a", limit: 1, runId: "workflow-2", kind: "workflow", asyncDir: workflowDir }, { rootDir });
+			assert.ok(second);
+			second.markWorkflowStarted();
+			writeJson(path.join(workflowDir, "status.json"), { runId: "workflow-2", sessionId: "session-a", mode: "workflow", state: "complete", startedAt: 100, steps: [{ agent: "worker", workflowKey: "async", runId: "child", async: true, status: "completed" }] });
+			writeJson(path.join(childDir, "status.json"), { runId: "child", sessionId: "session-a", mode: "single", state: "complete", startedAt: 100, processTerminal: { version: 1, state: "unknown", runId: "child", runnerProcessInstanceId: "runner-child", reason: "process-tree-unverified" } });
+			writeJson(path.join(childDir, "process-terminal.json"), { version: 1, state: "unknown", runId: "child", runnerProcessInstanceId: "runner-child", reason: "process-tree-unverified" });
+			assert.deepEqual(getActiveAsyncCapacitySnapshot("session-a", 1, { rootDir }), { used: 1, limit: 1 });
+			writeJson(path.join(childDir, "process-terminal.json"), observedProof("child", "runner-child"));
+			assert.deepEqual(getActiveAsyncCapacitySnapshot("session-a", 1, { rootDir }), { used: 0, limit: 1 });
+		} finally {
+			fs.rmSync(rootDir, { recursive: true, force: true });
+		}
+	});
+
+	it("retains terminal workflows while a resumed async child lacks observed proof", () => {
+		const rootDir = tempRoot();
+		const asyncRoot = path.join(rootDir, "runs");
+		const workflowDir = path.join(asyncRoot, "workflow");
+		const childDir = path.join(asyncRoot, "revived-child");
+		try {
+			const workflow = acquireActiveAsyncCapacity({ sessionId: "session-a", limit: 1, runId: "workflow", kind: "workflow", asyncDir: workflowDir }, { rootDir });
+			assert.ok(workflow);
+			workflow.markWorkflowStarted();
+			writeJson(path.join(workflowDir, "status.json"), { runId: "workflow", sessionId: "session-a", mode: "workflow", state: "failed", startedAt: 100, steps: [{ agent: "worker", workflowKey: "resume", runId: "revived-child", async: true, status: "failed" }] });
+			writeJson(path.join(childDir, "status.json"), { runId: "revived-child", sessionId: "session-a", mode: "single", state: "failed", startedAt: 100, processTerminal: { version: 1, state: "not-started", runId: "revived-child", runnerProcessInstanceId: "runner-child" } });
+
+			assert.deepEqual(getActiveAsyncCapacitySnapshot("session-a", 1, { rootDir }), { used: 1, limit: 1 });
+			writeJson(path.join(childDir, "process-terminal.json"), observedProof("revived-child", "runner-child"));
+			assert.deepEqual(getActiveAsyncCapacitySnapshot("session-a", 1, { rootDir }), { used: 0, limit: 1 });
+		} finally {
+			fs.rmSync(rootDir, { recursive: true, force: true });
+		}
+	});
+
+	it("releases terminal workflows when a child is marked failed before launch identity exists", () => {
+		const rootDir = tempRoot();
+		const workflowDir = path.join(rootDir, "runs", "workflow");
+		try {
+			const workflow = acquireActiveAsyncCapacity({ sessionId: "session-a", limit: 1, runId: "workflow", kind: "workflow", asyncDir: workflowDir }, { rootDir });
+			assert.ok(workflow);
+			workflow.markWorkflowStarted();
+			writeJson(path.join(workflowDir, "status.json"), {
+				runId: "workflow",
+				sessionId: "session-a",
+				mode: "workflow",
+				state: "failed",
+				startedAt: 100,
+				steps: [{ agent: "worker", workflowKey: "prep-failure", status: "failed", async: false, error: "gate cannot be combined with acceptance" }],
+			});
+
+			assert.deepEqual(getActiveAsyncCapacitySnapshot("session-a", 1, { rootDir }), { used: 0, limit: 1 });
+		} finally {
+			fs.rmSync(rootDir, { recursive: true, force: true });
+		}
+	});
+});

package/dist/extensions/pi-subagents/test/unit/agent-overrides.test.ts

@@ -80,8 +80,27 @@ describe("builtin agent overrides", () => {
 		assert.equal(scout?.modelSource?.type, "subagents.defaultModel");
 		assert.equal(scout?.modelSource?.scope, "user");
 		assert.equal(builtins.find((agent) => agent.name === "worker")?.model, "deepseek-v4-flash");
-		assert.equal(builtins.find((agent) => agent.name === "oracle")?.model, "deepseek-v4-pro");
-		assert.equal(builtins.find((agent) => agent.name === "reviewer")?.model, undefined);
+		const oracle = builtins.find((agent) => agent.name === "oracle");
+		assert.equal(oracle?.model, "deepseek-v4-pro");
+		assert.equal(oracle?.modelSource, undefined);
+		const reviewer = builtins.find((agent) => agent.name === "reviewer");
+		assert.equal(reviewer?.model, undefined);
+		assert.equal(reviewer?.modelSource, undefined);
+	});
+
+	it("clears subagents.defaultModel provenance for same-value agent model overrides", () => {
+		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
+			subagents: {
+				defaultModel: "deepseek-v4-flash",
+				agentOverrides: {
+					worker: { model: "deepseek-v4-flash" },
+				},
+			},
+		});
+
+		const worker = discoverAgentsAll(tempProject).builtin.find((agent) => agent.name === "worker");
+		assert.equal(worker?.model, "deepseek-v4-flash");
+		assert.equal(worker?.modelSource, undefined);
 	});
 
 	it("prefers project subagents.defaultModel over user defaultModel", () => {

package/dist/extensions/pi-subagents/test/unit/async-recovery-descriptor.test.ts

@@ -2,8 +2,21 @@ 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 { afterEach, describe, it } from "node:test";
 import { readAsyncRecoveryDescriptor } from "../../src/runs/background/async-resume.ts";
+import { createRunFanoutBudget } from "../../src/runs/shared/run-fanout-budget.ts";
+
+const budgetDirectories: string[] = [];
+
+function runFanoutBudget(runId: string) {
+	const descriptor = createRunFanoutBudget(runId, 64);
+	budgetDirectories.push(descriptor.directory);
+	return descriptor;
+}
+
+afterEach(() => {
+	for (const directory of budgetDirectories.splice(0)) fs.rmSync(directory, { recursive: true, force: true });
+});
 
 describe("async recovery descriptor", () => {
 	it("accepts launchContractDigest written by async execution", () => {
@@ -13,6 +26,7 @@ describe("async recovery descriptor", () => {
 			fs.writeFileSync(path.join(root, "recovery-descriptor.json"), JSON.stringify({
 				version: 1,
 				launchContractDigest: digest,
+				runFanoutBudget: runFanoutBudget("run-digest"),
 				sourceRunId: "run-digest",
 				agent: "worker",
 				cwd: root,
@@ -38,6 +52,7 @@ describe("async recovery descriptor", () => {
 			fs.writeFileSync(path.join(root, "recovery-descriptor.json"), JSON.stringify({
 				version: 1,
 				launchContractDigest: {},
+				runFanoutBudget: runFanoutBudget("run-bad-digest"),
 				sourceRunId: "run-digest",
 				agent: "worker",
 				cwd: root,

package/dist/extensions/pi-subagents/test/unit/async-resume.test.ts

@@ -4,6 +4,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { describe, it } from "node:test";
 import { buildRevivedAsyncTask, resolveAsyncResumeTarget } from "../../src/runs/background/async-resume.ts";
+import { createRunFanoutBudget } from "../../src/runs/shared/run-fanout-budget.ts";
 
 function writeJson(filePath: string, value: object): void {
 	fs.mkdirSync(path.dirname(filePath), { recursive: true });
@@ -97,7 +98,7 @@ describe("async resume lookup", () => {
 				steps: [{ agent: "worker", status: "paused", sessionFile }],
 			});
 			const descriptor = {
-				version: 1, sourceRunId: "run-descriptor", agent: "worker", cwd: root, systemPromptMode: "replace",
+				version: 1, runFanoutBudget: createRunFanoutBudget("run-descriptor", 64), sourceRunId: "run-descriptor", agent: "worker", cwd: root, systemPromptMode: "replace",
 				inheritProjectContext: false, inheritSkills: false, outputMode: "inline", maxSubagentDepth: 2, share: false,
 			};
 			writeJson(path.join(asyncDir, "recovery-descriptor.json"), { ...descriptor, token: "must-not-be-accepted" });
@@ -141,6 +142,7 @@ describe("async resume lookup", () => {
 			});
 			const descriptor = {
 				version: 1,
+				runFanoutBudget: createRunFanoutBudget("run-turn-budget", 64),
 				sourceRunId: "run-turn-budget",
 				agent: "worker",
 				cwd: root,
@@ -195,6 +197,7 @@ describe("async resume lookup", () => {
 			});
 			writeJson(path.join(asyncDir, "recovery-descriptor.json"), {
 				version: 1,
+				runFanoutBudget: createRunFanoutBudget("run-acceptance", 64),
 				sourceRunId: "run-acceptance",
 				agent: "worker",
 				cwd: root,
@@ -244,6 +247,7 @@ describe("async resume lookup", () => {
 			});
 			writeJson(path.join(asyncDir, "recovery-descriptor.json"), {
 				version: 1,
+				runFanoutBudget: createRunFanoutBudget("run-reviewed-acceptance", 64),
 				sourceRunId: "run-reviewed-acceptance",
 				agent: "worker",
 				cwd: root,
@@ -288,6 +292,7 @@ describe("async resume lookup", () => {
 			});
 			writeJson(path.join(asyncDir, "recovery-descriptor.json"), {
 				version: 1,
+				runFanoutBudget: createRunFanoutBudget("run-inferred-acceptance", 64),
 				sourceRunId: "run-inferred-acceptance",
 				agent: "worker",
 				cwd: root,

package/dist/extensions/pi-subagents/test/unit/chain-append.test.ts

@@ -12,6 +12,8 @@ import {
 } from "../../src/runs/background/chain-append.ts";
 import type { AsyncStatus } from "../../src/shared/types.ts";
 import type { RunnerStep } from "../../src/runs/shared/parallel-utils.ts";
+import { claimRunFanoutBatchWithCommit, createRunFanoutBudget, getRunFanoutBudgetSnapshot } from "../../src/runs/shared/run-fanout-budget.ts";
+import { PROMPT_REDACTED } from "../../src/shared/utils.ts";
 import { createTempDir, removeTempDir } from "../support/helpers.ts";
 
 function writeStatus(asyncDir: string, status: Partial<AsyncStatus> & Pick<AsyncStatus, "runId" | "mode" | "state" | "startedAt">): void {
@@ -71,6 +73,75 @@ describe("chain append requests", () => {
 		}
 	});
 
+	it("persists the request inside the admission callback", () => {
+		const root = createTempDir("pi-chain-append-admission-");
+		try {
+			const asyncDir = path.join(root, "run-admission");
+			writeStatus(asyncDir, {
+				runId: "run-admission",
+				mode: "chain",
+				state: "running",
+				startedAt: 100,
+				steps: [{ agent: "scout", status: "running" }],
+			});
+			let admitted = false;
+			const result = enqueueChainAppendRequest({
+				asyncDir,
+				runId: "run-admission",
+				steps: [runnerStep("worker")],
+				now: 200,
+				admit: (persist) => {
+					assert.equal(countPendingChainAppendRequests(asyncDir), 0);
+					persist();
+					admitted = true;
+				},
+			});
+
+			assert.equal(admitted, true);
+			assert.equal(result.pendingCount, 1);
+		} finally {
+			removeTempDir(root);
+		}
+	});
+
+	it("reports accepted appends and keeps admission claims when bookkeeping fails after persistence", () => {
+		const root = createTempDir("pi-chain-append-bookkeeping-");
+		const budget = createRunFanoutBudget("append-bookkeeping", 1);
+		try {
+			const asyncDir = path.join(root, "run-bookkeeping");
+			writeStatus(asyncDir, {
+				runId: "run-bookkeeping",
+				mode: "chain",
+				state: "running",
+				startedAt: 100,
+				steps: [{ agent: "scout", status: "running" }],
+			});
+			const statusPath = path.join(asyncDir, "status.json");
+			fs.mkdirSync(path.join(asyncDir, "events.jsonl"));
+
+			const result = enqueueChainAppendRequest({
+				asyncDir,
+				runId: "run-bookkeeping",
+				steps: [runnerStep("worker")],
+				now: 200,
+				admit: (persist) => claimRunFanoutBatchWithCommit(budget, ["chain[1]"], () => {
+					persist();
+					fs.rmSync(statusPath, { force: true });
+					fs.mkdirSync(statusPath);
+				}),
+			});
+
+			assert.equal(result.pendingCount, 1);
+			assert.match(result.bookkeepingError ?? "", /status update failed/);
+			assert.match(result.bookkeepingError ?? "", /event append failed/);
+			assert.equal(readPendingChainAppendRequests(asyncDir).length, 1);
+			assert.deepEqual(getRunFanoutBudgetSnapshot(budget), { used: 1, limit: 1, remaining: 0 });
+		} finally {
+			fs.rmSync(budget.directory, { recursive: true, force: true });
+			removeTempDir(root);
+		}
+	});
+
 	it("reads pending append requests without consuming them and reports reserved output names", () => {
 		const root = createTempDir("pi-chain-append-pending-");
 		try {
@@ -198,11 +269,11 @@ describe("chain append requests", () => {
 			"reviewer:pending",
 			"auditor:pending",
 		]);
-		// Appended steps must carry their own bounded task description for fleet display.
+		// Appended steps must not carry raw task text into durable status.
 		assert.deepEqual(status.steps?.slice(1).map((step) => step.description), [
-			"Use {previous}",
-			"Use {previous}",
-			"Use {previous}",
+			PROMPT_REDACTED,
+			PROMPT_REDACTED,
+			PROMPT_REDACTED,
 		]);
 		assert.deepEqual(status.parallelGroups, [{ start: 2, count: 2, stepIndex: 2 }]);
 		assert.equal(status.workflowGraph?.nodes[1]?.id, "step-1");

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

@@ -53,6 +53,24 @@ test("declared read-only builtin tools suppress implementation-word false positi
 	});
 });
 
+test("hyphenated fix adjectives in review tasks do not trigger the completion guard", () => {
+	const result = evaluateCompletionMutationGuard({
+		agent: "worker",
+		task: "Return a review with the top 2-3 must-fix items.",
+		messages: [assistantText("Review: findings with severity labels.")],
+	});
+
+	assert.deepEqual(result, {
+		expectedMutation: false,
+		attemptedMutation: false,
+		triggered: false,
+	});
+	assert.equal(
+		expectsImplementationMutation("worker", "Return a review with the top 2-3 must-fix items."),
+		false,
+	);
+});
+
 test("read-only issue drafting tasks do not trigger on suggested fix wording", () => {
 	const task = "Draft GitHub issue for pi-subagents bug from current conversation. Include title, environment/context, reproduction steps, actual/expected, logs excerpt, suspected cause, suggested fix. Terse but complete. No tools needed.";
 	const result = evaluateCompletionMutationGuard({

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

@@ -69,7 +69,7 @@ describe("buildDoctorReport", () => {
 
 			const report = buildDoctorReport({
 				cwd: root,
-				config: { defaultSessionDir: "~/subagent-sessions", intercomBridge: { mode: "always" }, maxSubagentSpawnsPerSession: 4 },
+				config: { defaultSessionDir: "~/subagent-sessions", intercomBridge: { mode: "always" }, maxSubagentSpawnsPerSession: 4, maxActiveAsyncRunsPerSession: 2 },
 				state,
 				currentSessionFile: path.join(root, "sessions", "parent.jsonl"),
 				currentSessionId: "session-abc123",
@@ -116,6 +116,10 @@ describe("buildDoctorReport", () => {
 			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, /missing or unknown cleanup proof retains capacity/);
 			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\)/);
@@ -125,6 +129,30 @@ describe("buildDoctorReport", () => {
 		}
 	});
 
+	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 {