@selesai/code 0.8.4 → 0.8.5

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

@@ -68,6 +68,7 @@ const originalEnv = {
 	[PI_INTERCOM_SESSION_ID_ENV]: process.env[PI_INTERCOM_SESSION_ID_ENV],
 	MCP_HASH_ROOT: process.env.MCP_HASH_ROOT,
 	MCP_HASH_TOKEN: process.env.MCP_HASH_TOKEN,
+	SELESAI_SUBAGENT_TASK_DELIVERY: process.env.SELESAI_SUBAGENT_TASK_DELIVERY,
 };
 const originalCwd = process.cwd();
 const tempRoots: string[] = [];
@@ -481,6 +482,88 @@ describe("buildPiArgs model wiring", () => {
 	});
 });
 
+describe("buildPiArgs task delivery", () => {
+	const longTask = "x".repeat(8001);
+
+	function taskFileFromArgs(args: string[]): string | undefined {
+		const ref = args.find((arg) => arg.startsWith("@") && arg.endsWith("task.md"));
+		return ref ? ref.slice(1) : undefined;
+	}
+
+	it("delivers short tasks inline by default", () => {
+		const { args } = buildPiArgs({
+			baseArgs: ["-p"],
+			task: "hello",
+			sessionEnabled: false,
+			inheritProjectContext: false,
+			inheritSkills: false,
+		});
+
+		assert.ok(args.includes("Task: hello"));
+		assert.equal(taskFileFromArgs(args), undefined);
+	});
+
+	it("delivers tasks over the argv limit via a temp file by default", () => {
+		const { args } = buildPiArgs({
+			baseArgs: ["-p"],
+			task: longTask,
+			sessionEnabled: false,
+			inheritProjectContext: false,
+			inheritSkills: false,
+		});
+
+		const taskFile = taskFileFromArgs(args);
+		assert.ok(taskFile, "expected an @task.md argv reference");
+		assert.equal(fs.readFileSync(taskFile, "utf-8"), `Task: ${longTask}`);
+		assert.ok(!args.includes(`Task: ${longTask}`));
+	});
+
+	it("delivers short tasks via file when SELESAI_SUBAGENT_TASK_DELIVERY=file", () => {
+		process.env.SELESAI_SUBAGENT_TASK_DELIVERY = "file";
+		const { args } = buildPiArgs({
+			baseArgs: ["-p"],
+			task: "hello",
+			sessionEnabled: false,
+			inheritProjectContext: false,
+			inheritSkills: false,
+		});
+
+		const taskFile = taskFileFromArgs(args);
+		assert.ok(taskFile, "expected an @task.md argv reference");
+		assert.equal(fs.readFileSync(taskFile, "utf-8"), "Task: hello");
+		assert.ok(!args.includes("Task: hello"));
+	});
+
+
+	it("falls back to auto when SELESAI_SUBAGENT_TASK_DELIVERY is invalid", () => {
+		process.env.SELESAI_SUBAGENT_TASK_DELIVERY = "carrier-pigeon";
+		const { args } = buildPiArgs({
+			baseArgs: ["-p"],
+			task: longTask,
+			sessionEnabled: false,
+			inheritProjectContext: false,
+			inheritSkills: false,
+		});
+
+		assert.ok(taskFileFromArgs(args), "expected file delivery for over-limit task");
+	});
+
+	it("lets the per-launch taskDelivery override beat the env setting", () => {
+		delete process.env.SELESAI_SUBAGENT_TASK_DELIVERY;
+		const { args } = buildPiArgs({
+			baseArgs: ["-p"],
+			task: "hello",
+			taskDelivery: "file",
+			sessionEnabled: false,
+			inheritProjectContext: false,
+			inheritSkills: false,
+		});
+
+		assert.ok(taskFileFromArgs(args), "expected an @task.md argv reference");
+		assert.ok(!args.includes("Task: hello"));
+	});
+});
+
 describe("buildPiArgs system prompt mode wiring", () => {
 	it("uses --append-system-prompt by default", () => {
 		const { args } = buildPiArgs({

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

@@ -182,14 +182,14 @@ Package skill content.
 	});
 
 	it("records private redacted run history and cleans session artifacts under the configured agent dir", () => {
-		const task = "Inspect customer ACME token=SECRET";
+		const task = "PROMPT_AUDIT_SENTINEL_1021 Inspect customer ACME token=SECRET";
 		recordRun("env-agent", task, 0, 42);
 		const historyPath = path.join(agentDir, "run-history.jsonl");
 		assert.equal(fs.existsSync(historyPath), true);
 		assertPrivateHistoryModes(historyPath);
 
 		const rawHistory = fs.readFileSync(historyPath, "utf-8");
-		assert.doesNotMatch(rawHistory, /Inspect customer|ACME|SECRET/);
+		assert.doesNotMatch(rawHistory, /PROMPT_AUDIT_SENTINEL_1021|Inspect customer|ACME|SECRET/);
 		assert.match(rawHistory, /"task":"\[redacted\]"/);
 		assert.match(rawHistory, /"taskHash":"[a-f0-9]{64}"/);
 

package/dist/extensions/pi-subagents/test/unit/process-terminal.test.ts

@@ -3,6 +3,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import test from "node:test";
+import { ACTIVE_RUN_INDEX_DIR, updateActiveRunIndex } from "../../src/runs/background/active-run-index.ts";
 import {
 	finalizeProcessTerminal,
 	processTerminalPath,
@@ -27,6 +28,7 @@ test("process-terminal proof requires the matching runner instance and writer cl
 					closeObservedAt: 10,
 					exitCode: 0,
 					signal: null,
+					processTree: { state: "observed", mechanism: "posix-process-group", processGroupId: 123, verifiedAt: 11 },
 				}],
 			},
 		});
@@ -82,6 +84,57 @@ test("process-terminal rejects missing writer close evidence", () => {
 	}
 });
 
+test("process-terminal fails closed when process-tree verification is unknown", () => {
+	const asyncDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-process-terminal-"));
+	try {
+		writeProcessTerminalCandidate(asyncDir, {
+			version: 1,
+			runId: "run-tree-unknown",
+			runnerProcessInstanceId: "runner-tree-unknown",
+			expectedWriters: { "0": 1 },
+			writers: {
+				"0": [{
+					processInstanceId: "writer-tree-unknown",
+					kind: "pi-writer",
+					attempt: 0,
+					closeObservedAt: 10,
+					exitCode: 1,
+					signal: "SIGKILL",
+					processTree: { state: "unknown", reason: "verification-failed", diagnostic: "still live" },
+				}],
+			},
+		});
+		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({ runId: "run-tree-unknown", state: "failed", lifecycleArtifactVersion: 3, steps: [{ agent: "worker", status: "failed" }] }));
+		fs.writeFileSync(path.join(asyncDir, "events.jsonl"), "");
+		updateActiveRunIndex(asyncDir, "running");
+		const markerPath = path.join(path.dirname(asyncDir), ACTIVE_RUN_INDEX_DIR, path.basename(asyncDir));
+		const proof = finalizeProcessTerminal(asyncDir, "run-tree-unknown", {
+			processInstanceId: "runner-tree-unknown",
+			closeObservedAt: 20,
+			exitCode: 1,
+			signal: null,
+		});
+		assert.equal(proof.state, "unknown");
+		assert.equal(proof.reason, "process-tree-unverified");
+		assert.equal(fs.existsSync(markerPath), true);
+		fs.rmSync(processTerminalPath(asyncDir), { force: true });
+		const candidatePath = path.join(asyncDir, "process-terminal-candidate.json");
+		const candidate = JSON.parse(fs.readFileSync(candidatePath, "utf-8"));
+		candidate.writers["0"][0].processTree = { state: "observed", mechanism: "posix-process-group", processGroupId: 126, verifiedAt: 21 };
+		fs.writeFileSync(candidatePath, JSON.stringify(candidate));
+		const observed = finalizeProcessTerminal(asyncDir, "run-tree-unknown", {
+			processInstanceId: "runner-tree-unknown",
+			closeObservedAt: 30,
+			exitCode: 1,
+			signal: null,
+		});
+		assert.equal(observed.state, "observed");
+		assert.equal(fs.existsSync(markerPath), false);
+	} finally {
+		fs.rmSync(asyncDir, { recursive: true, force: true });
+	}
+});
+
 test("malformed process-terminal sidecars project unknown instead of throwing", () => {
 	const asyncDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-process-terminal-"));
 	try {
@@ -112,7 +165,7 @@ test("process-terminal preserves stopped non-resumability and requires lease rel
 			runnerProcessInstanceId: "stopped-runner",
 			expectedWriters: { "0": 1 },
 			writers: {
-				"0": [{ processInstanceId: "stopped-writer", kind: "pi-writer", attempt: 0, closeObservedAt: 10, exitCode: 0, signal: null }],
+				"0": [{ processInstanceId: "stopped-writer", kind: "pi-writer", attempt: 0, closeObservedAt: 10, exitCode: 0, signal: null, processTree: { state: "observed", mechanism: "posix-process-group", processGroupId: 124, verifiedAt: 11 } }],
 			},
 			revivalLeaseToken: "lease-token",
 			revivalLeaseReleaseAcknowledged: false,
@@ -161,7 +214,7 @@ test("process-terminal rejects cross-run observed sidecars and inconsistent expe
 			runnerProcessInstanceId: "runner-1",
 			expectedWriters: { "0": 0 },
 			writers: {
-				"0": [{ processInstanceId: "unexpected-writer", kind: "pi-writer", attempt: 0, closeObservedAt: 10, exitCode: 0, signal: null }],
+				"0": [{ processInstanceId: "unexpected-writer", kind: "pi-writer", attempt: 0, closeObservedAt: 10, exitCode: 0, signal: null, processTree: { state: "observed", mechanism: "posix-process-group", processGroupId: 125, verifiedAt: 11 } }],
 			},
 		});
 		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({ runId: "actual-run", state: "complete", lifecycleArtifactVersion: 3, steps: [{ agent: "worker", status: "complete" }] }));

package/dist/extensions/pi-subagents/test/unit/public-execution.test.ts

@@ -19,7 +19,18 @@ describe("public subagent execution normalization", () => {
 		);
 	});
 
-	it("rejects malformed public execution shapes", () => {
+	it("rejects private run fan-out fields at the public boundary", () => {
+		for (const params of [
+			{ workflowScript: "return 1", runFanoutBudget: { version: 1 } },
+			{ workflowScript: "return 1", runFanoutAdmitted: true },
+		] as const) {
+			const result = normalizePublicSubagentExecution(params);
+			assert.equal(result.ok, false);
+			if (!result.ok) assert.match(result.error, /does not accept internal run fan-out fields/);
+		}
+	});
+
+	it("rejects removed public execution shapes", () => {
 		for (const params of [
 			{ action: " " },
 			{ action: "single" },

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

@@ -146,7 +146,7 @@ describe("subagent extension RPC bridge", () => {
 		assert.deepEqual(executedParams, { action: "status", id: "abc123" });
 		assert.equal((reply as { data: { text?: string } }).data.text, "Run: abc123");
 		assert.deepEqual((reply as { data: { fleet?: unknown } }).data.fleet, {
-			version: 1, entries: [], totalActive: 0, omitted: 0,
+			version: 1, entries: [], totalActive: 0, topLevelAsyncCapacity: { used: 0, limit: 0 }, omitted: 0,
 		});
 
 		bridge.dispose();
@@ -174,8 +174,9 @@ describe("subagent extension RPC bridge", () => {
 		assert.equal((fleet as { omitted?: number }).omitted, 0);
 		assert.deepEqual(fleet.entries[0], {
 			key: "fleet-1", agent: "reviewer", role: "opaque label", model: "anthropic/claude-opus-4-8:high", effort: "high",
-			startedAt: 120, tokens: { input: 12, output: 34, total: 46 }, goal: "Review the diff",
+			startedAt: 120, tokens: { input: 12, output: 34, total: 46 },
 		});
+		assert.equal(JSON.stringify(fleet).includes("Review the diff"), false);
 		assert.equal(JSON.stringify(fleet).includes("async-private-id"), false);
 		bridge.dispose();
 	});
@@ -200,15 +201,13 @@ describe("subagent extension RPC bridge", () => {
 		const malformedSurrogate = /[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/u;
 
 		assert.doesNotMatch(entry.agent, malformedSurrogate);
-		assert.doesNotMatch(entry.goal, malformedSurrogate);
-		assert.doesNotMatch(entry.goal, /[\r\n]/);
+		assert.equal(entry.goal, undefined);
 		assert.ok(entry.agent.length <= 96);
-		assert.ok(entry.goal.length <= 512);
 		assert.match(entry.agent, /^worker broken/);
 		bridge.dispose();
 	});
 
-	it("projects resolved foreground model, effort, split usage, and goal", async () => {
+	it("projects resolved foreground model, effort, and split usage without prompt goals", async () => {
 		const events = new FakeEvents();
 		const state = {
 			currentSessionId: "session-123",
@@ -231,6 +230,7 @@ describe("subagent extension RPC bridge", () => {
 				}]]),
 			}]]),
 			asyncJobs: new Map(),
+			activeAsyncCapacity: { used: 2, limit: 4 },
 		} as any;
 		state.foregroundControls.set("private-old", {
 			runId: "private-old",
@@ -250,6 +250,7 @@ describe("subagent extension RPC bridge", () => {
 		assert.deepEqual((reply as any).data.fleet, {
 			version: 1,
 			totalActive: 1,
+			topLevelAsyncCapacity: { used: 2, limit: 4 },
 			omitted: 0,
 			entries: [{
 				key: "fleet-1",
@@ -258,7 +259,6 @@ describe("subagent extension RPC bridge", () => {
 				effort: "high",
 				startedAt: 100,
 				tokens: { input: 321, output: 45, total: 366 },
-				goal: "Implement the fix",
 			}],
 		});
 		assert.equal(JSON.stringify((reply as any).data.fleet).includes("private-run"), false);

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

@@ -0,0 +1,121 @@
+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 { spawn } from "node:child_process";
+import { afterEach, describe, it } from "node:test";
+import {
+	claimRunFanoutBatch,
+	claimRunFanoutBatchWithCommit,
+	createRunFanoutBudget,
+	decodeRunFanoutBudgetDescriptor,
+	encodeRunFanoutBudgetDescriptor,
+	getRunFanoutBudgetSnapshot,
+	RunFanoutLimitError,
+	validateRunFanoutBudgetDescriptor,
+} from "../../src/runs/shared/run-fanout-budget.ts";
+import { resolveMaxSubagentSpawnsPerRun } from "../../src/shared/types.ts";
+
+const directories: string[] = [];
+const externalDirectories: string[] = [];
+const previousEnv = process.env.SELESAI_SUBAGENT_MAX_SPAWNS_PER_RUN;
+
+afterEach(() => {
+	for (const directory of directories.splice(0)) fs.rmSync(directory, { recursive: true, force: true });
+	for (const directory of externalDirectories.splice(0)) fs.rmSync(directory, { recursive: true, force: true });
+	if (previousEnv === undefined) delete process.env.SELESAI_SUBAGENT_MAX_SPAWNS_PER_RUN;
+	else process.env.SELESAI_SUBAGENT_MAX_SPAWNS_PER_RUN = previousEnv;
+});
+
+function budget(limit: number) {
+	const descriptor = createRunFanoutBudget(`test-${Date.now()}-${Math.random()}`, limit);
+	directories.push(descriptor.directory);
+	return descriptor;
+}
+
+describe("run fan-out budget", () => {
+	it("resolves environment over config and falls back to 64", () => {
+		delete process.env.SELESAI_SUBAGENT_MAX_SPAWNS_PER_RUN;
+		assert.equal(resolveMaxSubagentSpawnsPerRun(undefined), 64);
+		assert.equal(resolveMaxSubagentSpawnsPerRun(12), 12);
+		for (const invalid of [0, -1, 1.5, "bad"]) assert.equal(resolveMaxSubagentSpawnsPerRun(invalid as number), 64);
+		process.env.SELESAI_SUBAGENT_MAX_SPAWNS_PER_RUN = "7";
+		assert.equal(resolveMaxSubagentSpawnsPerRun(12), 7);
+		for (const invalid of ["0", "-1", "1.5", "bad"]) {
+			process.env.SELESAI_SUBAGENT_MAX_SPAWNS_PER_RUN = invalid;
+			assert.equal(resolveMaxSubagentSpawnsPerRun(undefined), 64);
+		}
+	});
+
+	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.throws(() => claimRunFanoutBatch(descriptor, ["tasks[2]"]), (error: unknown) => {
+			assert.ok(error instanceof RunFanoutLimitError);
+			assert.equal(error.rejection.path, "tasks[2]");
+			assert.equal(error.rejection.used, 2);
+			assert.equal(error.rejection.remaining, 0);
+			return true;
+		});
+	});
+
+	it("rolls back only the failed admission batch", () => {
+		const descriptor = budget(2);
+		claimRunFanoutBatch(descriptor, ["single"]);
+		assert.throws(() => claimRunFanoutBatch(descriptor, ["chain[0]", "chain[1]"]), RunFanoutLimitError);
+		assert.deepEqual(getRunFanoutBudgetSnapshot(descriptor), { used: 1, limit: 2, remaining: 1 });
+	});
+
+	it("rolls back a batch when its commit fails", () => {
+		const descriptor = budget(2);
+		claimRunFanoutBatch(descriptor, ["existing"]);
+		assert.throws(
+			() => claimRunFanoutBatchWithCommit(descriptor, ["append"], () => { throw new Error("enqueue failed"); }),
+			/enqueue failed/,
+		);
+		assert.deepEqual(getRunFanoutBudgetSnapshot(descriptor), { used: 1, limit: 2, remaining: 1 });
+	});
+
+	it("reports claims-directory I/O errors instead of ordinary exhaustion", () => {
+		const descriptor = budget(2);
+		fs.rmSync(path.join(descriptor.directory, "claims"), { recursive: true });
+		fs.writeFileSync(path.join(descriptor.directory, "claims"), "not a directory", "utf-8");
+		assert.throws(() => getRunFanoutBudgetSnapshot(descriptor), /claims directory is unreadable.*ENOTDIR/);
+	});
+
+	it("admits exactly one simultaneous two-slot batch at limit two", async () => {
+		const moduleUrl = new URL("../../src/runs/shared/run-fanout-budget.ts", import.meta.url).href;
+		const script = `import { claimRunFanoutBatch } from ${JSON.stringify(moduleUrl)}; const descriptor = JSON.parse(process.argv[1]); try { claimRunFanoutBatch(descriptor, [process.argv[2] + "[0]", process.argv[2] + "[1]"]); process.stdout.write("admitted"); } catch { process.stdout.write("rejected"); }`;
+		for (let iteration = 0; iteration < 12; iteration++) {
+			const descriptor = budget(2);
+			const launch = (claimPath: string) => new Promise<string>((resolve, reject) => {
+				const child = spawn(process.execPath, ["--experimental-strip-types", "--input-type=module", "--eval", script, JSON.stringify(descriptor), claimPath], { stdio: ["ignore", "pipe", "pipe"] });
+				let stdout = "";
+				let stderr = "";
+				child.stdout.on("data", (chunk) => { stdout += chunk; });
+				child.stderr.on("data", (chunk) => { stderr += chunk; });
+				child.on("error", reject);
+				child.on("close", (code) => code === 0 ? resolve(stdout) : reject(new Error(stderr)));
+			});
+
+			assert.deepEqual((await Promise.all([launch("group-a"), launch("group-b")])).sort(), ["admitted", "rejected"], `iteration ${iteration}`);
+			assert.deepEqual(getRunFanoutBudgetSnapshot(descriptor), { used: 2, limit: 2, remaining: 0 });
+		}
+	});
+
+	it("fails closed when descriptor identity or managed-root containment is invalid", () => {
+		const descriptor = budget(2);
+		assert.throws(() => validateRunFanoutBudgetDescriptor({ ...descriptor, limit: 3 }), /does not match/);
+
+		const outside = fs.mkdtempSync(path.join(os.tmpdir(), "pi-run-fanout-outside-"));
+		externalDirectories.push(outside);
+		fs.mkdirSync(path.join(outside, "claims"));
+		fs.writeFileSync(path.join(outside, "manifest.json"), JSON.stringify({ version: 1, rootRunId: descriptor.rootRunId, limit: 2, createdAt: Date.now() }));
+		const linked = path.join(path.dirname(descriptor.directory), `linked-${Date.now()}`);
+		fs.symlinkSync(outside, linked, process.platform === "win32" ? "junction" : "dir");
+		directories.push(linked);
+		assert.throws(() => validateRunFanoutBudgetDescriptor({ ...descriptor, directory: linked }), /resolves outside/);
+	});
+});

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

@@ -6,6 +6,7 @@ import { describe, it } from "node:test";
 import { updateActiveRunIndex } from "../../src/runs/background/active-run-index.ts";
 import { inspectSubagentStatus } from "../../src/runs/background/run-status.ts";
 import { createNestedRoute, writeNestedEvent } from "../../src/runs/shared/nested-events.ts";
+import { claimRunFanoutBatch, createRunFanoutBudget, writeRunFanoutBudgetDescriptor } from "../../src/runs/shared/run-fanout-budget.ts";
 import { TEMP_ROOT_DIR, type SubagentState } from "../../src/shared/types.ts";
 
 function errno(code: string): NodeJS.ErrnoException {
@@ -22,6 +23,7 @@ function textContent(result: ReturnType<typeof inspectSubagentStatus>): string {
 describe("async run status inspection", () => {
 	it("repairs stale running status and reports diagnosis plus result path", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-run-status-stale-"));
+		let budgetDirectory: string | undefined;
 		try {
 			const asyncRoot = path.join(root, "runs");
 			const resultsDir = path.join(root, "results");
@@ -40,6 +42,10 @@ describe("async run status inspection", () => {
 				sessionFile,
 				steps: [{ agent: "scout", status: "running", startedAt: 100, sessionFile }],
 			}, null, 2), "utf-8");
+			const descriptor = createRunFanoutBudget("run-stale", 64);
+			budgetDirectory = descriptor.directory;
+			writeRunFanoutBudgetDescriptor(asyncDir, descriptor);
+			claimRunFanoutBatch(descriptor, ["single"]);
 
 			const result = inspectSubagentStatus({ id: "run-stale" }, {
 				asyncDirRoot: asyncRoot,
@@ -51,6 +57,8 @@ describe("async run status inspection", () => {
 			const text = textContent(result);
 			assert.equal(result.isError, undefined);
 			assert.match(text, /State: failed/);
+			assert.match(text, /Run fan-out: 1\/64 used, 63 remaining/);
+			assert.deepEqual(result.details.runFanoutBudget, { used: 1, limit: 64, remaining: 63 });
 			assert.match(text, /Diagnosis: Async runner process 12345 exited or disappeared/);
 			assert.match(text, new RegExp(`Result: ${path.join(resultsDir, "run-stale.json").replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`));
 			assert.match(text, /Step 1: scout failed, error: Async runner process 12345 exited or disappeared/);
@@ -60,6 +68,7 @@ describe("async run status inspection", () => {
 			assert.equal(resultJson.results[0].sessionFile, sessionFile);
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });
+			if (budgetDirectory) fs.rmSync(budgetDirectory, { recursive: true, force: true });
 		}
 	});
 

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

@@ -236,12 +236,13 @@ describe("SubagentParams schema", { skip: !schemasAvailable ? "typebox not avail
 		assert.ok(maxRuntimeSchema, "maxRuntimeMs schema should exist");
 		assert.equal(timeoutSchema.minimum, 1);
 		assert.equal(maxRuntimeSchema.minimum, 1);
-		assert.match(String(timeoutSchema.description ?? ""), /foreground runs and async children/i);
-		assert.match(String(timeoutSchema.description ?? ""), /async children default to 30m/i);
+		assert.match(String(timeoutSchema.description ?? ""), /foreground and single async runs/i);
+		assert.match(String(timeoutSchema.description ?? ""), /use config timeoutMs, else 30m/i);
 		assert.match(String(timeoutSchema.description ?? ""), /async composites have no default parent deadline/i);
 		assert.doesNotMatch(String(timeoutSchema.description ?? ""), /foreground-only/i);
 		assert.match(String(maxRuntimeSchema.description ?? ""), /timeoutMs/i);
-		assert.match(String(maxRuntimeSchema.description ?? ""), /async children default to 30m/i);
+		assert.match(String(maxRuntimeSchema.description ?? ""), /foreground and single async runs/i);
+		assert.match(String(maxRuntimeSchema.description ?? ""), /use config timeoutMs, else 30m/i);
 		assert.match(String(maxRuntimeSchema.description ?? ""), /async composites have no default parent deadline/i);
 		assert.equal(turnBudgetSchema?.properties?.maxTurns?.minimum, 1);
 		assert.equal(turnBudgetSchema?.properties?.graceTurns?.minimum, 0);

package/dist/extensions/pi-subagents/test/unit/single-output.test.ts

@@ -309,4 +309,32 @@ describe("finalizeSingleOutput", () => {
 
 		assert.equal(result.displayOutput, "truncated output");
 	});
+
+	it("preserves the saved-output reference for acceptance-only failures", () => {
+		const result = finalizeSingleOutput({
+			fullOutput: "useful output",
+			outputPath: "/tmp/review.md",
+			outputMode: "file-only",
+			exitCode: 1,
+			preserveSavedOutput: true,
+			savedPath: "/tmp/review.md",
+		});
+
+		assert.match(result.displayOutput, /^Output saved to:/);
+		assert.doesNotMatch(result.displayOutput, /useful output/);
+	});
+
+	it("does not duplicate an existing saved-output reference", () => {
+		const outputReference = formatSavedOutputReference("/tmp/review.md", "useful output");
+		const result = finalizeSingleOutput({
+			fullOutput: `useful output\n\n${outputReference.message}`,
+			outputPath: "/tmp/review.md",
+			exitCode: 1,
+			preserveSavedOutput: true,
+			savedPath: "/tmp/review.md",
+			outputReference,
+		});
+
+		assert.equal(result.displayOutput.match(/Output saved to:/g)?.length, 1);
+	});
 });

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

@@ -2,11 +2,12 @@ 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 { writeAtomicJson, writePrivateAtomicJson } from "../../src/shared/atomic-json.ts";
 import { closeSteerInbox, interruptRequestPath, steerRequestsDir, writeSteerAck, type SteerRequest } from "../../src/runs/background/control-channel.ts";
 import { steerAsyncRun } from "../../src/runs/foreground/async-steering-action.ts";
 import { createSteeringStatus, recordSteeringRequest, updateSteeringTarget } from "../../src/runs/background/steering.ts";
+import { createRunFanoutBudget } from "../../src/runs/shared/run-fanout-budget.ts";
 import { ASYNC_DIR, type AsyncStatus, type Details, type SteeringRecoveryDescriptor, type SteeringTargetState, type SubagentState } from "../../src/shared/types.ts";
 
 function createState(): SubagentState {
@@ -29,6 +30,11 @@ function createState(): SubagentState {
 }
 
 let statusWriteMtimeMs = Date.now();
+const budgetDirectories: string[] = [];
+
+afterEach(() => {
+	for (const directory of budgetDirectories.splice(0)) fs.rmSync(directory, { recursive: true, force: true });
+});
 
 function writeStatus(asyncDir: string, status: AsyncStatus): void {
 	fs.mkdirSync(asyncDir, { recursive: true });
@@ -91,8 +97,11 @@ async function readRequest(asyncDir: string): Promise<SteerRequest> {
 }
 
 function recoveryDescriptor(runId: string): SteeringRecoveryDescriptor {
+	const runFanoutBudget = createRunFanoutBudget(runId, 64);
+	budgetDirectories.push(runFanoutBudget.directory);
 	return {
 		version: 1,
+		runFanoutBudget,
 		sourceRunId: runId,
 		agent: "worker-0",
 		cwd: os.tmpdir(),

package/dist/extensions/pi-subagents/test/unit/task-intent.test.ts

@@ -61,6 +61,45 @@ describe("classifyTaskMutationIntent", () => {
 		assert.equal(classifyTaskMutationIntent("worker", "Create a summary").kind, "unknown");
 	});
 
+	it("does not read hyphenated fix adjectives as the fix verb", () => {
+		// Core regression: "must-fix items" in review output specs (fails on old code).
+		assert.equal(classifyTaskMutationIntent("worker", "Return a review with the top 2-3 must-fix items").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "Return a review with the top 2-3 must-fix items.").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "Review and report MUST-FIX items").kind, "unknown");
+		// should-fix with a noun from the pattern's alternation (also fails on old code).
+		assert.equal(classifyTaskMutationIntent("worker", "List should-fix tests with severity labels").kind, "unknown");
+		// Same class for other verbs: hyphenated adjective + verb.
+		assert.equal(classifyTaskMutationIntent("worker", "Return must-edit findings").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "Return must-update items").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "List should-add files").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "Return must-apply changes").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "List should-make changes").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "must-do those fixes").kind, "unknown");
+		// Dash coverage: U+2010 hyphen, U+2011 non-breaking hyphen, en/em dashes.
+		assert.equal(classifyTaskMutationIntent("worker", "Return the must\u2010fix items").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "Return the must\u2011fix items").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "Return the must\u2013fix items").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "Return the must\u2014fix items").kind, "unknown");
+		// Clause-level em/en dashes are punctuation, not compounds: "branch—fix it".
+		assert.equal(classifyTaskMutationIntent("worker", "Inspect the failing branch\u2014fix it.").kind, "implementation");
+		assert.equal(classifyTaskMutationIntent("worker", "Inspect the failing branch\u2013fix it.").kind, "implementation");
+		assert.equal(taskMayMutate("Inspect the failing branch\u2014fix it."), true);
+		// Hyphenated genuine imperatives stay write-capable.
+		assert.equal(taskMayMutate("hot-fix the bug"), true);
+		assert.equal(taskMayMutate("quick-fix that bug"), true);
+		// Genuine imperative usage keeps classifying as implementation.
+		assert.equal(classifyTaskMutationIntent("worker", "Go through the list and fix items one by one").kind, "implementation");
+		assert.equal(classifyTaskMutationIntent("worker", "fix items on the sprint board").kind, "implementation");
+		// CLI flags keep write intent: "--fix" / "-w" are not hyphenated adjectives.
+		assert.equal(classifyTaskMutationIntent("worker", "Run eslint --fix code").kind, "implementation");
+		assert.equal(taskMayMutate("Run eslint --fix code"), true);
+		// "--write" was never a classifier verb (pre-existing unknown); the
+		// regression guard is that write-capability survives for acceptance.
+		assert.equal(taskMayMutate("Run prettier --write files"), true);
+		// Guard-facing mirror: the completion guard must not expect mutation.
+		assert.equal(expectsImplementationMutation("worker", "Return a review with the top 2-3 must-fix items"), false);
+	});
+
 	it("expectsImplementationMutation mirrors the classifier", () => {
 		assert.equal(expectsImplementationMutation("worker", "Do not modify tests; implement the fix"), true);
 		assert.equal(expectsImplementationMutation("worker", "Review the diff and suggest fixes only. Do not edit files."), false);