@selesai/code 0.13.15 → 0.13.18

package/dist/extensions/pi-subagents/test/integration/slash-commands.test.ts

@@ -9,7 +9,6 @@ import { registerAgent } from "../../src/api/agents.ts";
 import { clearRuntimeAgentsForPi } from "../../src/agents/runtime-agent-registry.ts";
 import { scheduledRunStorePath } from "../../src/runs/background/scheduled-runs.ts";
 import { updateActiveRunIndex } from "../../src/runs/background/active-run-index.ts";
-import { SUBAGENT_FANOUT_CHILD_ENV } from "../../src/runs/shared/pi-args.ts";
 import { getArtifactPaths, getArtifactsDir } from "../../src/shared/artifacts.ts";
 import { ASYNC_DIR, DIRS } from "../../src/shared/types.ts";
 import type { WatchdogReviewFunction } from "../../src/watchdog/runtime.ts";
@@ -1514,4 +1513,4 @@ describe("subagents-inspect-rpc command", { skip: !available ? "slash-commands.t
 		assert.equal(widgetCalls.length, 0);
 		assert.match(notifications[0] ?? "", /RPC surfaces/);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/integration/workflow-result-publication.test.ts

@@ -0,0 +1,127 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import { syncBuiltinESMExports } from "node:module";
+import { describe, it } from "node:test";
+import { createResultWatcher } from "../../src/runs/background/result-watcher.ts";
+import registerSubagentNotify from "../../src/runs/background/notify.ts";
+import { SUBAGENT_ASYNC_COMPLETE_EVENT, type SubagentState } from "../../src/shared/types.ts";
+import { makeMinimalCtx } from "../support/helpers.ts";
+import { installAsyncExecutionHooks, available, createSubagentExecutor, ASYNC_DIR, RESULTS_DIR, tempDir } from "../support/async-execution-fixture.ts";
+
+function barrier() {
+	let resolve!: () => void;
+	const promise = new Promise<void>((done) => { resolve = done; });
+	return { promise, resolve };
+}
+async function bounded(promise: Promise<unknown>) {
+	let timer: ReturnType<typeof setTimeout>;
+	try { await Promise.race([promise, new Promise((_, reject) => { timer = setTimeout(() => reject(new Error("publication barrier timed out")), 12000); })]); }
+	finally { clearTimeout(timer!); }
+}
+
+describe("host workflow result publication", { skip: !available }, () => {
+	installAsyncExecutionHooks();
+	for (const outcome of ["complete", "failed", "stopped", "retry-error"] as const) {
+	it(`retains real Darwin demand until deferred indexed workflow publication settles (${outcome})`, async () => {
+		const polled = barrier(), published = barrier(), delivered = barrier(), retired = barrier(), failed = barrier(), emitted = barrier();
+		let held = true, attempted = false, notifications = 0, refreshes = 0;
+		let statusWrites = 0, statusDeferred = false, statusRecovered = false;
+		let poll: ReturnType<typeof setInterval> | undefined;
+		const sessionId = "workflow-publication-session", owner = "workflow-publication-owner";
+		const state: SubagentState = { baseCwd: tempDir, currentSessionId: sessionId, completionOwnerId: owner,
+			asyncJobs: new Map(), foregroundControls: new Map(), lastForegroundControlId: null,
+			cleanupTimers: new Map(), lastUiContext: null, poller: null, completionSeen: new Map(),
+			watcher: null, watcherRestartTimer: null, resultFileCoalescer: { schedule: () => false, clear() {} },
+		};
+		const pi = { getSessionName: () => undefined, events: { on: () => () => {}, emit(event: string, data: unknown) {
+			if (event === SUBAGENT_ASYNC_COMPLETE_EVENT) { assert.equal((data as { completionOwnerId: string }).completionOwnerId, owner); delivered.resolve(); }
+		} }, sendMessage() { notifications++; } };
+		const notifier = registerSubagentNotify(pi, state, { batchConfig: { enabled: false } });
+		const watcher = createResultWatcher(pi, state, RESULTS_DIR, 60000, { platform: "darwin", coalesceDelayMs: 0, notifier,
+			hasDeliveryDemand: () => [...state.asyncJobs.values()].some((job) => job.status === "running" || job.status === "queued"),
+			timers: { setTimeout, clearTimeout, setInterval: ((handler: () => void, delay: number) => {
+				assert.equal(delay, 3000);
+				poll = setInterval(() => { handler(); if (attempted) polled.resolve(); }, delay); return poll;
+			}) as typeof setInterval, clearInterval: ((handle: ReturnType<typeof setInterval>) => { clearInterval(handle); poll = undefined; retired.resolve(); }) as typeof clearInterval },
+		});
+		const originalWrite = fs.writeFileSync, originalRename = fs.renameSync, originalAppend = fs.appendFileSync;
+		fs.writeFileSync = ((file, ...args) => {
+			if (String(file).includes(`${path.sep}result-pending${path.sep}`)) {
+				attempted = true;
+				if (held) throw Object.assign(new Error("injected workflow capacity failure"), { code: "ENOSPC" });
+				if (outcome === "retry-error") throw Object.assign(new Error("injected workflow retry EIO"), { code: "EIO" });
+			}
+			return originalWrite(file, ...args);
+		}) as typeof fs.writeFileSync;
+		fs.renameSync = ((from, to) => {
+			if (path.basename(String(to)) === "status.json") {
+				if (++statusWrites > 1 && !attempted) { statusDeferred = true; throw Object.assign(new Error("injected running status capacity failure"), { code: "ENOSPC" }); }
+				if (statusDeferred && held && attempted) statusRecovered = true;
+			}
+			originalRename(from, to); if (path.dirname(String(to)) === RESULTS_DIR) published.resolve();
+		}) as typeof fs.renameSync;
+		fs.appendFileSync = ((file, data, ...args) => {
+			originalAppend(file, data, ...args);
+			if (String(data).includes('"type":"subagent.workflow.result_write_failed"')) failed.resolve();
+			if (String(data).includes('"type":"subagent.workflow.emit"')) emitted.resolve();
+		}) as typeof fs.appendFileSync;
+		syncBuiltinESMExports();
+		try {
+			const executor = createSubagentExecutor!({ pi, state, config: {}, asyncByDefault: false, tempArtifactsDir: tempDir,
+				getSubagentSessionRoot: () => tempDir, expandTilde: (p: string) => p, discoverAgents: () => ({ agents: [] }),
+				refreshResultDelivery: () => { refreshes++; watcher.refreshResultDelivery(); },
+			});
+			const ctx = makeMinimalCtx(tempDir); ctx.sessionManager.getSessionId = () => sessionId;
+			const script = outcome === "stopped" ? "await new Promise(() => {})" : outcome === "failed" ? "throw new Error('workflow script failed')" : "return 'done'";
+			const launch = await executor.execute("workflow-publication", { workflowScript: `emit('progress'); ${script}`, async: true }, new AbortController().signal, undefined, ctx);
+			assert.notEqual(launch.isError, true);
+			const id = launch.details.asyncId!;
+			watcher.startResultWatcher();
+			if (outcome === "stopped") {
+				await bounded(emitted.promise);
+				const stop = await executor.execute("workflow-stop", { action: "stop", id }, new AbortController().signal, undefined, ctx);
+				assert.notEqual(stop.isError, true);
+				assert.match(stop.content[0]?.text ?? "", /Stop requested/);
+				assert.equal(state.workflowControllers?.get(id)?.signal.aborted, true);
+			}
+			await bounded(polled.promise);
+			const status = JSON.parse(fs.readFileSync(path.join(ASYNC_DIR, id, "status.json"), "utf8"));
+			assert.equal(status.state, "running", "terminal status must not precede indexed workflow result publication");
+			assert.equal(state.asyncJobs.get(id)?.status, "running");
+			assert.equal(statusDeferred, true); assert.equal(statusRecovered, true);
+			assert.equal(fs.existsSync(path.join(ASYNC_DIR, ".active-runs", id)), true);
+			assert.ok(poll); assert.equal(notifications, 0); assert.equal(refreshes, 0);
+			held = false;
+			if (outcome === "retry-error") {
+				await bounded(failed.promise);
+				// Allow the awaited failure callback to finish its existing cleanup.
+				await new Promise<void>((resolve) => setImmediate(resolve));
+				assert.equal(state.workflowControllers?.has(id), false);
+				assert.equal(state.asyncJobs.get(id)?.status, "running");
+				assert.equal(notifications, 0); assert.equal(refreshes, 0);
+				assert.match(fs.readFileSync(path.join(ASYNC_DIR, id, "events.jsonl"), "utf8"), /injected workflow retry EIO/);
+				assert.equal(fs.existsSync(path.join(RESULTS_DIR, `${id}.json`)), false);
+				return;
+			}
+			await bounded(Promise.all([published.promise, delivered.promise]));
+			assert.equal(state.asyncJobs.get(id)?.status, outcome);
+			const terminalStatus = JSON.parse(fs.readFileSync(path.join(ASYNC_DIR, id, "status.json"), "utf8"));
+			assert.equal(terminalStatus.state, outcome);
+			if (outcome === "stopped") assert.equal(terminalStatus.stopped, true);
+			assert.equal(notifications, 1); assert.equal(refreshes, 1);
+			assert.equal(fs.existsSync(path.join(RESULTS_DIR, `${id}.json`)), false);
+			// The existing demand timer retires itself after terminal publication.
+			await bounded(retired.promise);
+			assert.equal(poll, undefined);
+		} finally {
+			held = false;
+			try { await bounded(outcome === "retry-error" ? failed.promise : published.promise); }
+			finally {
+				watcher.stopResultWatcher(); notifier.dispose();
+				fs.writeFileSync = originalWrite; fs.renameSync = originalRename; fs.appendFileSync = originalAppend; syncBuiltinESMExports();
+			}
+		}
+	});
+	}
+});

package/dist/extensions/pi-subagents/test/integration/workflow-steer-inbox.test.ts

@@ -0,0 +1,365 @@
+/**
+ * Integration tests for the durable steer inbox of async WORKFLOW runs.
+ *
+ * `watchAsyncControlInbox` is installed only by subagent-runner.ts, and the runner never executes
+ * workflow scripts, so before this fix no process consumed `control/steer-requests/` for a
+ * workflow run: a queued request file sat on disk until the run ended and the requester's
+ * "delivered" receipt was never backed by a delivery.
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { events, makeAgent, makeMinimalCtx } from "../support/helpers.ts";
+import { requestAsyncSteer, steerInboxClosedPath, steerRequestsDir } from "../../src/runs/background/control-channel.ts";
+import type { AsyncStatusPayload } from "../support/async-execution-fixture.ts";
+import type { SteeringStatus } from "../../src/shared/types.ts";
+import {
+	installAsyncExecutionHooks, available, isAsyncAvailable, ASYNC_DIR,
+	createSubagentExecutor, waitForMockPiCall, waitForAsyncState, tempDir, mockPi,
+	makeAsyncExecutor, readAsyncPayload, RESULTS_DIR, waitForAsyncEvent,
+} from "../support/async-execution-fixture.ts";
+
+type SteeringTargets = { steering?: { recent: Array<{ id: string; targets: Array<{ index: number; state: string; reason?: string }> }> } };
+
+function recentSteering(status: AsyncStatusPayload, requestId: string): { index: number; state: string; reason?: string } | undefined {
+	return (status as SteeringTargets).steering?.recent?.find((request) => request.id === requestId)?.targets[0];
+}
+
+describe("async workflow steer inbox", { skip: !available ? "pi packages not available" : undefined }, () => {
+	installAsyncExecutionHooks();
+
+	for (const outcome of ["complete", "failed", "stopped"]) it(`settles steering without terminal status when result index publication fails (${outcome})`, { skip: !isAsyncAvailable() || !createSubagentExecutor ? "jiti or executor not available" : undefined }, async () => {
+		const release = path.join(tempDir, "index-failure-release");
+		const indexPath = path.join(RESULTS_DIR, "result-index");
+		mockPi.onCall({ steps: [{ waitForPath: release, jsonl: [events.assistantMessage("done")] }] });
+		const ctx = makeMinimalCtx(tempDir);
+		ctx.sessionManager.getSessionId = () => "session-index-steering";
+		const executor = makeAsyncExecutor([makeAgent("worker", { completionGuard: false })]);
+		const launch = await executor.execute("index-steering", {
+			workflowScript: `await runs.run("A", { agent: "worker", task: "Wait" }); ${outcome === "failed" ? 'throw new Error("script failed")' : 'return "done"'}`,
+			async: true,
+		}, new AbortController().signal, undefined, ctx);
+		assert.equal(launch.isError, undefined);
+		const runId = launch.details!.asyncId as string;
+		const asyncDir = path.join(ASYNC_DIR, runId);
+		await waitForMockPiCall(mockPi, 0, 10_000);
+		const session = mockPi.sessions[0]!.session!;
+		const originalSteer = session.steer;
+		let entered = false;
+		let releaseSteer!: () => void;
+		const blocked = new Promise<void>((resolve) => { releaseSteer = resolve; });
+		session.steer = async () => { entered = true; await blocked; };
+		try {
+			requestAsyncSteer(asyncDir, { id: "queued", message: "later", mode: "follow_up" });
+			requestAsyncSteer(asyncDir, { id: "unresolved", message: "pending" });
+			await waitForAsyncState(runId, (candidate) => entered && recentSteering(candidate, "queued")?.state === "queued" && recentSteering(candidate, "unresolved")?.state === "routed", 15_000);
+			fs.rmSync(indexPath, { recursive: true, force: true });
+			fs.mkdirSync(RESULTS_DIR, { recursive: true });
+			fs.writeFileSync(indexPath, "not a directory");
+			if (outcome === "stopped") {
+				const stop = await executor.execute("stop-index-steering", { action: "stop", id: runId }, new AbortController().signal, undefined, ctx);
+				assert.notEqual(stop.isError, true);
+			} else fs.writeFileSync(release, "go");
+			await waitForAsyncEvent(runId, "subagent.workflow.result_write_failed");
+			const before = fs.readFileSync(path.join(asyncDir, "status.json"), "utf8");
+			const status = JSON.parse(before) as { state: string; endedAt?: number; activityState?: string; steering: SteeringStatus };
+			assert.equal(status.state, "running", "failed index publication cannot authorize terminal status");
+			assert.equal(status.endedAt, undefined);
+			assert.equal(status.activityState, "needs_attention");
+			assert.equal(status.steering.pending, 0);
+			assert.equal(status.steering.failed, 2);
+			assert.equal(status.steering.delivered, 0);
+			assert.ok(status.steering.recent.every((request) => request.targets[0]?.state === "failed" && request.targets[0].reason === `run became ${outcome} before steering delivery settled; delivery unconfirmed`));
+			assert.equal(fs.existsSync(path.join(ASYNC_DIR, ".active-runs", runId)), true);
+			assert.equal(fs.existsSync(path.join(RESULTS_DIR, `${runId}.json`)), false);
+			assert.equal(fs.existsSync(path.join(RESULTS_DIR, "result-pending", "session-index-steering", `${runId}.json`)), true);
+			const unpublished = JSON.parse(fs.readFileSync(path.join(RESULTS_DIR, "result-pending", "session-index-steering", `${runId}.json`), "utf8"));
+			assert.equal(unpublished.state, outcome, "computed outcome is retained only in unpublished result");
+			if (outcome !== "complete") assert.equal(unpublished.activityState, "needs_attention", "failure finalization preserves steering attention");
+			assert.equal(fs.existsSync(steerInboxClosedPath(asyncDir)), true);
+			const journal = fs.readFileSync(path.join(asyncDir, "events.jsonl"), "utf8");
+			assert.equal(journal.split("\n").filter((line) => line.includes('"type":"subagent.steer.failed"')).length, 2);
+			assert.doesNotMatch(journal, /"type":"subagent.workflow.completed"/);
+			releaseSteer();
+			await new Promise((resolve) => setTimeout(resolve, 350));
+			assert.equal(fs.readFileSync(path.join(asyncDir, "status.json"), "utf8"), before);
+			assert.equal(fs.readFileSync(path.join(asyncDir, "events.jsonl"), "utf8"), journal);
+		} finally {
+			session.steer = originalSteer;
+			releaseSteer();
+			fs.writeFileSync(release, "go");
+			fs.rmSync(indexPath, { recursive: true, force: true });
+		}
+	});
+
+	for (const shutdown of [false, true]) it(`accounts for 21 same-scan requests beyond display history (${shutdown ? "shutdown" : "delivered"})`, { skip: !isAsyncAvailable() || !createSubagentExecutor ? "jiti or executor not available" : undefined }, async () => {
+		const release = path.join(tempDir, "batch-accounting-release");
+		mockPi.onCall({ steps: [{ waitForPath: release, jsonl: [events.assistantMessage("done")] }] });
+		const ctx = makeMinimalCtx(tempDir);
+		ctx.sessionManager.getSessionId = () => "session-batch-accounting";
+		const executor = makeAsyncExecutor([makeAgent("worker", { completionGuard: false })]);
+		const launch = await executor.execute("batch-accounting", { workflowScript: `return await runs.run("A", { agent: "worker", task: "Wait" });`, async: true }, new AbortController().signal, undefined, ctx);
+		assert.equal(launch.isError, undefined);
+		const runId = launch.details!.asyncId as string;
+		const asyncDir = path.join(ASYNC_DIR, runId);
+		await waitForMockPiCall(mockPi, 0, 10_000);
+		const session = mockPi.sessions[0]!.session!;
+		const originalSteer = session.steer.bind(session);
+		const originalFollowUp = session.followUp.bind(session);
+		let releaseSteers!: () => void;
+		const blocked = new Promise<void>((resolve) => { releaseSteers = resolve; });
+		let calls = 0;
+		session.followUp = async (text) => {
+			calls++;
+			assert.deepEqual(fs.readdirSync(steerRequestsDir(asyncDir)), []);
+			await originalFollowUp(text);
+		};
+		session.steer = async (text) => {
+			calls++;
+			assert.deepEqual(fs.readdirSync(steerRequestsDir(asyncDir)), [], "entire batch consumed before first delivery callback");
+			if (shutdown) await blocked;
+			else await originalSteer(text);
+		};
+		const accounting = (candidate: AsyncStatusPayload) => (candidate as { steering?: SteeringStatus }).steering;
+		try {
+			for (let index = 0; index < 21; index++) requestAsyncSteer(asyncDir, { id: `batch-${index}`, message: `batch-${index}`, targetIndex: 0, ts: index + 1, ...(shutdown && (index === 0 || index === 20) ? { mode: "follow_up" as const } : {}) });
+			const active = await waitForAsyncState(runId, (candidate) => calls === 21 && accounting(candidate)?.recent.every((request) => request.targets[0]?.state === (shutdown ? request.id === "batch-20" ? "queued" : "routed" : "delivered")) === true, 15_000);
+			assert.equal(accounting(active)!.requested, 21);
+			assert.equal(accounting(active)!.pending, shutdown ? 21 : 0, "queued acknowledgments still count once as pending");
+			if (shutdown) {
+				const queuedEvents = fs.readFileSync(path.join(asyncDir, "events.jsonl"), "utf8").trim().split("\n").map((line) => JSON.parse(line)).filter((event) => event.type === "subagent.steer.queued");
+				assert.deepEqual(queuedEvents.map((event) => event.requestId), ["batch-0", "batch-20"], "both evicted and retained queued receipts remain pending");
+			}
+			assert.equal(accounting(active)!.recent.length, 20);
+			assert.equal(accounting(active)!.recent.some((request) => request.id === "batch-0"), false, "first unresolved receipt was evicted");
+			fs.writeFileSync(release, "go");
+			const terminal = await waitForAsyncState(runId, (candidate) => candidate.state === "complete", 15_000);
+			const counters = accounting(terminal)!;
+			assert.equal(counters.pending, 0);
+			assert.equal(counters.delivered, shutdown ? 0 : 21);
+			assert.equal(counters.failed, shutdown ? 21 : 0);
+			assert.equal(counters.recent.length, 20, "history cap must not grow");
+			if (shutdown) assert.ok(counters.recent.every((request) => request.targets[0]?.state === "failed" && request.targets[0].reason?.includes("delivery unconfirmed")));
+			const before = fs.readFileSync(path.join(asyncDir, "status.json"), "utf8");
+			const journal = fs.readFileSync(path.join(asyncDir, "events.jsonl"), "utf8");
+			const terminalEvents = journal.trim().split("\n").map((line) => JSON.parse(line)).filter((event) => event.requestId?.startsWith("batch-") && event.type === `subagent.steer.${shutdown ? "failed" : "delivered"}`);
+			assert.equal(terminalEvents.length, counters.delivered + counters.failed);
+			assert.equal(new Set(terminalEvents.map((event) => event.requestId)).size, 21, "every request has exactly one terminal event");
+			releaseSteers();
+			await new Promise((resolve) => setTimeout(resolve, 350));
+			assert.equal(fs.readFileSync(path.join(asyncDir, "status.json"), "utf8"), before);
+			assert.equal(fs.readFileSync(path.join(asyncDir, "events.jsonl"), "utf8"), journal);
+		} finally {
+			session.steer = originalSteer;
+			session.followUp = originalFollowUp;
+			releaseSteers();
+			fs.writeFileSync(release, "go");
+		}
+	});
+
+	for (const stop of [false, true]) it(`settles consumed pending deliveries before ${stop ? "stop" : "completion"} and ignores late callbacks`, { skip: !isAsyncAvailable() || !createSubagentExecutor ? "jiti or executor not available" : undefined }, async () => {
+		const release = path.join(tempDir, "pending-steer-release");
+		mockPi.onCall({ steps: [{ waitForPath: release, jsonl: [events.assistantMessage("done")] }] });
+		const ctx = makeMinimalCtx(tempDir);
+		ctx.sessionManager.getSessionId = () => "session-pending-steer";
+		const executor = makeAsyncExecutor([makeAgent("worker", { completionGuard: false })]);
+		const launch = await executor.execute("pending-steer", { workflowScript: `return await runs.run("A", { agent: "worker", task: "Wait" });`, async: true }, new AbortController().signal, undefined, ctx);
+		assert.equal(launch.isError, undefined);
+		const runId = launch.details!.asyncId as string;
+		const asyncDir = path.join(ASYNC_DIR, runId);
+		await waitForMockPiCall(mockPi, 0, 10_000);
+		const session = mockPi.sessions[0]!.session!;
+		const originalSteer = session.steer;
+		let settle!: () => void;
+		let entered = false;
+		session.steer = async () => {
+			entered = true;
+			await new Promise<void>((resolve, reject) => { settle = stop ? () => reject(new Error("late rejection")) : resolve; });
+		};
+		try {
+			requestAsyncSteer(asyncDir, { id: "pending", message: "pending", targetIndex: 0 });
+			await waitForAsyncState(runId, (candidate) => entered && recentSteering(candidate, "pending")?.state === "routed", 15_000);
+			assert.deepEqual(fs.readdirSync(steerRequestsDir(asyncDir)), [], "pending request is consumed, not available to file drain");
+			if (stop) {
+				requestAsyncSteer(asyncDir, { id: "file-resident", message: "not consumed", targetIndexes: [0, 99] });
+				const stopped = await executor.execute("stop-pending", { action: "stop", id: runId }, new AbortController().signal, undefined, ctx);
+				assert.notEqual(stopped.isError, true, stopped.content[0]?.text);
+			} else fs.writeFileSync(release, "go");
+			const terminal = await waitForAsyncState(runId, (candidate) => candidate.state === (stop ? "stopped" : "complete"), 15_000);
+			assert.equal(recentSteering(terminal, "pending")?.state, "failed");
+			assert.match(recentSteering(terminal, "pending")!.reason!, /before steering delivery settled/);
+			assert.equal(fs.existsSync(steerInboxClosedPath(asyncDir)), true);
+			if (stop) {
+				const targets = (terminal as SteeringTargets).steering!.recent.find((request) => request.id === "file-resident")!.targets;
+				assert.deepEqual(targets.map(({ index, state }) => [index, state]), [[0, "failed"], [99, "failed"]]);
+				assert.ok(targets.every(({ reason }) => reason?.includes("before steering request was consumed")));
+			}
+			const before = fs.readFileSync(path.join(asyncDir, "status.json"), "utf8");
+			const journalBefore = fs.readFileSync(path.join(asyncDir, "events.jsonl"), "utf8");
+			assert.equal(journalBefore.split("\n").filter((line) => line.includes('"type":"subagent.steer.failed"') && line.includes('"requestId":"pending"')).length, 1);
+			settle();
+			await new Promise((resolve) => setTimeout(resolve, 350));
+			assert.equal(fs.readFileSync(path.join(asyncDir, "status.json"), "utf8"), before, "late callback must not rewrite durable terminal state");
+			assert.equal(fs.readFileSync(path.join(asyncDir, "events.jsonl"), "utf8"), journalBefore, "late callback must not append contradictory evidence");
+		} finally {
+			session.steer = originalSteer;
+			settle?.();
+			fs.writeFileSync(release, "go");
+		}
+	});
+
+	it("delivers an inbox steer request to a live async workflow child", { skip: !isAsyncAvailable() || !createSubagentExecutor ? "jiti or executor not available" : undefined }, async () => {
+		const release = path.join(tempDir, "workflow-steer-release");
+		mockPi.onCall({ steps: [{ waitForPath: release, jsonl: [events.assistantMessage("steered workflow child")] }] });
+		const ctx = makeMinimalCtx(tempDir);
+		ctx.sessionManager.getSessionId = () => "session-workflow-steer";
+		const executor = makeAsyncExecutor([makeAgent("worker", { completionGuard: false })]);
+
+		const launch = await executor.execute(
+			`workflow-steer-inbox-${Date.now().toString(36)}`,
+			{ workflowScript: `return await runs.run("waits", { agent: "worker", task: "Wait for guidance" });`, async: true },
+			new AbortController().signal,
+			undefined,
+			ctx,
+		);
+		assert.equal(launch.isError, undefined, launch.content[0]?.text);
+		const runId = launch.details?.asyncId as string;
+		assert.ok(runId, "expected an async workflow run id");
+		const asyncDir = path.join(ASYNC_DIR, runId);
+
+		try {
+			// The child is now live and parked on the release path, so the workflow run is genuinely
+			// steerable: the only question is whether anything consumes its inbox.
+			await waitForMockPiCall(mockPi, 0, 10_000);
+			requestAsyncSteer(asyncDir, { message: "Focus on the failing test.", id: "workflow-steer-1", ts: Date.now() });
+
+			const status = await waitForAsyncState(runId, (candidate) => recentSteering(candidate, "workflow-steer-1") !== undefined, 15_000);
+			const target = recentSteering(status, "workflow-steer-1");
+			assert.equal(target?.state, "delivered", `expected a real delivery, got ${JSON.stringify(target)}`);
+			// The request file must be consumed, not left on disk for the life of the run.
+			assert.deepEqual(fs.readdirSync(steerRequestsDir(asyncDir)), []);
+
+			const steers = fs.readFileSync(path.join(mockPi.dir, "steers.jsonl"), "utf-8").trim().split("\n").map((line) => JSON.parse(line) as { text: string });
+			assert.match(steers[0]?.text ?? "", /Focus on the failing test\./, "the live child must receive the steer text");
+
+			const eventsText = fs.readFileSync(path.join(asyncDir, "events.jsonl"), "utf-8");
+			assert.match(eventsText, /"type":"subagent\.steer\.routed"[^\n]*"requestId":"workflow-steer-1"/);
+			assert.match(eventsText, /"type":"subagent\.steer\.delivered"[^\n]*"requestId":"workflow-steer-1"/);
+			requestAsyncSteer(asyncDir, { message: "Follow up later", id: "workflow-follow-up", mode: "follow_up" });
+			const queued = await waitForAsyncState(runId, (candidate) => recentSteering(candidate, "workflow-follow-up")?.state === "queued", 15_000);
+			const counters = (queued as { steering: SteeringStatus }).steering;
+			assert.equal(counters.requested, 2);
+			assert.equal(counters.delivered, 1);
+			assert.equal(counters.pending, 1, "routed to queued must not double-count the pending target");
+		} finally {
+			fs.writeFileSync(release, "go");
+		}
+
+		const payload = await readAsyncPayload(runId);
+		assert.equal(payload.success, true);
+		const terminal = await waitForAsyncState(runId, (candidate) => candidate.state === "complete", 15_000);
+		const counters = (terminal as { steering: SteeringStatus }).steering;
+		assert.equal(counters.pending, 0);
+		assert.equal(counters.delivered, 1);
+		assert.equal(counters.failed, 1);
+		assert.equal(recentSteering(terminal, "workflow-follow-up")?.state, "failed");
+		assert.match(recentSteering(terminal, "workflow-follow-up")!.reason!, /delivery unconfirmed/);
+	});
+
+	for (const parallel of [false, true]) it(`routes every explicit target without sibling fallback (${parallel ? "parallel" : "sequential"})`, { skip: !isAsyncAvailable() || !createSubagentExecutor ? "jiti or executor not available" : undefined }, async () => {
+		const releaseA = path.join(tempDir, "target-release-a");
+		const releaseB = path.join(tempDir, "target-release-b");
+		mockPi.onCall({ steps: [{ waitForPath: releaseA, jsonl: [events.assistantMessage("A done")] }] });
+		mockPi.onCall({ steps: [{ waitForPath: releaseB, jsonl: [events.assistantMessage("B done")] }] });
+		const ctx = makeMinimalCtx(tempDir);
+		ctx.sessionManager.getSessionId = () => "session-workflow-targets";
+		const executor = makeAsyncExecutor([makeAgent("worker", { completionGuard: false })]);
+		const launch = await executor.execute("workflow-targets", {
+			workflowScript: parallel
+				? `return await Promise.all([runs.run("A", { agent: "worker", task: "A" }), runs.run("B", { agent: "worker", task: "B" })]);`
+				: `await runs.run("A", { agent: "worker", task: "A" }); return await runs.run("B", { agent: "worker", task: "B" });`,
+			async: true,
+		}, new AbortController().signal, undefined, ctx);
+		assert.equal(launch.isError, undefined, launch.content[0]?.text);
+		const runId = launch.details?.asyncId as string;
+		const asyncDir = path.join(ASYNC_DIR, runId);
+		const deliveredTexts = (): string[] => {
+			const file = path.join(mockPi.dir, "steers.jsonl");
+			return fs.existsSync(file) ? fs.readFileSync(file, "utf8").trim().split("\n").filter(Boolean).map((line) => JSON.parse(line).text) : [];
+		};
+		const check = async (id: string, address: { targetIndex?: number; targetIndexes?: number[] }, expected: Array<[number, string]>, deliveries: number, alreadyWritten = false) => {
+			if (!alreadyWritten) requestAsyncSteer(asyncDir, { id, message: id, ...address });
+			const status = await waitForAsyncState(runId, (candidate) => {
+				const targets = (candidate as SteeringTargets).steering?.recent.find((request) => request.id === id)?.targets;
+				return targets !== undefined && targets.every((target) => target.state === "delivered" || target.state === "failed");
+			}, 15_000);
+			const targets = (status as SteeringTargets).steering!.recent.find((request) => request.id === id)!.targets;
+			assert.deepEqual(targets.map(({ index, state }) => [index, state]), expected);
+			assert.equal(deliveredTexts().filter((text) => text.includes(id)).length, deliveries);
+			const journal = fs.readFileSync(path.join(asyncDir, "events.jsonl"), "utf8").trim().split("\n").map((line) => JSON.parse(line)).filter((event) => event.requestId === id);
+			assert.equal(journal.filter((event) => event.type === "subagent.steer.requested").length, 1);
+			for (const [index, state] of expected) assert.equal(journal.filter((event) => event.index === index && event.type === `subagent.steer.${state}`).length, 1);
+			return targets;
+		};
+		try {
+			await waitForMockPiCall(mockPi, 0, 10_000);
+			// Hold a transport-written request outside the watched inbox until A disappears.
+			// This controls queue-to-consumption delay without changing the watcher or child lifecycle.
+			const heldDir = path.join(tempDir, "held-steer");
+			if (!parallel) {
+				requestAsyncSteer(heldDir, { id: "disappeared-A", message: "disappeared-A", targetIndex: 0 });
+				fs.writeFileSync(releaseA, "go");
+			}
+			await waitForMockPiCall(mockPi, 1, 10_000);
+			await waitForAsyncState(runId, (candidate) => (candidate.steps?.length ?? 0) === 2, 15_000);
+			if (parallel) {
+				const targets = await check("ambiguous", {}, [[0, "failed"]], 0);
+				assert.match(targets[0]!.reason!, /2 live children/);
+			} else {
+				for (const file of fs.readdirSync(steerRequestsDir(heldDir))) fs.renameSync(path.join(steerRequestsDir(heldDir), file), path.join(steerRequestsDir(asyncDir), file));
+				await check("disappeared-A", {}, [[0, "failed"]], 0, true);
+				const targets = await check("dead-A", { targetIndex: 0 }, [[0, "failed"]], 0);
+				assert.match(targets[0]!.reason!, /not live/);
+				await check("unique-B", {}, [[1, "delivered"]], 1);
+			}
+			await check("aggregate", { targetIndexes: [0, 1] }, [[0, parallel ? "delivered" : "failed"], [1, "delivered"]], parallel ? 2 : 1);
+			if (parallel) {
+				const deliveries = fs.readFileSync(path.join(mockPi.dir, "steers.jsonl"), "utf8").trim().split("\n").map((line) => JSON.parse(line) as { text: string; sessionId: string });
+				assert.equal(new Set(deliveries.filter(({ text }) => text.includes("aggregate")).map(({ sessionId }) => sessionId)).size, 2, "aggregate must reach two distinct children");
+			}
+			await check("out-of-range", { targetIndex: 99 }, [[99, "failed"]], 0);
+			await check("mixed-range", { targetIndexes: [1, 99] }, [[1, "delivered"], [99, "failed"]], 1);
+		} finally {
+			fs.writeFileSync(releaseA, "go");
+			fs.writeFileSync(releaseB, "go");
+		}
+		assert.equal((await readAsyncPayload(runId)).success, true);
+	});
+
+	it("closes the inbox and fails a late steer request when the workflow ends", { skip: !isAsyncAvailable() || !createSubagentExecutor ? "jiti or executor not available" : undefined }, async () => {
+		const ctx = makeMinimalCtx(tempDir);
+		ctx.sessionManager.getSessionId = () => "session-workflow-steer-closed";
+		const executor = makeAsyncExecutor([]);
+
+		const launch = await executor.execute(
+			`workflow-steer-closed-${Date.now().toString(36)}`,
+			{ workflowScript: "return 'done'", async: true },
+			new AbortController().signal,
+			undefined,
+			ctx,
+		);
+		assert.equal(launch.isError, undefined, launch.content[0]?.text);
+		const runId = launch.details?.asyncId as string;
+		const asyncDir = path.join(ASYNC_DIR, runId);
+
+		await waitForAsyncState(runId, (candidate) => candidate.state === "complete", 15_000);
+		// A terminal run must refuse new steering rather than accept a request nothing will read.
+		assert.equal(fs.existsSync(steerInboxClosedPath(asyncDir)), true, "the steer inbox must be closed at teardown");
+		assert.throws(
+			() => requestAsyncSteer(asyncDir, { message: "Too late.", id: "workflow-steer-late", ts: Date.now() }),
+			/no longer accepts steering requests/,
+		);
+	});
+});

package/dist/extensions/pi-subagents/test/smoke/pi085-child.ts

@@ -0,0 +1,31 @@
+import assert from "node:assert/strict";
+import { pathToFileURL } from "node:url";
+import { AgentSession } from "@selesai/code";
+import { BACKGROUND_CONTEXT } from "@earendil-works/pi-agent-core";
+import { createModels } from "@earendil-works/pi-ai";
+
+const state = globalThis.__pi085Smoke = { AgentSession, BACKGROUND_CONTEXT, createModels, started: 0, stopped: 0, faux: undefined };
+const { loadRunnerChildSessionFactory } = await import(pathToFileURL(`${process.env.SMOKE_EXTENSION}/src/runs/background/runner-child-sessions.ts`).href);
+const factory = await loadRunnerChildSessionFactory({});
+const errors = [];
+let started = 0, stopped = 0;
+try {
+	const child = await factory.create({
+		cwd: process.cwd(), storage: { kind: "memory" }, model: "pi085-smoke/local", tools: [],
+		extensionPaths: [`${process.cwd()}/pi085-extension.ts`], ambientExtensions: false,
+		noSkills: true, noContextFiles: true, runtime: {},
+		hooks: [{ name: "lifecycle", factory(pi) {
+			pi.on("session_start", () => { started++; });
+			pi.on("session_shutdown", () => { stopped++; });
+		} }], onExtensionError(error) { errors.push(error); },
+	});
+	try {
+		assert.equal(child.modelId, "pi085-smoke/local");
+		await child.prompt("Return the local scripted response.");
+		assert.equal(state.faux.state.callCount, 1);
+		assert.ok(child.messages.some(m => m.role === "assistant" && m.content.some(c => c.type === "text" && c.text === "local response verified")));
+	} finally { await child.dispose(); }
+	assert.deepEqual([started, stopped, state.started, state.stopped], [1, 1, 1, 1]);
+	assert.deepEqual(errors, []);
+	console.log("PASS public SDK/default child factory: local prompt, API identity, startup/shutdown");
+} finally { await factory.dispose(); }

package/dist/extensions/pi-subagents/test/smoke/pi085-clean-install.mjs

@@ -0,0 +1,74 @@
+// Run with Node >=22.19.0: node --experimental-strip-types test/smoke/pi085-clean-install.mjs [artifact-dir] [0.85.0|0.85.1]
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const source = fileURLToPath(new URL("../../", import.meta.url));
+const version = process.argv[3] ?? "0.85.0";
+assert.ok(["0.85.0", "0.85.1"].includes(version), "requires an explicitly supported smoke version");
+const isPi0850 = version === "0.85.0";
+const root = process.argv[2] ? path.resolve(process.argv[2]) : fs.mkdtempSync(path.join(os.tmpdir(), "pi085-smoke-"));
+fs.mkdirSync(root, { recursive: true });
+const host = path.join(root, "host");
+const extension = path.join(root, "extension");
+const cwd = path.join(root, "cwd");
+for (const dir of [host, extension, cwd, path.join(root, "home")]) fs.mkdirSync(dir, { recursive: true });
+assert.ok(!fs.existsSync(path.join(host, "node_modules")), "requires a pristine host install");
+assert.ok(!fs.existsSync(path.join(extension, "node_modules")), "requires a pristine extension install");
+const env = {
+	...process.env, HOME: path.join(root, "home"), USERPROFILE: path.join(root, "home"), SELESAI_CODING_AGENT_DIR: path.join(root, "agent"),
+	XDG_CACHE_HOME: path.join(root, "cache"), npm_config_cache: path.join(root, "npm-cache"),
+	NODE_COMPILE_CACHE: path.join(root, "node-cache"), JITI_FS_CACHE: "false", PI_OFFLINE: "1",
+};
+// Do not inherit loader/alias overrides or operator credentials into the child.
+for (const key of Object.keys(env)) {
+	if (/API_KEY|TOKEN|SECRET|PASSWORD/.test(key) || ["NODE_OPTIONS", "NODE_PATH", "JITI_ALIAS"].includes(key)) delete env[key];
+}
+function run(name, command, args, workdir, extra = {}, success = true) {
+	const result = spawnSync(command, args, { cwd: workdir, env: { ...env, ...extra }, encoding: "utf8", timeout: 180000, maxBuffer: 10 * 1024 * 1024 });
+	fs.writeFileSync(path.join(root, `${name}.log`), `${result.stdout ?? ""}${result.stderr ?? ""}`);
+	assert.ifError(result.error);
+	if (success) assert.equal(result.status, 0, `${name}: ${result.stdout}\n${result.stderr}`);
+	else assert.notEqual(result.status, 0, `${name} unexpectedly passed`);
+	return result;
+}
+fs.writeFileSync(path.join(host, "package.json"), JSON.stringify({ private: true, dependencies: { "@selesai/code": version } }));
+run("host-install", "npm", ["install", "--no-audit", "--no-fund"], host);
+const packed = JSON.parse(run("pack", "npm", ["pack", "--json", "--pack-destination", root], source).stdout)[0];
+assert.ok(packed.files.some(file => file.path === "runner-server-preload.mjs"), "preload must ship");
+fs.writeFileSync(path.join(extension, "package.json"), JSON.stringify({ private: true, dependencies: { "pi-subagents": `file:${path.join(root, packed.filename)}` } }));
+run("extension-install", "npm", ["install", "--no-audit", "--no-fund"], extension);
+const installed = path.join(extension, "node_modules/pi-subagents");
+const pi = path.join(host, "node_modules/@selesai/code");
+const { createJiti } = await import(pathToFileURL(path.join(extension, "node_modules/jiti/lib/jiti.mjs")).href);
+const jitiLoader = createJiti(import.meta.url, { fsCache: false });
+const { resolveHostPeerAliases, findHostPeerPackageDir, resolvePackageSubpath } = await jitiLoader.import(path.join(installed, "src/runs/background/runner-aliases.ts"));
+assert.equal(findHostPeerPackageDir(pi, "@earendil-works/pi-server"), undefined, "host must remain missing server");
+if (!isPi0850) assert.equal(findHostPeerPackageDir(pi, "@earendil-works/pi-client"), undefined, "stable host must remain missing client");
+const pristine = run("pristine-public-sdk", process.execPath, ["--input-type=module", "-e", `await import(${JSON.stringify(pathToFileURL(resolvePackageSubpath(pi, ".")).href)})`], cwd, {}, !isPi0850);
+if (isPi0850) assert.match(pristine.stderr, /Cannot find package '@earendil-works\/pi-server'/);
+const resolved = resolveHostPeerAliases(pi);
+assert.deepEqual(resolved.missing, []);
+assert.deepEqual(resolved.supplemental, isPi0850 ? ["@earendil-works/pi-server", "@earendil-works/pi-server/unix"] : []);
+if (!isPi0850) {
+	for (const specifier of ["@earendil-works/pi-server", "@earendil-works/pi-server/unix", "@earendil-works/pi-client/unix"]) assert.equal(resolved.aliases[specifier], undefined);
+}
+fs.writeFileSync(path.join(root, "aliases.json"), JSON.stringify(resolved, null, 2));
+for (const file of ["pi085-child.ts", "pi085-extension.ts"]) fs.copyFileSync(new URL(file, import.meta.url), path.join(cwd, file));
+const childEnv = { SMOKE_EXTENSION: installed, JITI_ALIAS: JSON.stringify(resolved.aliases) };
+const jiti = path.join(extension, "node_modules/jiti/lib/jiti-cli.mjs");
+const args = [jiti, path.join(cwd, "pi085-child.ts")];
+// The real file-extension gate must fail with aliases alone, not just an import mock.
+if (isPi0850) {
+	const negative = run("without-preload", process.execPath, args, cwd, childEnv, false);
+	assert.match(negative.stderr, /Model "pi085-smoke\/local" not found/);
+}
+const preload = resolved.supplemental.length ? ["--import", pathToFileURL(path.join(installed, "runner-server-preload.mjs")).href] : [];
+const positive = run("child", process.execPath, [...preload, ...args], cwd, childEnv);
+assert.match(positive.stdout, /PASS public SDK\/default child factory/);
+assert.equal(findHostPeerPackageDir(pi, "@earendil-works/pi-server"), undefined);
+if (!isPi0850) assert.equal(findHostPeerPackageDir(pi, "@earendil-works/pi-client"), undefined);
+console.log(`${positive.stdout.trim()}\nArtifacts: ${root}`);

package/dist/extensions/pi-subagents/test/smoke/pi085-extension.ts

@@ -0,0 +1,16 @@
+import assert from "node:assert/strict";
+import { AgentSession } from "@selesai/code";
+import { BACKGROUND_CONTEXT } from "@earendil-works/pi-agent-core";
+import { createModels, fauxProvider, fauxAssistantMessage } from "@earendil-works/pi-ai";
+
+export default function(pi) {
+	const state = globalThis.__pi085Smoke;
+	assert.equal(AgentSession, state.AgentSession);
+	assert.equal(BACKGROUND_CONTEXT, state.BACKGROUND_CONTEXT);
+	assert.equal(createModels, state.createModels);
+	state.faux = fauxProvider({ provider: "pi085-smoke", models: [{ id: "local" }], tokensPerSecond: 100000 });
+	state.faux.setResponses([fauxAssistantMessage("local response verified")]);
+	pi.registerProvider(state.faux.provider);
+	pi.on("session_start", () => { state.started++; });
+	pi.on("session_shutdown", () => { state.stopped++; });
+}