@selesai/code 0.5.20 → 0.5.21

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

@@ -0,0 +1,124 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+	formatSpawnBudget,
+	getSpawnBudgetSnapshot,
+	grantSpawnBudget,
+	preflightSpawnBudget,
+	reserveSpawnBudget,
+} from "../../src/runs/shared/spawn-budget.ts";
+import type { ExtensionConfig, SubagentState } from "../../src/shared/types.ts";
+
+function makeState(sessionId = "session-a"): SubagentState {
+	return {
+		baseCwd: "",
+		currentSessionId: sessionId,
+		asyncJobs: new Map(),
+		foregroundControls: new Map(),
+		lastForegroundControlId: null,
+	};
+}
+
+const capped: ExtensionConfig = { maxSubagentSpawnsPerSession: 4 };
+
+describe("spawn budget", () => {
+	it("keeps unset and zero caps unlimited without cumulative accounting", () => {
+		for (const config of [{}, { maxSubagentSpawnsPerSession: 0 }]) {
+			const state = makeState();
+			const reserved = reserveSpawnBudget(state, config, "session-a", 50);
+			assert.equal(reserved.error, undefined);
+			assert.deepEqual(reserved.snapshot, {
+				used: 0,
+				configuredLimit: null,
+				granted: 0,
+				limit: null,
+				remaining: null,
+				grantRemaining: null,
+				grantHistory: [],
+			});
+			assert.equal(formatSpawnBudget(reserved.snapshot), "Spawn budget: unlimited");
+		}
+	});
+
+	it("preflights declared capacity without reserving partial work", () => {
+		const state = makeState();
+		state.subagentSpawns = { sessionId: "session-a", count: 2 };
+
+		const checked = preflightSpawnBudget(state, capped, "session-a", 3);
+		assert.match(checked.error ?? "", /2\/4 used, 3 requested\).*2 remaining/);
+		assert.equal(state.subagentSpawns.count, 2);
+	});
+
+	it("reserves cumulative declared capacity", () => {
+		const state = makeState();
+		const first = reserveSpawnBudget(state, capped, "session-a", 3);
+		assert.equal(first.error, undefined);
+		assert.equal(first.snapshot.used, 3);
+		assert.equal(first.snapshot.remaining, 1);
+
+		const rejected = reserveSpawnBudget(state, capped, "session-a", 2);
+		assert.match(rejected.error ?? "", /3\/4 used, 2 requested\).*1 remaining/);
+		assert.equal(state.subagentSpawns?.count, 3);
+	});
+
+	it("grants at most the original configured limit and keeps bounded audit records", () => {
+		const state = makeState();
+		state.subagentSpawns = { sessionId: "session-a", count: 4 };
+
+		const first = grantSpawnBudget(state, capped, "session-a", 3, 100);
+		assert.equal(first.error, undefined);
+		assert.equal(first.snapshot.limit, 7);
+		assert.equal(first.snapshot.remaining, 3);
+		assert.equal(first.snapshot.grantRemaining, 1);
+		assert.deepEqual(first.snapshot.grantHistory, [
+			{ sessionId: "session-a", amount: 3, grantedAt: 100, previousLimit: 4, limit: 7 },
+		]);
+
+		const rejected = grantSpawnBudget(state, capped, "session-a", 2, 200);
+		assert.match(rejected.error ?? "", /2 requested but only 1/);
+		assert.equal(rejected.snapshot.limit, 7);
+
+		const final = grantSpawnBudget(state, capped, "session-a", 1, 300);
+		assert.equal(final.error, undefined);
+		assert.equal(final.snapshot.limit, 8);
+		assert.equal(final.snapshot.granted, 4);
+		assert.equal(final.snapshot.grantRemaining, 0);
+	});
+
+	it("bounds grant history while preserving aggregate granted capacity", () => {
+		const state = makeState();
+		const config = { maxSubagentSpawnsPerSession: 100 };
+		for (let index = 0; index < 25; index += 1) {
+			const granted = grantSpawnBudget(state, config, "session-a", 1, index);
+			assert.equal(granted.error, undefined);
+		}
+
+		const snapshot = getSpawnBudgetSnapshot(state, config, "session-a");
+		assert.equal(snapshot.granted, 25);
+		assert.equal(snapshot.limit, 125);
+		assert.equal(snapshot.grantHistory.length, 20);
+		assert.equal(snapshot.grantHistory[0]?.grantedAt, 5);
+	});
+
+	it("rejects meaningless or invalid grants", () => {
+		const state = makeState();
+		assert.match(grantSpawnBudget(state, {}, "session-a", 1).error ?? "", /no configured spawn cap/);
+		assert.match(grantSpawnBudget(state, capped, "session-a", 0).error ?? "", /positive integer/);
+		assert.match(grantSpawnBudget(state, capped, "session-a", 1.5).error ?? "", /positive integer/);
+	});
+
+	it("resets usage and grants only when the logical session changes", () => {
+		const state = makeState();
+		reserveSpawnBudget(state, capped, "session-a", 2);
+		grantSpawnBudget(state, capped, "session-a", 2, 100);
+
+		const sameSession = getSpawnBudgetSnapshot(state, capped, "session-a");
+		assert.equal(sameSession.used, 2);
+		assert.equal(sameSession.granted, 2);
+
+		const newSession = getSpawnBudgetSnapshot(state, capped, "session-b");
+		assert.equal(newSession.used, 0);
+		assert.equal(newSession.granted, 0);
+		assert.equal(newSession.limit, 4);
+	});
+});

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

@@ -153,8 +153,8 @@ describe("async stale-run reconciliation", () => {
 				startedAt: 1000,
 				lastUpdate: 1000,
 				steps: [
-					{ agent: "scout", status: "running", startedAt: 1000 },
-					{ agent: "worker", status: "running", startedAt: 1100 },
+					{ agent: "scout", status: "running", startedAt: 1000, model: "planned-scout", attemptedModels: ["planned-scout"] },
+					{ agent: "worker", status: "running", startedAt: 1100, model: "planned-worker", attemptedModels: ["planned-worker"] },
 				],
 			});
 			const scoutSession = path.join(root, "scout.jsonl");
@@ -164,8 +164,8 @@ describe("async stale-run reconciliation", () => {
 				success: false,
 				state: "failed",
 				results: [
-					{ agent: "scout", success: true, sessionFile: scoutSession, model: "fast" },
-					{ agent: "worker", success: false, error: "boom", sessionFile: workerSession, model: "careful" },
+					{ agent: "scout", success: true, sessionFile: scoutSession, model: "fast", attemptedModels: ["planned-scout", "fast"] },
+					{ agent: "worker", success: false, error: "boom", sessionFile: workerSession, model: "careful", attemptedModels: ["planned-worker", "careful"] },
 				],
 			}, null, 2), "utf-8");
 
@@ -180,11 +180,13 @@ describe("async stale-run reconciliation", () => {
 			assert.equal(result.status?.steps?.[0]?.status, "complete");
 			assert.equal(result.status?.steps?.[0]?.exitCode, 0);
 			assert.equal(result.status?.steps?.[0]?.model, "fast");
+			assert.deepEqual(result.status?.steps?.[0]?.attemptedModels, ["planned-scout", "fast"]);
 			assert.equal(result.status?.steps?.[0]?.sessionFile, scoutSession);
 			assert.equal(result.status?.steps?.[1]?.status, "failed");
 			assert.equal(result.status?.steps?.[1]?.exitCode, 1);
 			assert.equal(result.status?.steps?.[1]?.error, "boom");
 			assert.equal(result.status?.steps?.[1]?.model, "careful");
+			assert.deepEqual(result.status?.steps?.[1]?.attemptedModels, ["planned-worker", "careful"]);
 			assert.equal(result.status?.steps?.[1]?.sessionFile, workerSession);
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });

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

@@ -1,5 +1,6 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
+import { formatModelThinking } from "../../src/shared/formatters.ts";
 import { aggregateStepStatus, formatActivityLabel, formatParallelOutcome } from "../../src/shared/status-format.ts";
 import type { AsyncJobStep } from "../../src/shared/types.ts";
 
@@ -8,6 +9,12 @@ describe("status format helpers", () => {
 		assert.equal(formatActivityLabel(1_000, undefined, 1_500), "active now");
 		assert.equal(formatActivityLabel(1_000, "needs_attention", 4_000), "no activity for 3s");
 		assert.equal(formatActivityLabel(undefined, "active_long_running", 4_000), "active but long-running");
+		assert.equal(formatActivityLabel(4_000, "active_long_running", 4_000), "active but long-running · last activity now");
+	});
+
+	it("formats max thinking from model suffixes and explicit metadata", () => {
+		assert.equal(formatModelThinking("openai/gpt-5:max"), "gpt-5 · thinking max");
+		assert.equal(formatModelThinking("openai/gpt-5", "max"), "gpt-5 · thinking max");
 	});
 
 	it("aggregates step status and parallel outcomes", () => {

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

@@ -0,0 +1,397 @@
+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 { 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 { ASYNC_DIR, type AsyncStatus, type Details, type SteeringRecoveryDescriptor, type SteeringTargetState, type SubagentState } from "../../src/shared/types.ts";
+
+function createState(): SubagentState {
+	return {
+		baseCwd: "",
+		currentSessionId: "session",
+		asyncJobs: new Map(),
+		foregroundRuns: new Map(),
+		foregroundControls: new Map(),
+		lastForegroundControlId: null,
+		pendingForegroundControlNotices: new Map(),
+		cleanupTimers: new Map(),
+		lastUiContext: null,
+		poller: null,
+		completionSeen: new Map(),
+		watcher: null,
+		watcherRestartTimer: null,
+		resultFileCoalescer: { schedule: () => false, clear: () => {} },
+	};
+}
+
+function writeStatus(asyncDir: string, status: AsyncStatus): void {
+	fs.mkdirSync(asyncDir, { recursive: true });
+	writeAtomicJson(path.join(asyncDir, "status.json"), status);
+}
+
+function runningStatus(runId: string, mode: AsyncStatus["mode"] = "single", count = 1): AsyncStatus {
+	return {
+		runId,
+		sessionId: "session",
+		mode,
+		state: "running",
+		pid: 12345,
+		cwd: os.tmpdir(),
+		startedAt: Date.now(),
+		lastUpdate: Date.now(),
+		steps: Array.from({ length: count }, (_, index) => ({ agent: `worker-${index}`, status: "running" as const, startedAt: Date.now() })),
+		steering: createSteeringStatus(),
+	};
+}
+
+function projectRequest(status: AsyncStatus, request: SteerRequest, states: SteeringTargetState[]): void {
+	const targets = states.map((state, index) => ({ index, state }));
+	status.steering ??= createSteeringStatus();
+	recordSteeringRequest(status.steering, { id: request.id, requestedAt: request.ts, source: request.source, message: request.message, targets });
+	for (const target of targets) {
+		const step = status.steps?.[target.index];
+		if (!step) continue;
+		step.steering = createSteeringStatus();
+		recordSteeringRequest(step.steering, { id: request.id, requestedAt: request.ts, source: request.source, message: request.message, targets: [target] });
+	}
+}
+
+async function waitUntil<T>(read: () => T | undefined, timeoutMs = 1_000): Promise<T> {
+	const deadline = Date.now() + timeoutMs;
+	while (true) {
+		const value = read();
+		if (value !== undefined) return value;
+		if (Date.now() >= deadline) throw new Error("Timed out waiting for steering test condition.");
+		await new Promise((resolve) => setTimeout(resolve, 5));
+	}
+}
+
+async function readRequest(asyncDir: string): Promise<SteerRequest> {
+	return waitUntil(() => {
+		const dir = steerRequestsDir(asyncDir);
+		if (!fs.existsSync(dir)) return undefined;
+		const file = fs.readdirSync(dir).find((entry) => entry.endsWith(".json"));
+		return file ? JSON.parse(fs.readFileSync(path.join(dir, file), "utf-8")) as SteerRequest : undefined;
+	});
+}
+
+function recoveryDescriptor(runId: string): SteeringRecoveryDescriptor {
+	return {
+		version: 1,
+		sourceRunId: runId,
+		agent: "worker-0",
+		cwd: os.tmpdir(),
+		systemPromptMode: "replace",
+		inheritProjectContext: false,
+		inheritSkills: false,
+		outputMode: "inline",
+		absoluteDeadlineAt: Date.now() + 10_000,
+		initialTurnBudget: { maxTurns: 10, graceTurns: 2 },
+		initialToolBudget: { soft: 8, hard: 12, block: ["read"] },
+		maxSubagentDepth: 2,
+		share: false,
+	};
+}
+
+function successResult(asyncId: string): { content: [{ type: "text"; text: string }]; details: Details } {
+	return { content: [{ type: "text", text: "started" }], details: { mode: "single", results: [], asyncId } };
+}
+
+describe("acknowledged steering action", () => {
+	it("returns delivered only after the runner records child-session acceptance", async () => {
+		const runId = `steer-delivered-${Date.now().toString(36)}`;
+		const asyncDir = path.join(ASYNC_DIR, runId);
+		writeStatus(asyncDir, runningStatus(runId));
+		try {
+			const action = steerAsyncRun({ state: createState(), runId, message: "correct course", location: { asyncDir }, ackTimeoutMs: 500, kill: () => true });
+			const request = await readRequest(asyncDir);
+			assert.deepEqual(request.targetIndexes, [0]);
+			const status = runningStatus(runId);
+			projectRequest(status, request, ["routed"]);
+			updateSteeringTarget(status.steering!, request.id, 0, "delivered", Date.now());
+			updateSteeringTarget(status.steps![0]!.steering!, request.id, 0, "delivered", Date.now());
+			writeStatus(asyncDir, status);
+			const result = await action;
+			assert.equal(result.isError, undefined);
+			assert.equal(result.details.steering?.state, "delivered");
+			assert.match(result.content[0]!.text, /Steering delivered/);
+		} finally {
+			fs.rmSync(asyncDir, { recursive: true, force: true });
+		}
+	});
+
+	it("returns a tool error when the runner has closed its steering inbox", async () => {
+		const runId = `steer-closed-${Date.now().toString(36)}`;
+		const asyncDir = path.join(ASYNC_DIR, runId);
+		writeStatus(asyncDir, runningStatus(runId));
+		closeSteerInbox(asyncDir, "complete");
+		try {
+			const result = await steerAsyncRun({ state: createState(), runId, message: "too late", location: { asyncDir }, kill: () => true });
+			assert.equal(result.isError, true);
+			assert.match(result.content[0]!.text, /no longer accepts steering requests/);
+		} finally {
+			fs.rmSync(asyncDir, { recursive: true, force: true });
+		}
+	});
+
+	it("does not commit recovery when the caller aborts the acknowledgment wait", async () => {
+		const runId = `steer-abort-${Date.now().toString(36)}`;
+		const asyncDir = path.join(ASYNC_DIR, runId);
+		writeStatus(asyncDir, runningStatus(runId));
+		const controller = new AbortController();
+		controller.abort();
+		let interrupted = false;
+		let recovered = false;
+		try {
+			const result = await steerAsyncRun({
+				state: createState(), runId, message: "correct course", location: { asyncDir }, signal: controller.signal,
+				kill: (_pid, signal) => { if (signal !== 0) interrupted = true; return true; },
+				recover: async () => { recovered = true; return successResult("replacement"); },
+			});
+			assert.equal(result.details.steering?.state, "pending");
+			assert.equal(interrupted, false);
+			assert.equal(recovered, false);
+			assert.equal(fs.existsSync(path.join(asyncDir, "control", "steer-recovery")), false);
+		} finally {
+			fs.rmSync(asyncDir, { recursive: true, force: true });
+		}
+	});
+
+	it("honors an acknowledgment persisted before recovery commit without interrupting", async () => {
+		const runId = `steer-final-ack-${Date.now().toString(36)}`;
+		const asyncDir = path.join(ASYNC_DIR, runId);
+		writeStatus(asyncDir, runningStatus(runId));
+		let request: SteerRequest | undefined;
+		let interrupted = false;
+		let recovered = false;
+		try {
+			const result = await steerAsyncRun({
+				state: createState(), runId, message: "correct course", location: { asyncDir }, ackTimeoutMs: 25,
+				kill: (_pid, signal) => { if (signal !== 0) interrupted = true; return true; },
+				onRequestQueued: (requestPath) => {
+					request = JSON.parse(fs.readFileSync(requestPath, "utf-8")) as SteerRequest;
+					const routed = runningStatus(runId);
+					projectRequest(routed, request, ["routed"]);
+					writeStatus(asyncDir, routed);
+				},
+				onBeforeRecoveryClaim: (_requestId, committedAt) => {
+					assert.ok(request);
+					const recoveryDir = path.join(asyncDir, "control", "steer-recovery");
+					assert.equal(fs.existsSync(path.join(recoveryDir, "claim.json")), false);
+					assert.equal(fs.existsSync(path.join(recoveryDir, `${Buffer.from(request.id).toString("base64url")}.json`)), false);
+					const acknowledged = runningStatus(runId);
+					projectRequest(acknowledged, request, ["routed"]);
+					updateSteeringTarget(acknowledged.steering!, request.id, 0, "delivered", committedAt);
+					updateSteeringTarget(acknowledged.steps![0]!.steering!, request.id, 0, "delivered", committedAt);
+					writeStatus(asyncDir, acknowledged);
+				},
+				recover: async () => { recovered = true; return successResult("replacement"); },
+			});
+			assert.equal(result.details.steering?.state, "delivered");
+			assert.equal(interrupted, false);
+			assert.equal(recovered, false);
+			assert.ok(request);
+			assert.equal(fs.existsSync(path.join(asyncDir, "control", "steer-recovery", `${Buffer.from(request.id).toString("base64url")}.json`)), false);
+		} finally {
+			fs.rmSync(asyncDir, { recursive: true, force: true });
+		}
+	});
+
+	it("releases the recovery claim when interrupt delivery definitively fails", async () => {
+		const runId = `steer-interrupt-failed-${Date.now().toString(36)}`;
+		const asyncDir = path.join(ASYNC_DIR, runId);
+		writeStatus(asyncDir, runningStatus(runId));
+		try {
+			const action = steerAsyncRun({
+				state: createState(),
+				runId,
+				message: "correct course",
+				location: { asyncDir },
+				ackTimeoutMs: 25,
+				kill: (_pid, signal) => {
+					if (signal === 0) return true;
+					const error = new Error("runner disappeared") as NodeJS.ErrnoException;
+					error.code = "ESRCH";
+					throw error;
+				},
+				recover: async () => successResult("replacement"),
+			});
+			const request = await readRequest(asyncDir);
+			const routed = runningStatus(runId);
+			projectRequest(routed, request, ["routed"]);
+			writeStatus(asyncDir, routed);
+			const result = await action;
+			assert.equal(result.isError, true);
+			assert.match(result.content[0]!.text, /Failed to commit steering recovery interrupt/);
+			const recoveryDir = path.join(asyncDir, "control", "steer-recovery");
+			assert.equal(fs.existsSync(path.join(recoveryDir, "claim.json")), false);
+			assert.equal(fs.existsSync(path.join(recoveryDir, `${Buffer.from(request.id).toString("base64url")}.json`)), false);
+		} finally {
+			fs.rmSync(asyncDir, { recursive: true, force: true });
+		}
+	});
+
+	it("keeps the claim after an unconfirmed pause to prevent delayed duplicate recovery", async () => {
+		const runId = `steer-pause-unconfirmed-${Date.now().toString(36)}`;
+		const asyncDir = path.join(ASYNC_DIR, runId);
+		writeStatus(asyncDir, runningStatus(runId));
+		try {
+			const action = steerAsyncRun({
+				state: createState(), runId, message: "correct course", location: { asyncDir },
+				ackTimeoutMs: 25, recoveryTimeoutMs: 50, kill: () => true,
+				recover: async () => successResult("replacement"),
+			});
+			const request = await readRequest(asyncDir);
+			const routed = runningStatus(runId);
+			projectRequest(routed, request, ["routed"]);
+			writeStatus(asyncDir, routed);
+			const result = await action;
+			assert.equal(result.isError, true);
+			assert.match(result.content[0]!.text, /claim remains committed to prevent a delayed duplicate/);
+			assert.equal(fs.existsSync(path.join(asyncDir, "control", "steer-recovery", "claim.json")), true);
+		} finally {
+			fs.rmSync(asyncDir, { recursive: true, force: true });
+		}
+	});
+
+	it("pauses and revives a single run with only its remaining budgets", async () => {
+		const runId = `steer-recover-${Date.now().toString(36)}`;
+		const asyncDir = path.join(ASYNC_DIR, runId);
+		const sessionFile = path.join(asyncDir, "child.jsonl");
+		writeStatus(asyncDir, runningStatus(runId));
+		fs.writeFileSync(sessionFile, "", "utf-8");
+		const descriptorPath = path.join(asyncDir, "recovery-descriptor.json");
+		writePrivateAtomicJson(descriptorPath, recoveryDescriptor(runId));
+		if (process.platform !== "win32") assert.equal(fs.statSync(descriptorPath).mode & 0o777, 0o600);
+		let receivedLimits: unknown;
+		let recoveryStarted = false;
+		try {
+			const action = steerAsyncRun({
+				state: createState(),
+				runId,
+				message: "correct course",
+				location: { asyncDir },
+				ackTimeoutMs: 25,
+				recoveryTimeoutMs: 500,
+				kill: () => true,
+				recover: async (limits) => { recoveryStarted = true; receivedLimits = limits; return successResult("replacement"); },
+			});
+			const request = await readRequest(asyncDir);
+			const routed = runningStatus(runId);
+			projectRequest(routed, request, ["routed"]);
+			writeStatus(asyncDir, routed);
+			await waitUntil(() => fs.existsSync(interruptRequestPath(asyncDir)) ? true : undefined);
+			writeSteerAck(asyncDir, { requestId: request.id, index: 0, ts: Date.now(), state: "delivered", message: "accepted after runner pause" });
+			const paused: AsyncStatus = {
+				...routed,
+				state: "paused",
+				turnBudget: { maxTurns: 10, graceTurns: 2, turnCount: 7, outcome: "within-budget" },
+				toolBudget: { soft: 8, hard: 12, block: ["read"], toolCount: 9, outcome: "soft-reached" },
+				steps: [{ ...routed.steps![0]!, status: "paused", sessionFile }],
+			};
+			writeStatus(asyncDir, paused);
+			await new Promise((resolve) => setTimeout(resolve, 30));
+			assert.equal(recoveryStarted, false, "recovery must wait for final paused persistence");
+			writeStatus(asyncDir, { ...paused, endedAt: Date.now() });
+			const result = await action;
+			assert.equal(result.isError, undefined);
+			assert.equal(result.details.steering?.state, "recovered");
+			assert.equal(result.details.steering?.replacementRunId, "replacement");
+			assert.ok(result.details.steering?.targets[0]?.lateDeliveredAt);
+			const limits = receivedLimits as { timeoutMs: number; absoluteDeadlineAt: number; turnBudget: unknown; toolBudget: unknown };
+			assert.ok(limits.timeoutMs > 0 && limits.timeoutMs <= 10_000);
+			assert.ok(limits.absoluteDeadlineAt >= Date.now());
+			assert.deepEqual({ turnBudget: limits.turnBudget, toolBudget: limits.toolBudget }, {
+				turnBudget: { maxTurns: 3, graceTurns: 2 },
+				toolBudget: { hard: 3, block: ["read"] },
+			});
+			const persisted = JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8")) as AsyncStatus;
+			assert.equal(persisted.steering?.recent[0]?.targets[0]?.state, "recovered");
+			assert.ok(persisted.steering?.recent[0]?.targets[0]?.lateDeliveredAt);
+			assert.equal(persisted.steps?.[0]?.steering?.recent[0]?.targets[0]?.state, "recovered");
+		} finally {
+			fs.rmSync(asyncDir, { recursive: true, force: true });
+		}
+	});
+
+	it("leaves an unacknowledged single run paused when no session can be revived", async () => {
+		const runId = `steer-no-session-${Date.now().toString(36)}`;
+		const asyncDir = path.join(ASYNC_DIR, runId);
+		writeStatus(asyncDir, runningStatus(runId));
+		writePrivateAtomicJson(path.join(asyncDir, "recovery-descriptor.json"), recoveryDescriptor(runId));
+		let recovered = false;
+		try {
+			const action = steerAsyncRun({
+				state: createState(), runId, message: "correct course", location: { asyncDir }, ackTimeoutMs: 25, recoveryTimeoutMs: 500, kill: () => true,
+				recover: async () => { recovered = true; return successResult("replacement"); },
+			});
+			const request = await readRequest(asyncDir);
+			const routed = runningStatus(runId);
+			projectRequest(routed, request, ["routed"]);
+			writeStatus(asyncDir, routed);
+			await waitUntil(() => fs.existsSync(interruptRequestPath(asyncDir)) ? true : undefined);
+			writeStatus(asyncDir, { ...routed, state: "paused", endedAt: Date.now(), steps: [{ ...routed.steps![0]!, status: "paused" }] });
+			const result = await action;
+			assert.equal(result.isError, true);
+			assert.equal(recovered, false);
+			assert.match(result.content[0]!.text, /no persisted child session|does not have a persisted session file/i);
+		} finally {
+			fs.rmSync(asyncDir, { recursive: true, force: true });
+		}
+	});
+
+	it("never auto-interrupts a nested single run", async () => {
+		const runId = `steer-nested-${Date.now().toString(36)}`;
+		const asyncDir = path.join(ASYNC_DIR, runId);
+		const initial = runningStatus(runId);
+		initial.isNested = true;
+		writeStatus(asyncDir, initial);
+		let interrupted = false;
+		let recovered = false;
+		try {
+			const action = steerAsyncRun({
+				state: createState(), runId, message: "correct course", location: { asyncDir }, ackTimeoutMs: 25,
+				kill: (_pid, signal) => { if (signal !== 0) interrupted = true; return true; },
+				recover: async () => { recovered = true; return successResult("replacement"); },
+			});
+			const request = await readRequest(asyncDir);
+			const routed = runningStatus(runId);
+			routed.isNested = true;
+			projectRequest(routed, request, ["routed"]);
+			writeStatus(asyncDir, routed);
+			const result = await action;
+			assert.equal(result.details.steering?.state, "pending");
+			assert.equal(interrupted, false);
+			assert.equal(recovered, false);
+			assert.equal(fs.existsSync(interruptRequestPath(asyncDir)), false);
+		} finally {
+			fs.rmSync(asyncDir, { recursive: true, force: true });
+		}
+	});
+
+	it("reports partial multi-child delivery without interrupting the run", async () => {
+		const runId = `steer-partial-${Date.now().toString(36)}`;
+		const asyncDir = path.join(ASYNC_DIR, runId);
+		writeStatus(asyncDir, runningStatus(runId, "parallel", 2));
+		let killed = false;
+		try {
+			const action = steerAsyncRun({ state: createState(), runId, message: "correct course", location: { asyncDir }, ackTimeoutMs: 500, kill: (_pid, signal) => { if (signal !== 0) killed = true; return true; } });
+			const request = await readRequest(asyncDir);
+			assert.deepEqual(request.targetIndexes, [0, 1]);
+			const status = runningStatus(runId, "parallel", 2);
+			projectRequest(status, request, ["delivered", "failed"]);
+			writeStatus(asyncDir, status);
+			const result = await action;
+			assert.equal(result.isError, true);
+			assert.equal(result.details.steering?.state, "partial");
+			assert.equal(killed, false);
+			assert.equal(fs.existsSync(interruptRequestPath(asyncDir)), false);
+		} finally {
+			fs.rmSync(asyncDir, { recursive: true, force: true });
+		}
+	});
+});

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

@@ -0,0 +1,58 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { handleSubagentSteeringNotice } from "../../src/extension/steering-notices.ts";
+import type { SubagentState } from "../../src/shared/types.ts";
+
+function state(sessionId: string): SubagentState {
+	return {
+		baseCwd: "",
+		currentSessionId: sessionId,
+		asyncJobs: new Map(),
+		foregroundRuns: new Map(),
+		foregroundControls: new Map(),
+		lastForegroundControlId: null,
+		pendingForegroundControlNotices: new Map(),
+		cleanupTimers: new Map(),
+		lastUiContext: null,
+		poller: null,
+		completionSeen: new Map(),
+		watcher: null,
+		watcherRestartTimer: null,
+		resultFileCoalescer: { schedule: () => false, clear: () => {} },
+	};
+}
+
+describe("steering notices", () => {
+	it("delivers a failure notice to the matching parent session", () => {
+		const messages: unknown[] = [];
+		handleSubagentSteeringNotice({
+			pi: { sendMessage: (message: unknown) => messages.push(message) } as any,
+			state: state("session-1"),
+			details: { runId: "run", requestId: "request", state: "failed", message: "not delivered", currentSessionId: "session-1" },
+		});
+		assert.equal(messages.length, 1);
+		assert.match(JSON.stringify(messages[0]), /not delivered/);
+	});
+
+	it("suppresses notices owned by another or missing parent session", () => {
+		const messages: unknown[] = [];
+		for (const currentSessionId of ["session-2", undefined]) {
+			handleSubagentSteeringNotice({
+				pi: { sendMessage: (message: unknown) => messages.push(message) } as any,
+				state: state("session-1"),
+				details: { runId: "run", requestId: "request", state: "partial", message: "partial", currentSessionId },
+			});
+		}
+		assert.deepEqual(messages, []);
+	});
+
+	it("delivers recovered outcomes without changing their state", () => {
+		const messages: Array<{ details?: { state?: string } }> = [];
+		handleSubagentSteeringNotice({
+			pi: { sendMessage: (message: { details?: { state?: string } }) => messages.push(message) } as any,
+			state: state("session-1"),
+			details: { runId: "run", requestId: "request", state: "recovered", message: "replacement launched", currentSessionId: "session-1" },
+		});
+		assert.equal(messages[0]?.details?.state, "recovered");
+	});
+});