@selesai/code 0.8.3 → 0.8.5

package/dist/extensions/pi-subagents/test/unit/skills-fallback.test.ts

@@ -80,6 +80,29 @@ describe("skills filesystem fallback", () => {
 		assert.equal(discovered?.description, "Test description");
 	});
 
+	it("reads block scalar descriptions for discovery and child injection", () => {
+		const cases = [
+			["|", "first line\nsecond line"],
+			["|-", "first line\nsecond line"],
+			[">", "first line second line"],
+			[">-", "first line second line"],
+		] as const;
+
+		for (const [index, [indicator]] of cases.entries()) {
+			makeProjectSkill(tempDir, `block-scalar-${index}`, "Use block scalar metadata.", `${indicator}\n  first line\n  second line`);
+		}
+
+		for (const [index, [, description]] of cases.entries()) {
+			const name = `block-scalar-${index}`;
+			const discovered = discoverAvailableSkills(tempDir).find((skill) => skill.name === name);
+			assert.equal(discovered?.description, description);
+
+			const { resolved, missing } = resolveSkills([name], tempDir);
+			assert.deepEqual(missing, []);
+			assert.match(buildSkillInjection(resolved), new RegExp(`<description>${description.replace("\n", "\\n")}</description>`));
+		}
+	});
+
 	it("discovers project skills nested below grouping directories", () => {
 		writeSkillFile(
 			path.join(tempDir, ".selesai", "skills", "shell", "issue-262-nested-skill"),
@@ -354,7 +377,6 @@ describe("skills filesystem fallback", () => {
 					...process.env,
 					HOME: fakeHome,
 					USERPROFILE: fakeHome,
-					APPDATA: path.join(fakeHome, "appdata"),
 					PATH: `${binDir}${path.delimiter}${process.env.PATH ?? ""}`,
 					PI_DISCOVERY_MARKER: marker,
 					PI_OFFLINE: "1",

package/dist/extensions/pi-subagents/test/unit/slash-bridge.test.ts

@@ -52,7 +52,7 @@ describe("slash subagent bridge requester context", () => {
     await done;
   });
 
-  it("rejects removed chain and parallel inputs before executor dispatch", async () => {
+  it("accepts direct execution inputs before executor dispatch", async () => {
     const events = eventBus();
     let executeCalls = 0;
     registerSlashSubagentBridge({
@@ -67,9 +67,36 @@ describe("slash subagent bridge requester context", () => {
     const done = new Promise<void>((resolve, reject) => {
       events.on(RESPONSE, (data: any) => {
         try {
-          assert.equal(data.isError, true);
-          assert.match(data.errorText, /removed.*workflowScript/i);
-          assert.equal(executeCalls, 0);
+          assert.equal(data.isError, false);
+          assert.equal(executeCalls, 1);
+          resolve();
+        } catch (error) {
+          reject(error);
+        }
+      });
+    });
+
+    events.emit(REQUEST, { requestId: "legacy-single", params: { agent: "worker", task: "work" } });
+    await done;
+  });
+
+  it("accepts chain and parallel inputs before executor dispatch", async () => {
+    const events = eventBus();
+    let executeCalls = 0;
+    registerSlashSubagentBridge({
+      events,
+      getContext: () => ({ cwd: "/repo" }) as any,
+      execute: async () => {
+        executeCalls++;
+        return { content: [{ type: "text", text: "unexpected" }], details: { mode: "single", results: [] } } as any;
+      },
+    });
+
+    const done = new Promise<void>((resolve, reject) => {
+      events.on(RESPONSE, (data: any) => {
+        try {
+          assert.equal(data.isError, false);
+          assert.equal(executeCalls, 1);
           resolve();
         } catch (error) {
           reject(error);
@@ -77,7 +104,7 @@ describe("slash subagent bridge requester context", () => {
       });
     });
 
-    events.emit(REQUEST, { requestId: "legacy-parallel", params: { tasks: [{ agent: "builder", task: "work" }] } });
+    events.emit(REQUEST, { requestId: "legacy-parallel", params: { tasks: [{ agent: "worker", task: "work" }] } });
     await done;
   });
 });

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

@@ -42,7 +42,7 @@ describe("async stale-run reconciliation", () => {
 				startedAt: 1000,
 				lastUpdate: 1000,
 				currentStep: 0,
-				steps: [{ agent: "explorer", status: "running", startedAt: 1000 }],
+				steps: [{ agent: "scout", status: "running", startedAt: 1000 }],
 			});
 
 			const result = reconcileAsyncRun(asyncDir, {
@@ -84,7 +84,7 @@ describe("async stale-run reconciliation", () => {
 				startedAt: 1000,
 				lastUpdate: 1000,
 				currentStep: 0,
-				steps: [{ agent: "explorer", status: "running", startedAt: 1000 }],
+				steps: [{ agent: "scout", status: "running", startedAt: 1000 }],
 			});
 			fs.writeFileSync(path.join(asyncDir, "runner.stderr.log"), "startup failed\nmissing peer package\n", "utf-8");
 
@@ -119,7 +119,7 @@ describe("async stale-run reconciliation", () => {
 				startedAt: 1000,
 				lastUpdate: 1000,
 				currentStep: 0,
-				steps: [{ agent: "builder", status: "running", startedAt: 1000 }],
+				steps: [{ agent: "worker", status: "running", startedAt: 1000 }],
 			});
 			fs.mkdirSync(path.join(asyncDir, "events.jsonl"));
 
@@ -153,19 +153,19 @@ describe("async stale-run reconciliation", () => {
 				startedAt: 1000,
 				lastUpdate: 1000,
 				steps: [
-					{ agent: "explorer", status: "running", startedAt: 1000, model: "planned-explorer", attemptedModels: ["planned-explorer"] },
-					{ agent: "builder", status: "running", startedAt: 1100, model: "planned-builder", attemptedModels: ["planned-builder"] },
+					{ 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, "explorer.jsonl");
-			const workerSession = path.join(root, "builder.jsonl");
+			const scoutSession = path.join(root, "scout.jsonl");
+			const workerSession = path.join(root, "worker.jsonl");
 			fs.writeFileSync(path.join(resultsDir, "run-mixed.json"), JSON.stringify({
 				id: "run-mixed",
 				success: false,
 				state: "failed",
 				results: [
-					{ agent: "explorer", success: true, sessionFile: scoutSession, model: "fast", attemptedModels: ["planned-explorer", "fast"] },
-					{ agent: "builder", success: false, error: "boom", sessionFile: workerSession, model: "careful", attemptedModels: ["planned-builder", "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,13 +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-explorer", "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-builder", "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 });
@@ -205,7 +205,7 @@ describe("async stale-run reconciliation", () => {
 				pid: 12345,
 				startedAt: 1000,
 				lastUpdate: 1000,
-				steps: [{ agent: "builder", status: "running", startedAt: 1000 }],
+				steps: [{ agent: "worker", status: "running", startedAt: 1000 }],
 			});
 
 			const result = reconcileAsyncRun(asyncDir, {
@@ -236,7 +236,7 @@ describe("async stale-run reconciliation", () => {
 				pid: 12345,
 				startedAt: 1000,
 				lastUpdate: 1000,
-				steps: [{ agent: "builder", status: "running", startedAt: 1000 }],
+				steps: [{ agent: "worker", status: "running", startedAt: 1000 }],
 			});
 			const resultPath = path.join(resultsDir, "run-result.json");
 			fs.writeFileSync(resultPath, JSON.stringify({ id: "run-result", success: true, state: "complete", summary: "already done" }, null, 2), "utf-8");

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 {
@@ -28,9 +29,25 @@ 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 });
-	writeAtomicJson(path.join(asyncDir, "status.json"), status);
+	const statusPath = path.join(asyncDir, "status.json");
+	writeAtomicJson(statusPath, status);
+	// readStatus is metadata-cached. Keep fast test rewrites monotonic.
+	statusWriteMtimeMs = Math.max(statusWriteMtimeMs + 1, Date.now());
+	const mtime = new Date(statusWriteMtimeMs);
+	fs.utimesSync(statusPath, mtime, mtime);
+}
+
+function removeAsyncDir(asyncDir: string): void {
+	fs.rmSync(asyncDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 10 });
 }
 
 function runningStatus(runId: string, mode: AsyncStatus["mode"] = "single", count = 1): AsyncStatus {
@@ -43,7 +60,7 @@ function runningStatus(runId: string, mode: AsyncStatus["mode"] = "single", coun
 		cwd: os.tmpdir(),
 		startedAt: Date.now(),
 		lastUpdate: Date.now(),
-		steps: Array.from({ length: count }, (_, index) => ({ agent: `builder-${index}`, status: "running" as const, startedAt: Date.now() })),
+		steps: Array.from({ length: count }, (_, index) => ({ agent: `worker-${index}`, status: "running" as const, startedAt: Date.now() })),
 		steering: createSteeringStatus(),
 	};
 }
@@ -80,10 +97,13 @@ 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: "builder-0",
+		agent: "worker-0",
 		cwd: os.tmpdir(),
 		systemPromptMode: "replace",
 		inheritProjectContext: false,
@@ -120,7 +140,7 @@ describe("acknowledged steering action", () => {
 			assert.equal(result.details.steering?.state, "delivered");
 			assert.match(result.content[0]!.text, /Steering delivered/);
 		} finally {
-			fs.rmSync(asyncDir, { recursive: true, force: true });
+			removeAsyncDir(asyncDir);
 		}
 	});
 
@@ -134,7 +154,35 @@ describe("acknowledged steering action", () => {
 			assert.equal(result.isError, true);
 			assert.match(result.content[0]!.text, /no longer accepts steering requests/);
 		} finally {
-			fs.rmSync(asyncDir, { recursive: true, force: true });
+			removeAsyncDir(asyncDir);
+		}
+	});
+
+	it("queues follow-up as the next revival brief for a completed retained child", async () => {
+		const runId = `steer-retained-${Date.now().toString(36)}`;
+		const asyncDir = path.join(ASYNC_DIR, runId);
+		const sessionFile = path.join(asyncDir, "child.jsonl");
+		fs.mkdirSync(asyncDir, { recursive: true });
+		fs.writeFileSync(sessionFile, "", "utf-8");
+		writeStatus(asyncDir, {
+			...runningStatus(runId),
+			state: "complete",
+			parentWorkflowRunId: "workflow",
+			endedAt: Date.now(),
+			sessionFile,
+			steps: [{ agent: "worker-0", status: "complete", sessionFile }],
+		});
+		try {
+			const result = await steerAsyncRun({ state: createState(), runId, message: "Review the docs", mode: "follow_up", location: { asyncDir } });
+			assert.equal(result.isError, undefined);
+			assert.equal(result.details.steering?.deliveryStatus, "queued");
+			assert.match(result.content[0]!.text, /next resume/);
+			const queueDir = path.join(asyncDir, "control", "revival-briefs");
+			const queued = JSON.parse(fs.readFileSync(path.join(queueDir, fs.readdirSync(queueDir)[0]!), "utf-8")) as SteerRequest;
+			assert.equal(queued.message, "Review the docs");
+			assert.equal(queued.mode, "follow_up");
+		} finally {
+			removeAsyncDir(asyncDir);
 		}
 	});
 
@@ -157,7 +205,7 @@ describe("acknowledged steering action", () => {
 			assert.equal(recovered, false);
 			assert.equal(fs.existsSync(path.join(asyncDir, "control", "steer-recovery")), false);
 		} finally {
-			fs.rmSync(asyncDir, { recursive: true, force: true });
+			removeAsyncDir(asyncDir);
 		}
 	});
 
@@ -168,70 +216,30 @@ describe("acknowledged steering action", () => {
 		let request: SteerRequest | undefined;
 		let interrupted = false;
 		let recovered = false;
+		let attemptedRecovery = 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);
+					updateSteeringTarget(acknowledged.steering!, request.id, 0, "delivered", Date.now());
+					updateSteeringTarget(acknowledged.steps![0]!.steering!, request.id, 0, "delivered", Date.now());
 					writeStatus(asyncDir, acknowledged);
 				},
+				onBeforeRecoveryClaim: () => { attemptedRecovery = true; },
 				recover: async () => { recovered = true; return successResult("replacement"); },
 			});
 			assert.equal(result.details.steering?.state, "delivered");
 			assert.equal(interrupted, false);
 			assert.equal(recovered, false);
+			assert.equal(attemptedRecovery, 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 });
+			removeAsyncDir(asyncDir);
 		}
 	});
 
@@ -239,22 +247,31 @@ describe("acknowledged steering action", () => {
 		const runId = `steer-pause-unconfirmed-${Date.now().toString(36)}`;
 		const asyncDir = path.join(ASYNC_DIR, runId);
 		writeStatus(asyncDir, runningStatus(runId));
+		const kills: Array<{ pid: number; signal?: NodeJS.Signals | 0 }> = [];
+		let claimed = false;
 		try {
 			const action = steerAsyncRun({
 				state: createState(), runId, message: "correct course", location: { asyncDir },
-				ackTimeoutMs: 25, recoveryTimeoutMs: 50, kill: () => true,
+				ackTimeoutMs: 25,
+				recoveryTimeoutMs: 50,
+				kill: (pid, signal) => { kills.push({ pid, signal }); return true; },
+				onRequestQueued: (requestPath) => {
+					const request = JSON.parse(fs.readFileSync(requestPath, "utf-8")) as SteerRequest;
+					const routed = runningStatus(runId);
+					projectRequest(routed, request, ["routed"]);
+					writeStatus(asyncDir, routed);
+				},
+				onRecoveryCommitted: () => { claimed = 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.equal(claimed, true);
 			assert.match(result.content[0]!.text, /claim remains committed to prevent a delayed duplicate/);
+			assert.equal(fs.existsSync(interruptRequestPath(asyncDir)), true);
+			assert.deepEqual(kills, [{ pid: 12345, signal: 0 }]);
 			assert.equal(fs.existsSync(path.join(asyncDir, "control", "steer-recovery", "claim.json")), true);
 		} finally {
-			fs.rmSync(asyncDir, { recursive: true, force: true });
+			removeAsyncDir(asyncDir);
 		}
 	});
 
@@ -269,34 +286,47 @@ describe("acknowledged steering action", () => {
 		if (process.platform !== "win32") assert.equal(fs.statSync(descriptorPath).mode & 0o777, 0o600);
 		let receivedLimits: unknown;
 		let recoveryStarted = false;
+		let recoveryCommitted = false;
+		let request: SteerRequest | undefined;
+		let routed: AsyncStatus | undefined;
 		try {
 			const action = steerAsyncRun({
 				state: createState(),
 				runId,
 				message: "correct course",
 				location: { asyncDir },
-				ackTimeoutMs: 25,
-				recoveryTimeoutMs: 500,
+				ackTimeoutMs: 250,
+				recoveryTimeoutMs: 1_000,
 				kill: () => true,
-				recover: async (limits) => { recoveryStarted = true; receivedLimits = limits; return successResult("replacement"); },
+				onRequestQueued: (requestPath) => {
+					request = JSON.parse(fs.readFileSync(requestPath, "utf-8")) as SteerRequest;
+					routed = runningStatus(runId);
+					projectRequest(routed, request, ["routed"]);
+					writeStatus(asyncDir, routed);
+				},
+				onRecoveryCommitted: () => {
+					recoveryCommitted = true;
+					assert.ok(request);
+					assert.ok(routed);
+					writeSteerAck(asyncDir, { requestId: request.id, index: 0, ts: Date.now(), state: "delivered", message: "accepted after runner pause" });
+					writeStatus(asyncDir, {
+						...routed,
+						state: "paused",
+						endedAt: Date.now(),
+						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 }],
+					});
+				},
+				recover: async (limits) => {
+					recoveryStarted = true;
+					const paused = JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8")) as AsyncStatus;
+					assert.equal(paused.state, "paused");
+					assert.equal(typeof paused.endedAt, "number");
+					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");
@@ -314,33 +344,41 @@ describe("acknowledged steering action", () => {
 			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 });
+			removeAsyncDir(asyncDir);
 		}
 	});
 
-	it("leaves an unacknowledged single run paused when no session can be revived", async () => {
+	it("leaves a 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;
+		let recoveryCommitted = false;
+		let routed: AsyncStatus | undefined;
 		try {
 			const action = steerAsyncRun({
-				state: createState(), runId, message: "correct course", location: { asyncDir }, ackTimeoutMs: 25, recoveryTimeoutMs: 500, kill: () => true,
+				state: createState(), runId, message: "correct course", location: { asyncDir }, ackTimeoutMs: 250, recoveryTimeoutMs: 1_000, kill: () => true,
+				onRequestQueued: (requestPath) => {
+					const request = JSON.parse(fs.readFileSync(requestPath, "utf-8")) as SteerRequest;
+					routed = runningStatus(runId);
+					projectRequest(routed, request, ["failed"]);
+					writeStatus(asyncDir, routed);
+				},
+				onRecoveryCommitted: () => {
+					recoveryCommitted = true;
+					if (routed) writeStatus(asyncDir, { ...routed, state: "paused", endedAt: Date.now(), steps: [{ ...routed.steps![0]!, status: "paused" }] });
+				},
 				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.ok(recoveryCommitted);
+			assert.ok(routed);
 			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 });
+			removeAsyncDir(asyncDir);
 		}
 	});
 
@@ -369,7 +407,7 @@ describe("acknowledged steering action", () => {
 			assert.equal(recovered, false);
 			assert.equal(fs.existsSync(interruptRequestPath(asyncDir)), false);
 		} finally {
-			fs.rmSync(asyncDir, { recursive: true, force: true });
+			removeAsyncDir(asyncDir);
 		}
 	});
 
@@ -391,7 +429,7 @@ describe("acknowledged steering action", () => {
 			assert.equal(killed, false);
 			assert.equal(fs.existsSync(interruptRequestPath(asyncDir)), false);
 		} finally {
-			fs.rmSync(asyncDir, { recursive: true, force: true });
+			removeAsyncDir(asyncDir);
 		}
 	});
 });

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

@@ -116,7 +116,7 @@ describe("steering lifecycle ledger", () => {
 
 	it("reconstructs the original agent contract without leaking changed current fields", () => {
 		const current = {
-			name: "builder",
+			name: "worker",
 			description: "current",
 			model: "current/model",
 			fallbackModels: ["current/fallback"],
@@ -141,7 +141,7 @@ describe("steering lifecycle ledger", () => {
 		const recovered = applySteeringRecoveryAgentConfig(current, {
 			version: 1,
 			sourceRunId: "source",
-			agent: "builder",
+			agent: "worker",
 			cwd: "/original",
 			model: "original/model",
 			tools: ["read"],

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

@@ -0,0 +1,85 @@
+import assert from "node:assert/strict";
+import * as os from "node:os";
+import { describe, it } from "node:test";
+import { createSubagentExecutor, unknownSubagentActionMessage } from "../../src/runs/foreground/subagent-executor.ts";
+import type { SubagentState } from "../../src/shared/types.ts";
+
+function createState(): SubagentState {
+	return {
+		baseCwd: "",
+		currentSessionId: null,
+		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 createExecutor() {
+	return createSubagentExecutor({
+		pi: { events: { emit() {}, on() { return () => {}; } }, getSessionName() { return "parent"; } } as any,
+		state: createState(),
+		config: { maxSubagentDepth: 2, control: {}, intercomBridge: {} } as any,
+		asyncByDefault: false,
+		tempArtifactsDir: os.tmpdir(),
+		getSubagentSessionRoot: () => os.tmpdir(),
+		expandTilde: (value) => value,
+		discoverAgents: () => ({ agents: [] }),
+	});
+}
+
+function ctx() {
+	return {
+		cwd: os.tmpdir(),
+		hasUI: false,
+		sessionManager: { getSessionId() { return "session"; }, getSessionFile() { return null; } },
+		modelRegistry: { getAvailable() { return []; } },
+	} as any;
+}
+
+describe("subagent action recovery", () => {
+	it("suggests a benign typo with safe next steps", () => {
+		const message = unknownSubagentActionMessage("statsu");
+
+		assert.match(message, /Unknown action: statsu\. Did you mean status\?/);
+		assert.match(message, /Use subagent\(\{ action: "status" \}\)/);
+		assert.match(message, /Valid: .*status/);
+	});
+
+	it("does not suggest a destructive near-miss", () => {
+		const message = unknownSubagentActionMessage("del");
+
+		assert.match(message, /Unknown action: del\./);
+		assert.doesNotMatch(message, /Did you mean delete\?/);
+		assert.match(message, /Valid: .*delete/);
+	});
+
+	it("returns a concise recovery error for an invalid action", async () => {
+		const result = await createExecutor().execute("invalid-action", { action: "statsu" }, new AbortController().signal, undefined, ctx());
+		assert.equal(result.isError, true);
+		assert.equal(result.content[0]?.type, "text");
+		assert.equal(result.content[0]?.text, unknownSubagentActionMessage("statsu"));
+	});
+
+	it("routes invalid schedule actions through common recovery", async () => {
+		const result = await createExecutor().execute("invalid-schedule-action", { action: "schedule.lsit" }, new AbortController().signal, undefined, ctx());
+		assert.equal(result.isError, true);
+		assert.equal(result.content[0]?.type, "text");
+		assert.equal(result.content[0]?.text, unknownSubagentActionMessage("schedule.lsit"));
+	});
+
+	it("lists and suggests mission decision resolution", () => {
+		const message = unknownSubagentActionMessage("mission.resolve-decison");
+
+		assert.match(message, /Did you mean mission\.resolve-decision\?/);
+		assert.match(message, /Valid: .*mission\.resolve-decision/);
+	});
+});