@selesai/code 0.13.40 → 0.14.3

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

@@ -213,6 +213,7 @@ function createWatchdogHarness(review?: WatchdogReviewFunction) {
 	const commands = new Map<string, RegisteredSlashCommand>();
 	const renderers = new Map<string, (message: { content: string; details?: unknown }, options: { expanded: boolean }, theme: { fg(name: string, value: string): string; bold(value: string): string }) => { render(width: number): string[] } | undefined>();
 	const sent: unknown[] = [];
+	const entries: Array<{ customType: string; data: unknown }> = [];
 	const pi = {
 		events: createEventBus(),
 		on() {},
@@ -221,11 +222,13 @@ function createWatchdogHarness(review?: WatchdogReviewFunction) {
 		registerMessageRenderer(type: string, renderer: (message: { content: string; details?: unknown }, options: { expanded: boolean }, theme: { fg(name: string, value: string): string; bold(value: string): string }) => { render(width: number): string[] } | undefined) {
 			renderers.set(type, renderer);
 		},
+		registerEntryRenderer() {},
+		appendEntry(customType: string, data: unknown) { entries.push({ customType, data }); },
 		getThinkingLevel() { return "medium" as const; },
 		sendMessage(message: unknown) { sent.push(message); },
 	};
 	const runtime = registerMainWatchdog!(pi as never, review ? { review } : undefined);
-	return { commands, renderers, runtime, sent };
+	return { commands, renderers, runtime, sent, entries };
 }
 
 async function captureSlashCommandParams(
@@ -327,6 +330,40 @@ describe("subagents watchdog slash command", { skip: !available ? "watchdog comm
 		});
 	});
 
+	it("keeps a configured project watchdog in recommendations and explicit user-scope saves", async () => {
+		await withIsolatedHome(async () => {
+			await withTempProject("pi-watchdog-configured-", async (root) => {
+				const configured = { provider: "github-copilot", id: "gpt-6-astra", reasoning: true };
+				const gpt = { provider: "openai-codex", id: "gpt-5.5", reasoning: true };
+				const models = [configured, gpt];
+				const projectPath = path.join(root, ".selesai", "settings.json");
+				fs.mkdirSync(path.dirname(projectPath), { recursive: true });
+				const projectSettings = JSON.stringify({ subagents: { watchdog: { main: { model: "github-copilot/gpt-6-astra", thinking: "high" } } } });
+				fs.writeFileSync(projectPath, projectSettings);
+				const ctx = createCommandContext({ cwd: root, model: configured, modelRegistry: {
+					getAvailable: () => models,
+					find: (provider: string, id: string) => models.find((entry) => entry.provider === provider && entry.id === id),
+					hasConfiguredAuth: () => true,
+				} });
+				const { commands, sent } = createWatchdogHarness();
+				for (const command of ["status", "recommend-model", "check"]) {
+					await commands.get("subagents-watchdog")!.handler(command, ctx);
+					const content = String((sent.at(-1) as { content?: unknown }).content ?? "");
+					assert.match(content, /Keep configured watchdog: github-copilot\/gpt-6-astra:high/);
+					assert.doesNotMatch(content, /Recommended strong watchdog|strong independent watchdog/);
+				}
+				const userPath = path.join(process.env.HOME!, ".selesai", "agent", "settings.json");
+				assert.equal(fs.existsSync(userPath), false);
+				await commands.get("subagents-watchdog")!.handler("model recommended", ctx);
+				assert.deepEqual(JSON.parse(fs.readFileSync(userPath, "utf-8")).subagents.watchdog.main, {
+					model: "github-copilot/gpt-6-astra", thinking: "high",
+				});
+				assert.match(String((sent.at(-1) as { content?: unknown }).content), /saved to user settings/);
+				assert.equal(fs.readFileSync(projectPath, "utf-8"), projectSettings);
+			});
+		});
+	});
+
 	it("supports session-scoped recommended watchdog models without writing settings", async () => {
 		await withIsolatedHome(async () => {
 			await withTempProject("pi-watchdog-session-model-", async (root) => {
@@ -430,23 +467,19 @@ describe("subagents watchdog slash command", { skip: !available ? "watchdog comm
 		});
 	});
 
-	it("sends deterministic concern and blocker warning messages through the renderer path", async () => {
+	it("routes explicit low and medium test findings to entries and high findings to messages", async () => {
 		await withIsolatedHome(async () => {
-			const { commands, renderers, sent } = createWatchdogHarness();
-			await commands.get("subagents-watchdog")!.handler("test concern check the concern", createCommandContext());
-			await commands.get("subagents-watchdog")!.handler("test blocker check the blocker", createCommandContext());
-
-			const concern = sent[0] as { customType?: string; content?: string; display?: boolean; details?: Record<string, unknown> };
-			const blocker = sent[1] as { customType?: string; content?: string; display?: boolean; details?: Record<string, unknown> };
-			assert.equal(concern.customType, "subagent_watchdog_warning");
-			assert.equal(concern.display, true);
-			assert.equal(concern.details?.severity, "concern");
-			assert.equal(concern.details?.source, "main");
-			assert.equal(concern.details?.state, "displayed");
-			assert.match(concern.content ?? "", /source="main"/);
-			assert.match(concern.content ?? "", /<state>displayed<\/state>/);
-			assert.match(concern.content ?? "", /<recommended_action>/);
+			const { commands, renderers, sent, entries } = createWatchdogHarness();
+			await commands.get("subagents-watchdog")!.handler("test concern low check the concern", createCommandContext());
+			await commands.get("subagents-watchdog")!.handler("test concern medium check the medium concern", createCommandContext());
+			await commands.get("subagents-watchdog")!.handler("test blocker high check the blocker", createCommandContext());
+
+			assert.equal(entries.length, 2);
+			assert.deepEqual(entries.map((entry) => (entry.data as any).importance), ["low", "medium"]);
+			assert.equal(sent.length, 1);
+			const blocker = sent[0] as { customType?: string; content?: string; display?: boolean; details?: Record<string, unknown> };
 			assert.equal(blocker.details?.severity, "blocker");
+			assert.equal(blocker.details?.importance, "high");
 			assert.match(blocker.content ?? "", /<blocker_guidance>/);
 
 			const renderer = renderers.get("subagent_watchdog_warning")!;
@@ -463,7 +496,7 @@ describe("subagents watchdog slash command", { skip: !available ? "watchdog comm
 					assert.equal(request.emitWarning({
 						severity: "concern",
 						category: "test-gap",
-						confidence: "high",
+						importance: "high",
 						source: "main",
 						summary: "Focused validation is missing",
 						evidence: "The reviewed turn delta says changes were made but contains no test command.",
@@ -558,7 +591,7 @@ describe("slash command custom message delivery", { skip: !available ? "slash-co
 			const branch = [
 				{ type: "message", message: { role: "assistant", usage: { input: 10, output: 2, cacheRead: 30, cacheWrite: 0, cost: { total: 0.2 } } } },
 				{ type: "compaction", usage: { input: 5, output: 1, cacheRead: 0, cacheWrite: 0, cost: { total: 0.05 } } },
-				{ type: "message", message: { role: "toolResult", toolName: "subagent", details: { mode: "workflow", runId: workflowRunId, results: [] } } },
+				{ type: "message", message: { role: "toolResult", toolName: "subagent", details: { mode: "workflow", runId: workflowRunId, asyncId: workflowRunId, results: [] } } },
 			];
 			try {
 				registerSlashCommands!(pi as never, createState(root));
@@ -584,6 +617,77 @@ describe("slash command custom message delivery", { skip: !available ? "slash-co
 		});
 	});
 
+	it("/subagent-cost recovers async single and chain usage from status steps and metadata", async () => {
+		await withTempProject("pi-subagent-cost-async-single-", async (root) => {
+			const singleRunId = `single-cost-${process.pid}-${Date.now()}`;
+			const chainRunId = `chain-cost-${process.pid}-${Date.now()}`;
+			const sessionFile = path.join(root, "sessions", "parent.jsonl");
+			const artifactsDir = getArtifactsDir(sessionFile, root, "session");
+			fs.mkdirSync(path.dirname(sessionFile), { recursive: true });
+			fs.writeFileSync(sessionFile, "", "utf-8");
+			fs.mkdirSync(artifactsDir, { recursive: true });
+			const runningRunId = `running-cost-${process.pid}-${Date.now()}`;
+			const writeRun = (runId: string, agents: string[], stepStatus = "complete") => {
+				fs.mkdirSync(path.join(DIRS.async, runId), { recursive: true });
+				fs.writeFileSync(path.join(DIRS.async, runId, "status.json"), JSON.stringify({
+					runId, mode: agents.length > 1 ? "chain" : "single", state: stepStatus === "complete" ? "complete" : "running", startedAt: Date.now(), cwd: root,
+					steps: agents.map((agent) => ({ agent, status: stepStatus })),
+				}), "utf-8");
+			};
+			const writeMetadata = (runId: string, agent: string, index: number | undefined, usage: Record<string, number>) => {
+				fs.writeFileSync(getArtifactPaths(artifactsDir, runId, agent, index).metadataPath, JSON.stringify({ runId, agent, usage }), "utf-8");
+			};
+			writeRun(singleRunId, ["oracle"]);
+			writeMetadata(singleRunId, "oracle", undefined, { input: 30, output: 6, cacheRead: 0, cacheWrite: 0, cost: 0.3, turns: 2 });
+			writeRun(chainRunId, ["scout", "worker"]);
+			writeMetadata(chainRunId, "scout", 0, { input: 10, output: 2, cacheRead: 0, cacheWrite: 0, cost: 0.1, turns: 1 });
+			writeMetadata(chainRunId, "worker", 1, { input: 40, output: 8, cacheRead: 0, cacheWrite: 0, cost: 0.4, turns: 3 });
+			// A still-running child has no metadata yet and is not "unavailable".
+			writeRun(runningRunId, ["reviewer"], "running");
+
+			const sent: unknown[] = [];
+			const commands = new Map<string, RegisteredSlashCommand>();
+			const pi = {
+				events: createEventBus(),
+				registerCommand(name: string, spec: RegisteredSlashCommand) { commands.set(name, spec); },
+				registerShortcut() {},
+				sendMessage(message: unknown) { sent.push(message); },
+			};
+			const branch = [
+				{ type: "message", message: { role: "toolResult", toolName: "subagent", details: { mode: "single", runId: singleRunId, asyncId: singleRunId, results: [] } } },
+				{ type: "message", message: { role: "toolResult", toolName: "subagent", details: { mode: "chain", runId: chainRunId, asyncId: chainRunId, results: [] } } },
+				{ type: "message", message: { role: "toolResult", toolName: "subagent", details: { mode: "single", runId: runningRunId, asyncId: runningRunId, results: [] } } },
+				// The chain's bg_wait completion must not be counted again from artifacts.
+				{ type: "message", message: { role: "toolResult", toolName: "bg_wait", details: { mode: "single", results: [], completions: [{ runId: chainRunId, mode: "chain", results: [
+					{ agent: "scout", usage: { input: 10, output: 2, cacheRead: 0, cacheWrite: 0, cost: 0.1, turns: 1 } },
+					{ agent: "worker", usage: { input: 40, output: 8, cacheRead: 0, cacheWrite: 0, cost: 0.4, turns: 3 } },
+				] }] } } },
+			];
+			try {
+				registerSlashCommands!(pi as never, createState(root));
+				await commands.get("subagent-cost")!.handler("", createCommandContext({
+					cwd: root,
+					sessionManager: {
+						getBranch: () => branch,
+						getSessionFile: () => sessionFile,
+						getSessionId: () => "session-parent",
+					},
+				}));
+				const report = String((sent[0] as { content?: unknown }).content ?? "");
+				assert.match(report, /Child \d \(oracle\): ↑30 ↓6 \$0\.3000 \(2 turns\)/);
+				assert.match(report, /Child \d \(scout\): ↑10 ↓2 \$0\.1000 \(1 turn\)/);
+				assert.match(report, /Child \d \(worker\): ↑40 ↓8 \$0\.4000 \(3 turns\)/);
+				assert.equal((report.match(/Child \d+ \(/g) ?? []).length, 3);
+				assert.match(report, /Children: ↑80 ↓16 \$0\.8000 \(6 turns\)/);
+				assert.doesNotMatch(report, /Async child usage unavailable/);
+			} finally {
+				fs.rmSync(path.join(DIRS.async, singleRunId), { recursive: true, force: true });
+				fs.rmSync(path.join(DIRS.async, chainRunId), { recursive: true, force: true });
+				fs.rmSync(path.join(DIRS.async, runningRunId), { recursive: true, force: true });
+			}
+		});
+	});
+
 	it("registers a configured foreground detach shortcut", async () => {
 		const shortcuts = new Map<string, { handler(ctx: unknown): Promise<void> }>();
 		const sent: unknown[] = [];
@@ -615,15 +719,30 @@ describe("slash command custom message delivery", { skip: !available ? "slash-co
 		assert.match(String((sent[0] as { content?: unknown }).content ?? ""), /Detached foreground run run-123/);
 	});
 
-	it("does not reserve a foreground detach shortcut by default", () => {
+	it("preserves /subagents-fleet without reserving a global shortcut by default", () => {
+		const commands = new Map<string, RegisteredSlashCommand>();
 		const shortcuts = new Map<string, unknown>();
 		registerSlashCommands!({
 			events: createEventBus(),
-			registerCommand() {},
+			registerCommand(name: string, spec: RegisteredSlashCommand) { commands.set(name, spec); },
 			registerShortcut(key: string, spec: unknown) { shortcuts.set(key, spec); },
 			sendMessage() {},
 		}, createState(process.cwd()));
-		assert.equal(shortcuts.has("ctrl+b"), false);
+		assert.ok(commands.has("subagents-fleet"));
+		assert.equal(shortcuts.size, 0);
+	});
+
+	it("/subagents-fleet loads and opens the Fleet view on first use", async () => {
+		const commands = new Map<string, RegisteredSlashCommand>();
+		registerSlashCommands!({
+			events: createEventBus(),
+			registerCommand(name: string, spec: RegisteredSlashCommand) { commands.set(name, spec); },
+			registerShortcut() {},
+			sendMessage() {},
+		}, createState(process.cwd()));
+		let opened = 0;
+		await commands.get("subagents-fleet")!.handler("", createCommandContext({ hasUI: true, custom: async () => { opened += 1; return undefined; } }));
+		assert.equal(opened, 1);
 	});
 
 	it("/subagents-stop keeps the selector within its allocated width", async () => {

package/dist/extensions/pi-subagents/test/integration/structured-workflows.test.ts

@@ -0,0 +1,105 @@
+/** chain/tasks through executePublic with disabledFeatures "workflow-scripts", using the mock pi child launcher. */
+
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { describe, it } from "node:test";
+import { DIRS, type AsyncStatus } from "../../src/shared/types.ts";
+import { createEventBus, makeAgent, makeMinimalCtx } from "../support/helpers.ts";
+import { available, createSubagentExecutor, installSingleExecutionHooks, makeExecutor, mockPi, readAllCallArgs, tempDir } from "../support/single-execution-fixture.ts";
+
+const DISABLED = { disabledFeatures: ["workflow-scripts"] };
+
+function text(result: { content: Array<{ type: string; text?: string }> }): string {
+	return result.content.map((part) => part.text ?? "").join("\n");
+}
+
+describe("structured chain/tasks workflows", { skip: !available || !createSubagentExecutor ? "pi packages not available" : undefined }, () => {
+	installSingleExecutionHooks();
+
+	it("runs a chain in order with {task}, {previous}, and {outputs.name}", async () => {
+		mockPi.onCall({ matchArgIncludes: "Scan: fix login", output: "SCAN-RESULT" });
+		mockPi.onCall({ matchArgIncludes: "Plan from SCAN-RESULT", output: "PLAN-RESULT" });
+		mockPi.onCall({ matchArgIncludes: "Write PLAN-RESULT using SCAN-RESULT for fix login", output: "WRITTEN" });
+		const executor = makeExecutor([makeAgent("scout"), makeAgent("planner"), makeAgent("writer")], DISABLED);
+		const result = await executor.executePublic("chain-e2e", {
+			task: "fix login",
+			chain: [
+				{ agent: "scout", task: "Scan: {task}", as: "scan" },
+				{ agent: "planner", task: "Plan from {previous}" },
+				{ agent: "writer", task: "Write {previous} using {outputs.scan} for {task}" },
+			],
+			async: false,
+			chatProgress: "off",
+		}, new AbortController().signal, undefined, makeMinimalCtx(tempDir));
+		assert.equal(result.isError, undefined, text(result));
+		assert.equal(result.details.mode, "workflow");
+		assert.equal(result.details.workflow?.resource?.name, "chain");
+		assert.deepEqual(result.details.workflow?.value, {
+			ok: true,
+			children: [
+				{ key: "step-1", agent: "scout", ok: true, output: "SCAN-RESULT" },
+				{ key: "step-2", agent: "planner", ok: true, output: "PLAN-RESULT" },
+				{ key: "step-3", agent: "writer", ok: true, output: "WRITTEN" },
+			],
+		});
+		const launched = readAllCallArgs().map((args) => args.join(" "));
+		assert.equal(launched.length, 3);
+		assert.ok(launched[2]!.includes("Write PLAN-RESULT using SCAN-RESULT for fix login"), launched[2]);
+	});
+
+	it("does not warn about dynamic launches for a chain", async (t) => {
+		const warnings: string[] = [];
+		t.mock.method(console, "warn", (message: string) => { warnings.push(message); });
+		const result = await makeExecutor([makeAgent("scout")], DISABLED).executePublic("chain-warn", {
+			chain: [{ agent: "scout", task: "One" }, { agent: "scout" }],
+			async: false,
+			chatProgress: "off",
+		}, new AbortController().signal, undefined, makeMinimalCtx(tempDir));
+		assert.equal(result.isError, undefined, text(result));
+		assert.deepEqual(warnings.filter((message) => String(message).includes("dynamic child launches")), []);
+	});
+
+	it("returns a failed chain step as an error with the earlier step's output", async () => {
+		mockPi.onCall({ matchArgIncludes: "First step", output: "FIRST-OUTPUT" });
+		mockPi.onCall({ matchArgIncludes: "Second FIRST-OUTPUT", exitCode: 1, stderr: "second broke" });
+		const executor = makeExecutor([makeAgent("scout"), makeAgent("writer")], DISABLED);
+		const result = await executor.executePublic("chain-e2e-fail", {
+			chain: [{ agent: "scout", task: "First step" }, { agent: "writer", task: "Second {previous}" }, { agent: "writer" }],
+			async: false,
+			chatProgress: "off",
+		}, new AbortController().signal, undefined, makeMinimalCtx(tempDir));
+		assert.equal(result.isError, true);
+		assert.match(text(result), /chain stopped at step 2: step-2 \(writer\) failed/);
+		assert.equal(result.details.workflow?.resource?.name, "chain");
+		assert.deepEqual(result.details.results.map((child) => ({ agent: child.agent, ok: child.exitCode === 0 })), [
+			{ agent: "scout", ok: true },
+			{ agent: "writer", ok: false },
+		]);
+		assert.match(JSON.stringify(result.details.results[0]), /FIRST-OUTPUT/);
+		assert.equal(readAllCallArgs().length, 2, "the step after the failure does not launch");
+	});
+
+	it("records a failed state for an async tasks run with a failed child", async () => {
+		mockPi.onCall({ matchArgIncludes: "Task A", output: "A done" });
+		mockPi.onCall({ matchArgIncludes: "Task B", exitCode: 1, stderr: "B broke" });
+		const executor = makeExecutor([makeAgent("scout")], DISABLED, false, undefined, true, new Map(), undefined, undefined, createEventBus(), undefined, undefined, () => {});
+		const launch = await executor.executePublic("tasks-e2e-async", {
+			task: "the request",
+			tasks: [{ agent: "scout", task: "Task A for {task}" }, { agent: "scout", task: "Task B" }],
+			async: true,
+		}, new AbortController().signal, undefined, makeMinimalCtx(tempDir));
+		assert.equal(launch.isError, undefined, text(launch));
+		assert.ok(launch.details.asyncDir);
+		const statusPath = path.join(launch.details.asyncDir!, "status.json");
+		let status: Partial<Pick<AsyncStatus, "state">> = {};
+		for (let attempt = 0; attempt < 250; attempt += 1) {
+			if (fs.existsSync(statusPath)) status = JSON.parse(fs.readFileSync(statusPath, "utf8"));
+			if (status.state === "complete" || status.state === "failed") break;
+			await new Promise((resolve) => setTimeout(resolve, 20));
+		}
+		assert.equal(status.state, "failed");
+		fs.rmSync(launch.details.asyncDir!, { recursive: true, force: true });
+		if (launch.details.asyncId) fs.rmSync(path.join(DIRS.results, `${launch.details.asyncId}.json`), { force: true });
+	});
+});

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

@@ -6,8 +6,8 @@ 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";
+import { makeMinimalCtx, makeAgent, createEventBus, events } from "../support/helpers.ts";
+import { installAsyncExecutionHooks, available, createSubagentExecutor, ASYNC_DIR, RESULTS_DIR, tempDir, mockPi, readAsyncPayload, waitForAsyncState } from "../support/async-execution-fixture.ts";
 
 function barrier() {
 	let resolve!: () => void;
@@ -22,10 +22,67 @@ async function bounded(promise: Promise<unknown>) {
 
 describe("host workflow result publication", { skip: !available }, () => {
 	installAsyncExecutionHooks();
-	for (const outcome of ["complete", "failed", "stopped", "retry-error"] as const) {
+	for (const background of [false, true]) it(`reports explicit async children as running after workflow dispatch (async=${background})`, async () => {
+		const release = path.join(tempDir, "release-child");
+		mockPi.onCall({ steps: [{ waitForPath: release, jsonl: [events.assistantMessage("Final child report")] }] });
+		const notices: Array<{ customType: string; content: string }> = [];
+		const state: SubagentState = { baseCwd: tempDir, currentSessionId: "session-123", 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 = { events: createEventBus(), getSessionName: () => undefined, sendMessage(message: { customType: string; content: string }) { notices.push(message); } };
+		const executor = createSubagentExecutor!({ pi, state, config: {}, asyncByDefault: false, tempArtifactsDir: tempDir,
+			getSubagentSessionRoot: () => tempDir, expandTilde: (p: string) => p, discoverAgents: () => ({ agents: [makeAgent("worker")] }),
+		});
+		const notifier = registerSubagentNotify(pi, state, { batchConfig: { enabled: false } });
+		let childId: string | undefined;
+		try {
+			const result = await executor.execute("dispatch-reporting", { async: background, mission: false,
+				workflowScript: 'return await runs.run("child", { agent: "worker", task: "Wait for fixture release", async: true });',
+			}, new AbortController().signal, undefined, makeMinimalCtx(tempDir));
+			assert.notEqual(result.isError, true, result.content[0]?.text);
+			const payload = background ? await readAsyncPayload(result.details.asyncId!) : result.details;
+			const child = payload.workflow.value;
+			childId = child.runId;
+			assert.ok(childId);
+			assert.equal(JSON.parse(fs.readFileSync(path.join(ASYNC_DIR, childId, "status.json"), "utf8")).state, "running");
+			assert.equal(fs.existsSync(path.join(RESULTS_DIR, `${childId}.json`)), false);
+			assert.equal(payload.workflowChildren.children[0].state, "running");
+			assert.equal(child.state, "running");
+			assert.equal(child.ok, false, "ok is reserved for successful child completion");
+			assert.equal(child.output, "");
+			assert.equal(child.error, undefined);
+			assert.equal(child.outputReference, undefined);
+			assert.equal(child.asyncDir, path.join(ASYNC_DIR, childId));
+			assert.equal(payload.workflow.trace.at(-1).state, "started");
+			assert.equal(notices.some((notice) => notice.customType === "subagent-incremental-child-notify"), false);
+			assert.match(background ? payload.summary : result.content[0].text, /dispatch completed.*1 child run remains running/i);
+			if (background) {
+				assert.equal(payload.results[0].state, "running");
+				assert.equal(payload.results[0].success, undefined);
+				assert.equal(payload.results[0].outputState, "absent");
+				assert.equal(payload.results[0].artifactPaths?.outputPath, undefined);
+				await notifier.deliver({ ...payload, sessionId: state.currentSessionId, completionOwnerId: state.completionOwnerId });
+				assert.match(notices.at(-1)!.content, /dispatch complete/);
+				assert.match(notices.at(-1)!.content, /status=running/);
+			}
+		} finally {
+			fs.writeFileSync(release, "go");
+			if (childId) {
+				const final = await readAsyncPayload(childId);
+				assert.equal(final.success, true);
+				assert.equal(final.results[0].output, "Final child report");
+				await waitForAsyncState(childId, (status) => status.processTerminal?.state === "observed");
+			}
+			notifier.dispose();
+		}
+	});
+	for (const outcome of ["complete", "failed", "stopped", "index-error", "retry-error", "replacement-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 held = true, attempted = false, indexFailureInjected = false, notifications = 0, refreshes = 0, notificationContent = "";
+		const notificationTypes: string[] = [];
 		let statusWrites = 0, statusDeferred = false, statusRecovered = false;
 		let poll: ReturnType<typeof setInterval> | undefined;
 		const sessionId = "workflow-publication-session", owner = "workflow-publication-owner";
@@ -36,7 +93,7 @@ describe("host workflow result publication", { skip: !available }, () => {
 		};
 		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++; } };
+		} }, sendMessage(message: { customType?: string; content?: string }) { notifications++; notificationContent = message.content ?? ""; if (message.customType) notificationTypes.push(message.customType); } };
 		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"),
@@ -50,11 +107,15 @@ describe("host workflow result publication", { skip: !available }, () => {
 			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" });
+				if (outcome === "retry-error" || outcome === "replacement-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 (outcome === "index-error" && !held && !indexFailureInjected && String(to).includes(`${path.sep}result-index${path.sep}sessions${path.sep}`)) {
+				indexFailureInjected = true;
+				throw Object.assign(new Error("injected workflow index EIO"), { code: "EIO" });
+			}
 			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;
@@ -92,31 +153,49 @@ describe("host workflow result publication", { skip: !available }, () => {
 			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);
+			if (outcome === "replacement-error") {
+				state.currentSessionId = "replacement-session";
+				state.completionOwnerId = "replacement-owner";
+			}
 			held = false;
-			if (outcome === "retry-error") {
+			if (outcome === "retry-error" || outcome === "replacement-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);
+				if (outcome === "retry-error") {
+					// A failed publication must wake its owner: without the terminal
+					// result file the watcher can never deliver the completion wake.
+					assert.equal(notifications, 1); assert.equal(refreshes, 1);
+					assert.match(notificationContent, /Failed to write async workflow result/);
+				} else {
+					assert.equal(notifications, 0, "an old workflow failure must not enter the replacement session");
+					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 expectedState = outcome === "index-error" ? "complete" : outcome;
+			assert.equal(state.asyncJobs.get(id)?.status, expectedState);
 			const terminalStatus = JSON.parse(fs.readFileSync(path.join(ASYNC_DIR, id, "status.json"), "utf8"));
-			assert.equal(terminalStatus.state, outcome);
+			assert.equal(terminalStatus.state, expectedState);
 			if (outcome === "stopped") assert.equal(terminalStatus.stopped, true);
 			assert.equal(notifications, 1); assert.equal(refreshes, 1);
+			if (outcome === "index-error") {
+				assert.deepEqual(notificationTypes, ["subagent-notify"]);
+				assert.doesNotMatch(fs.readFileSync(path.join(ASYNC_DIR, id, "events.jsonl"), "utf8"), /subagent\.workflow\.result_write_failed/);
+			}
+			assert.ok(notificationContent.includes(`Retention-managed async directory: ${path.join(ASYNC_DIR, id)}`));
 			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); }
+			try { await bounded(outcome === "retry-error" || outcome === "replacement-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

@@ -18,7 +18,7 @@ import type { SteeringStatus } from "../../src/shared/types.ts";
 import {
 	installAsyncExecutionHooks, available, isAsyncAvailable, ASYNC_DIR,
 	createSubagentExecutor, waitForMockPiCall, waitForAsyncState, tempDir, mockPi,
-	makeAsyncExecutor, readAsyncPayload, RESULTS_DIR, waitForAsyncEvent,
+	makeAsyncExecutor, readAsyncPayload, RESULTS_DIR,
 } from "../support/async-execution-fixture.ts";
 
 type SteeringTargets = { steering?: { recent: Array<{ id: string; targets: Array<{ index: number; state: string; reason?: string }> }> } };
@@ -30,13 +30,13 @@ function recentSteering(status: AsyncStatusPayload, requestId: string): { index:
 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 () => {
+	for (const outcome of ["complete", "failed", "stopped"]) it(`settles steering with the committed terminal result when index creation 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 executor = makeAsyncExecutor([makeAgent("worker")]);
 		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,
@@ -62,26 +62,29 @@ describe("async workflow steer inbox", { skip: !available ? "pi packages not ava
 				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");
+			await waitForAsyncState(runId, (candidate) => candidate.state === outcome, 15_000);
 			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.state, outcome, "the matching committed payload authorizes the truthful terminal status");
+			assert.equal(typeof status.endedAt, "number");
 			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(ASYNC_DIR, ".active-runs", runId)), false);
 			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");
+			const committed = JSON.parse(fs.readFileSync(path.join(RESULTS_DIR, "result-pending", "session-index-steering", `${runId}.json`), "utf8"));
+			assert.equal(committed.runId, runId);
+			assert.equal(committed.sessionId, "session-index-steering");
+			assert.equal(committed.state, outcome);
+			if (outcome !== "complete") assert.equal(committed.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"/);
+			assert.match(journal, new RegExp(`"type":"subagent\\.workflow\\.completed"[^\\n]*"state":"${outcome}"`));
+			assert.doesNotMatch(journal, /"type":"subagent\.workflow\.result_write_failed"/);
 			releaseSteer();
 			await new Promise((resolve) => setTimeout(resolve, 350));
 			assert.equal(fs.readFileSync(path.join(asyncDir, "status.json"), "utf8"), before);
@@ -99,7 +102,7 @@ describe("async workflow steer inbox", { skip: !available ? "pi packages not ava
 		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 executor = makeAsyncExecutor([makeAgent("worker")]);
 		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;
@@ -164,7 +167,7 @@ describe("async workflow steer inbox", { skip: !available ? "pi packages not ava
 		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 executor = makeAsyncExecutor([makeAgent("worker")]);
 		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;
@@ -215,7 +218,7 @@ describe("async workflow steer inbox", { skip: !available ? "pi packages not ava
 		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 executor = makeAsyncExecutor([makeAgent("worker")]);
 
 		const launch = await executor.execute(
 			`workflow-steer-inbox-${Date.now().toString(36)}`,
@@ -275,7 +278,7 @@ describe("async workflow steer inbox", { skip: !available ? "pi packages not ava
 		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 executor = makeAsyncExecutor([makeAgent("worker")]);
 		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" })]);`