@selesai/code 0.13.0 → 0.13.2

package/dist/extensions/pi-subagents/test/unit/workflow-detach-reconcile.test.ts

@@ -147,8 +147,15 @@ describe("reconcileDetachedWorkflowChildCompletion", () => {
 	it("publishes a terminal result when the paused result file is already gone", () => {
 		const workflowRunId = "workflow-missing-result";
 		const asyncDir = path.join(DIRS.async, workflowRunId);
+		const childDir = path.join(DIRS.async, "child-1");
+		const requestedPath = path.join(asyncDir, "requested.md");
+		const savedPath = path.join(asyncDir, "saved.md");
+		const sessionFile = path.join(childDir, "session.jsonl");
 		fs.mkdirSync(asyncDir, { recursive: true });
+		fs.mkdirSync(childDir, { recursive: true });
 		fs.mkdirSync(DIRS.results, { recursive: true });
+		fs.writeFileSync(sessionFile, "", "utf-8");
+		fs.writeFileSync(path.join(childDir, "status.json"), JSON.stringify({ runId: "child-1", mode: "single", state: "complete", startedAt: 1, lastUpdate: 2, sessionId: "session-1", steps: [{ agent: "worker", status: "complete", sessionFile }] }), "utf-8");
 		const status = { ...pausedWorkflow("child-1"), runId: workflowRunId, sessionId: "session-1" };
 		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify(status), "utf-8");
 		writeWorkflowReceipt(asyncDir, buildWorkflowReceipt({
@@ -173,19 +180,397 @@ describe("reconcileDetachedWorkflowChildCompletion", () => {
 			state,
 			workflowRunId,
 			childRunId: "child-1",
-			result: { index: 0, agent: "worker", task: "t", exitCode: 0, usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 } },
+			result: { index: 0, agent: "worker", task: `Write your findings to exactly this path: ${requestedPath}`, exitCode: 0, sessionFile, savedOutputPath: savedPath, usage: { input: 100, output: 50, cacheRead: 25, cacheWrite: 5, cost: 0.001, turns: 1 } },
 		}), true);
-		const published = JSON.parse(fs.readFileSync(path.join(DIRS.results, `${workflowRunId}.json`), "utf-8")) as { state?: string; success?: boolean; error?: string; sessionId?: string; workflowReceipt?: { receipt?: { state?: string; entries?: Record<string, { resumability?: { state?: string; reason?: string } }> } } };
+		const published = JSON.parse(fs.readFileSync(path.join(DIRS.results, `${workflowRunId}.json`), "utf-8")) as { state?: string; success?: boolean; summary?: string; error?: string; sessionId?: string; workflowResolution?: string; recovery?: unknown[]; results?: Array<{ outputReference?: string; outputPathMapping?: unknown }>; workflowReceipt?: { receipt?: { state?: string; workflowResolution?: string; recovery?: unknown[]; entries?: Record<string, { resumability?: { state?: string; reason?: string } }> } } };
 		assert.equal(published.state, "failed");
 		assert.equal(published.success, false);
 		assert.match(published.error ?? "", /unsupported-continuation/);
+		assert.equal(published.workflowResolution, "settled-awaiting-resume");
+		assert.match(published.summary ?? "", /Workflow lanes settled/);
+		assert.deepEqual(published.recovery, [{ key: "detaches", call: "runs.run", resume: { workflowRunId, key: "detaches", latest: true }, taskRequired: true }]);
+		assert.ok(published.summary?.includes(`Output path mappings: 'detaches': requested ${requestedPath} -> saved ${savedPath}`));
+		assert.equal(published.results?.[0]?.outputReference, savedPath);
+		assert.deepEqual(published.results?.[0]?.outputPathMapping, { requestedPath, savedPath });
+		const publishedChild = published.results?.[0] as { usage?: unknown; sessionFile?: string } | undefined;
+		assert.deepEqual(publishedChild?.usage, { input: 100, output: 50, cacheRead: 25, cacheWrite: 5, cost: 0.001, turns: 1 });
+		assert.equal(publishedChild?.sessionFile, sessionFile);
 		assert.equal(published.sessionId, "session-1");
 		assert.equal(published.workflowReceipt?.receipt?.state, "failed");
-		assert.equal(published.workflowReceipt?.receipt?.entries?.detaches?.resumability?.state, "not-resumable");
-		assert.match(published.workflowReceipt?.receipt?.entries?.detaches?.resumability?.reason ?? "", /not found|Status file|too short/);
+		assert.equal(published.workflowReceipt?.receipt?.workflowResolution, "settled-awaiting-resume");
+		assert.deepEqual(published.workflowReceipt?.receipt?.recovery, published.recovery);
+		assert.equal(published.workflowReceipt?.receipt?.entries?.detaches?.resumability?.state, "resumable");
 		const events = fs.readFileSync(path.join(asyncDir, "events.jsonl"), "utf-8");
 		assert.match(events, /"type":"subagent.workflow.completed"/);
 		assert.match(events, /"state":"failed"/);
+		assert.match(events, /"workflowResolution":"settled-awaiting-resume"/);
+		assert.match(events, /"call":"runs.run"/);
+	});
+
+	it("classifies interrupted detached settlement without losing child details", () => {
+		const workflowRunId = "workflow-interrupted-handoff";
+		const asyncDir = path.join(DIRS.async, workflowRunId);
+		fs.mkdirSync(asyncDir, { recursive: true });
+		fs.mkdirSync(DIRS.results, { recursive: true });
+		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({ ...pausedWorkflow("child-interrupted"), runId: workflowRunId, sessionId: "session-1" }), "utf-8");
+		const state = { asyncJobs: new Map([[workflowRunId, { asyncId: workflowRunId, asyncDir, status: "paused" as const }]]) } as SubagentState;
+		assert.equal(reconcileDetachedWorkflowChildCompletion({
+			state,
+			workflowRunId,
+			childRunId: "child-interrupted",
+			result: { index: 0, agent: "worker", task: "t", exitCode: 0, interrupted: true, error: "operator stopped child", usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 } },
+		}), true);
+		const published = JSON.parse(fs.readFileSync(path.join(DIRS.results, `${workflowRunId}.json`), "utf-8")) as { workflowResolution?: string; error?: string; results?: Array<{ interrupted?: boolean; error?: string }> };
+		assert.equal(published.workflowResolution, "interrupted-child");
+		assert.equal(published.error, "operator stopped child");
+		assert.deepEqual(published.results, [{ workflowKey: "detaches", agent: "worker", runId: "child-interrupted", success: false, output: "", outputState: "absent", interrupted: true, error: "operator stopped child" }]);
+	});
+
+	it("prioritizes a failed sibling over interrupted detached evidence", () => {
+		const workflowRunId = "workflow-failed-sibling-handoff";
+		const asyncDir = path.join(DIRS.async, workflowRunId);
+		const status = { ...pausedWorkflow("child-interrupted"), runId: workflowRunId, sessionId: "session-1" };
+		status.steps!.push({ agent: "worker", workflowKey: "fails", runId: "child-failed", status: "paused", activityState: "needs_attention" });
+		fs.mkdirSync(asyncDir, { recursive: true });
+		fs.mkdirSync(DIRS.results, { recursive: true });
+		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify(status), "utf-8");
+		const state = { asyncJobs: new Map([[workflowRunId, { asyncId: workflowRunId, asyncDir, status: "paused" as const }]]) } as SubagentState;
+		let emitted: { name: string; payload: { error?: string; summary?: string; workflowResolution?: string } } | undefined;
+		assert.equal(reconcileDetachedWorkflowChildCompletion({
+			state,
+			workflowRunId,
+			childRunId: "child-failed",
+			result: { index: 1, agent: "worker", task: "t", exitCode: 1, error: "sibling boom", usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 } },
+		}), true);
+		const paused = JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8")) as { state?: string; error?: string; steps?: Array<{ runId?: string; error?: string }> };
+		assert.equal(paused.state, "paused");
+		assert.equal(paused.error, "Run 'worker' detached for intercom coordination.");
+		assert.equal(paused.steps?.find((step) => step.runId === "child-failed")?.error, "sibling boom");
+		assert.equal(reconcileDetachedWorkflowChildCompletion({
+			state,
+			workflowRunId,
+			childRunId: "child-interrupted",
+			result: { index: 0, agent: "worker", task: "t", exitCode: 0, interrupted: true, error: "operator stopped child", usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 } },
+			events: { emit: (name, payload) => { emitted = { name, payload: payload as { error?: string; summary?: string; workflowResolution?: string } }; } } as IntercomEventBus,
+		}), true);
+		const published = JSON.parse(fs.readFileSync(path.join(DIRS.results, `${workflowRunId}.json`), "utf-8")) as { workflowResolution?: string; error?: string; results?: Array<{ workflowKey?: string; interrupted?: boolean; error?: string }> };
+		assert.equal(published.workflowResolution, "failed-child");
+		assert.equal(published.error, "sibling boom");
+		assert.deepEqual(published.results?.find((child) => child.workflowKey === "detaches"), { workflowKey: "detaches", agent: "worker", runId: "child-interrupted", success: false, output: "", outputState: "absent", interrupted: true, error: "operator stopped child" });
+		assert.deepEqual(published.results?.find((child) => child.workflowKey === "fails"), { workflowKey: "fails", agent: "worker", runId: "child-failed", success: false, output: "", outputState: "absent", error: "sibling boom" });
+		assert.equal(emitted?.name, "subagent:async-complete");
+		assert.equal(emitted?.payload.summary, "sibling boom");
+		assert.equal(emitted?.payload.workflowResolution, "failed-child");
+		const events = fs.readFileSync(path.join(asyncDir, "events.jsonl"), "utf-8");
+		assert.match(events, /"workflowResolution":"failed-child"/);
+		assert.match(events, /"error":"sibling boom"/);
+		assert.doesNotMatch(events, /"error":"operator stopped child"/);
+	});
+
+	it("preserves a later failed child error after interruption settles first", () => {
+		const workflowRunId = "workflow-interrupted-first-handoff";
+		const asyncDir = path.join(DIRS.async, workflowRunId);
+		const status = { ...pausedWorkflow("child-interrupted"), runId: workflowRunId, sessionId: "session-1" };
+		status.steps!.push({ agent: "worker", workflowKey: "fails", runId: "child-failed", status: "paused", activityState: "needs_attention" });
+		fs.mkdirSync(asyncDir, { recursive: true });
+		fs.mkdirSync(DIRS.results, { recursive: true });
+		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify(status), "utf-8");
+		const state = { asyncJobs: new Map([[workflowRunId, { asyncId: workflowRunId, asyncDir, status: "paused" as const }]]) } as SubagentState;
+		assert.equal(reconcileDetachedWorkflowChildCompletion({
+			state,
+			workflowRunId,
+			childRunId: "child-interrupted",
+			result: { index: 0, agent: "worker", task: "t", exitCode: 0, interrupted: true, error: "operator stopped child" },
+		}), true);
+		const paused = JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8")) as { state?: string; steps?: Array<{ runId?: string; error?: string; interrupted?: boolean }> };
+		assert.equal(paused.state, "paused");
+		assert.equal(paused.steps?.find((step) => step.runId === "child-interrupted")?.interrupted, true);
+		assert.equal(paused.steps?.find((step) => step.runId === "child-interrupted")?.error, "operator stopped child");
+		assert.equal(reconcileDetachedWorkflowChildCompletion({
+			state,
+			workflowRunId,
+			childRunId: "child-failed",
+			result: { index: 1, agent: "worker", task: "t", exitCode: 1, error: "sibling boom" },
+		}), true);
+		const published = JSON.parse(fs.readFileSync(path.join(DIRS.results, `${workflowRunId}.json`), "utf-8")) as { workflowResolution?: string; error?: string; summary?: string; results?: Array<{ workflowKey?: string; error?: string; interrupted?: boolean }> };
+		assert.equal(published.workflowResolution, "failed-child");
+		assert.equal(published.error, "sibling boom");
+		assert.equal(published.summary, "sibling boom");
+		assert.equal(published.results?.find((child) => child.workflowKey === "detaches")?.error, "operator stopped child");
+		assert.equal(published.results?.find((child) => child.workflowKey === "detaches")?.interrupted, true);
+		assert.equal(published.results?.find((child) => child.workflowKey === "fails")?.error, "sibling boom");
+	});
+
+	it("preserves an interrupted child error after a later sibling succeeds", () => {
+		const workflowRunId = "workflow-interrupted-first-success-final";
+		const asyncDir = path.join(DIRS.async, workflowRunId);
+		const status = { ...pausedWorkflow("child-interrupted"), runId: workflowRunId, sessionId: "session-1" };
+		status.steps!.push({ agent: "worker", workflowKey: "passes", runId: "child-passes", status: "paused", activityState: "needs_attention" });
+		fs.mkdirSync(asyncDir, { recursive: true });
+		fs.mkdirSync(DIRS.results, { recursive: true });
+		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify(status), "utf-8");
+		const state = { asyncJobs: new Map([[workflowRunId, { asyncId: workflowRunId, asyncDir, status: "paused" as const }]]) } as SubagentState;
+		assert.equal(reconcileDetachedWorkflowChildCompletion({
+			state,
+			workflowRunId,
+			childRunId: "child-interrupted",
+			result: { index: 0, agent: "worker", task: "t", exitCode: 0, interrupted: true, error: "operator stopped child" },
+		}), true);
+		assert.equal(reconcileDetachedWorkflowChildCompletion({
+			state,
+			workflowRunId,
+			childRunId: "child-passes",
+			result: { index: 1, agent: "worker", task: "t", exitCode: 0 },
+		}), true);
+		const published = JSON.parse(fs.readFileSync(path.join(DIRS.results, `${workflowRunId}.json`), "utf-8")) as { workflowResolution?: string; error?: string; summary?: string; results?: Array<{ workflowKey?: string; error?: string; interrupted?: boolean }> };
+		assert.equal(published.workflowResolution, "interrupted-child");
+		assert.equal(published.error, "operator stopped child");
+		assert.equal(published.summary, "operator stopped child");
+		assert.equal(published.results?.find((child) => child.workflowKey === "detaches")?.error, "operator stopped child");
+		assert.equal(published.results?.find((child) => child.workflowKey === "detaches")?.interrupted, true);
+	});
+
+	it("classifies a stopped detached child as interrupted evidence", () => {
+		const workflowRunId = "workflow-stopped-handoff";
+		const asyncDir = path.join(DIRS.async, workflowRunId);
+		fs.mkdirSync(asyncDir, { recursive: true });
+		fs.mkdirSync(DIRS.results, { recursive: true });
+		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({ ...pausedWorkflow("child-stopped"), runId: workflowRunId, sessionId: "session-1" }), "utf-8");
+		const state = { asyncJobs: new Map([[workflowRunId, { asyncId: workflowRunId, asyncDir, status: "paused" as const }]]) } as SubagentState;
+		assert.equal(reconcileDetachedWorkflowChildCompletion({
+			state,
+			workflowRunId,
+			childRunId: "child-stopped",
+			result: { index: 0, agent: "worker", task: "t", exitCode: 1, stopped: true, error: "Subagent stopped by user.", usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 } },
+		}), true);
+		const published = JSON.parse(fs.readFileSync(path.join(DIRS.results, `${workflowRunId}.json`), "utf-8")) as { workflowResolution?: string; error?: string; results?: Array<{ workflowKey?: string; error?: string; interrupted?: boolean; stopped?: boolean }> };
+		assert.equal(published.workflowResolution, "interrupted-child");
+		assert.equal(published.error, "Subagent stopped by user.");
+		assert.deepEqual(published.results, [{ workflowKey: "detaches", agent: "worker", runId: "child-stopped", success: false, output: "", outputState: "absent", interrupted: true, stopped: true, error: "Subagent stopped by user." }]);
+	});
+
+	it("reconciles a foreground child without a persisted run id", () => {
+		const workflowRunId = "workflow-unbound-foreground-handoff";
+		const asyncDir = path.join(DIRS.async, workflowRunId);
+		const sessionFile = "/tmp/current-child.jsonl";
+		const status = { ...pausedWorkflow("placeholder", { runId: undefined, sessionFile }), runId: workflowRunId, sessionId: "session-1" };
+		fs.mkdirSync(asyncDir, { recursive: true });
+		fs.mkdirSync(DIRS.results, { recursive: true });
+		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify(status), "utf-8");
+		const state = { asyncJobs: new Map([[workflowRunId, { asyncId: workflowRunId, asyncDir, status: "paused" as const }]]) } as SubagentState;
+
+		assert.equal(reconcileDetachedWorkflowChildCompletion({
+			state,
+			workflowRunId,
+			childRunId: "current-child",
+			workflowKey: "detaches",
+			result: { index: 0, agent: "worker", task: "t", exitCode: 0, sessionFile },
+		}), true);
+		const published = JSON.parse(fs.readFileSync(path.join(DIRS.results, `${workflowRunId}.json`), "utf-8")) as { results?: Array<{ runId?: string; sessionFile?: string; success?: boolean }> };
+		assert.deepEqual(published.results, [{ workflowKey: "detaches", agent: "worker", runId: "current-child", sessionFile, success: true, output: "", outputState: "absent" }]);
+	});
+
+	it("reconciles a live foreground child without persisted identity fields", () => {
+		const workflowRunId = "workflow-missing-identity-handoff";
+		const childRunId = "current-child";
+		const asyncDir = path.join(DIRS.async, workflowRunId);
+		const status = { ...pausedWorkflow("placeholder", { runId: undefined, sessionFile: undefined }), runId: workflowRunId, sessionId: "session-1" };
+		fs.mkdirSync(asyncDir, { recursive: true });
+		fs.mkdirSync(DIRS.results, { recursive: true });
+		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify(status), "utf-8");
+		const state = {
+			asyncJobs: new Map([[workflowRunId, { asyncId: workflowRunId, asyncDir, status: "paused" as const }]]),
+			foregroundControls: new Map([[childRunId, { runId: childRunId, parentWorkflowRunId: workflowRunId, workflowKey: "detaches" }]]),
+		} as SubagentState;
+
+		assert.equal(reconcileDetachedWorkflowChildCompletion({
+			state,
+			workflowRunId,
+			childRunId,
+			workflowKey: "detaches",
+			result: { index: 0, agent: "worker", task: "t", exitCode: 0, sessionFile: "/tmp/current-child.jsonl" },
+		}), true);
+		const published = JSON.parse(fs.readFileSync(path.join(DIRS.results, `${workflowRunId}.json`), "utf-8")) as { results?: Array<{ runId?: string; success?: boolean }> };
+		assert.equal(published.results?.[0]?.runId, childRunId);
+		assert.equal(published.results?.[0]?.success, true);
+	});
+
+	it("does not reconcile ambiguous same-key live attempts without persisted identity", () => {
+		const workflowRunId = "workflow-ambiguous-missing-identity-handoff";
+		const childRunId = "stale-child";
+		const asyncDir = path.join(DIRS.async, workflowRunId);
+		const status = { ...pausedWorkflow("placeholder", { runId: undefined, sessionFile: undefined }), runId: workflowRunId, sessionId: "session-1" };
+		fs.mkdirSync(asyncDir, { recursive: true });
+		fs.mkdirSync(DIRS.results, { recursive: true });
+		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify(status), "utf-8");
+		const state = {
+			asyncJobs: new Map([[workflowRunId, { asyncId: workflowRunId, asyncDir, status: "paused" as const }]]),
+			foregroundControls: new Map([
+				[childRunId, { runId: childRunId, parentWorkflowRunId: workflowRunId, workflowKey: "detaches" }],
+				["replacement-child", { runId: "replacement-child", parentWorkflowRunId: workflowRunId, workflowKey: "detaches" }],
+			]),
+		} as SubagentState;
+
+		assert.equal(reconcileDetachedWorkflowChildCompletion({
+			state,
+			workflowRunId,
+			childRunId,
+			workflowKey: "detaches",
+			result: { index: 0, agent: "worker", task: "t", exitCode: 0, sessionFile: "/tmp/current-child.jsonl" },
+		}), false);
+		assert.equal(fs.existsSync(path.join(DIRS.results, `${workflowRunId}.json`)), false);
+	});
+
+	it("ignores stale completion when only the workflow key matches", () => {
+		const workflowRunId = "workflow-key-interrupted-handoff";
+		const asyncDir = path.join(DIRS.async, workflowRunId);
+		const status = { ...pausedWorkflow("placeholder", { runId: undefined, sessionFile: "/tmp/replacement-child.jsonl" }), runId: workflowRunId, sessionId: "session-1" };
+		fs.mkdirSync(asyncDir, { recursive: true });
+		fs.mkdirSync(DIRS.results, { recursive: true });
+		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify(status), "utf-8");
+		const state = { asyncJobs: new Map([[workflowRunId, { asyncId: workflowRunId, asyncDir, status: "paused" as const }]]) } as SubagentState;
+		assert.equal(reconcileDetachedWorkflowChildCompletion({
+			state,
+			workflowRunId,
+			childRunId: "latest-child-run",
+			workflowKey: "detaches",
+			result: { index: 0, agent: "worker", task: "t", exitCode: 0, interrupted: true, sessionFile: "/tmp/stale-child.jsonl", usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 } },
+		}), false);
+		const persisted = JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8")) as AsyncStatus;
+		assert.equal(persisted.steps?.[0]?.runId, undefined);
+		assert.equal(persisted.steps?.[0]?.sessionFile, "/tmp/replacement-child.jsonl");
+		assert.equal(persisted.steps?.[0]?.status, "paused");
+		assert.equal(fs.existsSync(path.join(DIRS.results, `${workflowRunId}.json`)), false);
+	});
+
+	it("classifies a stopped sibling as interrupted terminal evidence", () => {
+		const workflowRunId = "workflow-stopped-sibling-handoff";
+		const asyncDir = path.join(DIRS.async, workflowRunId);
+		const status = { ...pausedWorkflow("child-final"), runId: workflowRunId, sessionId: "session-1" };
+		status.steps!.push({ agent: "worker", workflowKey: "stopped", runId: "child-stopped", status: "stopped", stopped: true });
+		fs.mkdirSync(asyncDir, { recursive: true });
+		fs.mkdirSync(DIRS.results, { recursive: true });
+		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify(status), "utf-8");
+		const state = { asyncJobs: new Map([[workflowRunId, { asyncId: workflowRunId, asyncDir, status: "paused" as const }]]) } as SubagentState;
+		assert.equal(reconcileDetachedWorkflowChildCompletion({ state, workflowRunId, childRunId: "child-final", result: { index: 0, agent: "worker", task: "t", exitCode: 0, usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 } } }), true);
+		const published = JSON.parse(fs.readFileSync(path.join(DIRS.results, `${workflowRunId}.json`), "utf-8")) as { workflowResolution?: string; results?: Array<{ workflowKey?: string; stopped?: boolean }> };
+		assert.equal(published.workflowResolution, "interrupted-child");
+		assert.equal(published.results?.find((child) => child.workflowKey === "stopped")?.stopped, true);
+	});
+
+	it("keeps a detached timeout outcome local after fail-closed workflow settlement", () => {
+		const workflowRunId = "workflow-child-timeout-handoff";
+		const asyncDir = path.join(DIRS.async, workflowRunId);
+		const outcome = { state: "partial" as const, reason: "timeout" as const };
+		const status = { ...pausedWorkflow("child-timeout"), runId: workflowRunId, sessionId: "session-1" };
+		status.steps!.push({ agent: "worker", workflowKey: "still-open", runId: "child-open", status: "paused", activityState: "needs_attention" });
+		fs.mkdirSync(asyncDir, { recursive: true });
+		fs.mkdirSync(DIRS.results, { recursive: true });
+		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify(status), "utf-8");
+		writeWorkflowReceipt(asyncDir, buildWorkflowReceipt({
+			workflowRunId,
+			state: "paused",
+			children: [
+				{ key: "detaches", ok: false, agent: "worker", runId: "child-timeout", output: "paused", detached: true, artifactPaths: [], resumability: { state: "not-resumable", reason: "child detached" }, continuation: { runIds: ["child-timeout"] } },
+				{ key: "still-open", ok: false, agent: "worker", runId: "child-open", output: "paused", detached: true, artifactPaths: [], resumability: { state: "not-resumable", reason: "child detached" }, continuation: { runIds: ["child-open"] } },
+			],
+		}));
+		const state = { asyncJobs: new Map([[workflowRunId, { asyncId: workflowRunId, asyncDir, status: "paused" as const }]]) } as SubagentState;
+
+		assert.equal(reconcileDetachedWorkflowChildCompletion({
+			state,
+			workflowRunId,
+			childRunId: "child-timeout",
+			result: { index: 0, agent: "worker", task: "t", exitCode: 1, timedOut: true, error: "Subagent timed out after 50ms." },
+		}), true);
+		const paused = JSON.parse(fs.readFileSync(path.join(DIRS.results, `${workflowRunId}.json`), "utf-8")) as { state?: string; terminalOutcome?: unknown; results?: Array<{ workflowKey?: string; terminalOutcome?: unknown }>; workflowReceipt?: { receipt?: { terminalOutcome?: unknown; entries?: Record<string, { terminalOutcome?: unknown }> } } };
+		assert.equal(paused.state, "paused");
+		assert.equal(paused.terminalOutcome, undefined);
+		assert.equal(paused.workflowReceipt?.receipt?.terminalOutcome, undefined);
+		assert.deepEqual(paused.results?.find((child) => child.workflowKey === "detaches")?.terminalOutcome, outcome);
+		assert.deepEqual(paused.workflowReceipt?.receipt?.entries?.detaches?.terminalOutcome, outcome);
+
+		assert.equal(reconcileDetachedWorkflowChildCompletion({
+			state,
+			workflowRunId,
+			childRunId: "child-open",
+			result: { index: 1, agent: "worker", task: "t", exitCode: 0 },
+		}), true);
+		const terminal = JSON.parse(fs.readFileSync(path.join(DIRS.results, `${workflowRunId}.json`), "utf-8")) as { state?: string; terminalOutcome?: unknown; results?: Array<{ workflowKey?: string; terminalOutcome?: unknown }>; workflowReceipt?: { receipt?: { terminalOutcome?: unknown; entries?: Record<string, { terminalOutcome?: unknown }> } } };
+		assert.equal(terminal.state, "failed");
+		assert.equal(terminal.terminalOutcome, undefined);
+		assert.equal(terminal.workflowReceipt?.receipt?.terminalOutcome, undefined);
+		assert.deepEqual(terminal.results?.find((child) => child.workflowKey === "detaches")?.terminalOutcome, outcome);
+		assert.deepEqual(terminal.workflowReceipt?.receipt?.entries?.detaches?.terminalOutcome, outcome);
+	});
+
+	it("preserves sibling output path mappings when rebuilding from workflow status", () => {
+		const workflowRunId = "workflow-sibling-mappings";
+		const asyncDir = path.join(DIRS.async, workflowRunId);
+		const firstRequestedPath = path.join(asyncDir, "first-requested.md");
+		const firstSavedPath = path.join(asyncDir, "first-saved.md");
+		const secondRequestedPath = path.join(asyncDir, "second-requested.md");
+		const secondSavedPath = path.join(asyncDir, "second-saved.md");
+		fs.mkdirSync(asyncDir, { recursive: true });
+		fs.mkdirSync(DIRS.results, { recursive: true });
+		const status = { ...pausedWorkflow("child-1"), runId: workflowRunId, sessionId: "session-1" };
+		status.steps!.push({
+			agent: "worker",
+			workflowKey: "second",
+			runId: "child-2",
+			status: "paused",
+			activityState: "needs_attention",
+		});
+		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify(status), "utf-8");
+		const state = {
+			asyncJobs: new Map([[workflowRunId, { asyncId: workflowRunId, asyncDir, status: "paused" as const }]]),
+		} as SubagentState;
+
+		assert.equal(reconcileDetachedWorkflowChildCompletion({
+			state,
+			workflowRunId,
+			childRunId: "child-1",
+			result: { index: 0, agent: "worker", task: `Write your findings to exactly this path: ${firstRequestedPath}`, exitCode: 0, savedOutputPath: firstSavedPath, usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 } },
+		}), true);
+		fs.rmSync(path.join(DIRS.results, `${workflowRunId}.json`));
+		assert.equal(reconcileDetachedWorkflowChildCompletion({
+			state,
+			workflowRunId,
+			childRunId: "child-2",
+			result: { index: 1, agent: "worker", task: `Write your findings to exactly this path: ${secondRequestedPath}`, exitCode: 0, savedOutputPath: secondSavedPath, usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 } },
+		}), true);
+
+		const published = JSON.parse(fs.readFileSync(path.join(DIRS.results, `${workflowRunId}.json`), "utf-8")) as { summary?: string; results?: Array<{ workflowKey?: string; outputPathMapping?: unknown }> };
+		assert.deepEqual(published.results?.map((child) => [child.workflowKey, child.outputPathMapping]), [
+			["detaches", { requestedPath: firstRequestedPath, savedPath: firstSavedPath }],
+			["second", { requestedPath: secondRequestedPath, savedPath: secondSavedPath }],
+		]);
+		assert.ok(published.summary?.includes(`'detaches': requested ${firstRequestedPath} -> saved ${firstSavedPath}`));
+		assert.ok(published.summary?.includes(`'second': requested ${secondRequestedPath} -> saved ${secondSavedPath}`));
+	});
+
+	it("skips non-object existing result entries while summarizing output mappings", () => {
+		const workflowRunId = "workflow-existing-non-object-results";
+		const asyncDir = path.join(DIRS.async, workflowRunId);
+		const requestedPath = path.join(asyncDir, "requested.md");
+		const savedPath = path.join(asyncDir, "saved.md");
+		fs.mkdirSync(asyncDir, { recursive: true });
+		fs.mkdirSync(DIRS.results, { recursive: true });
+		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({ ...pausedWorkflow("child-1"), runId: workflowRunId, sessionId: "session-1" }), "utf-8");
+		fs.writeFileSync(path.join(DIRS.results, `${workflowRunId}.json`), JSON.stringify({ activityState: "needs_attention", results: [null, { workflowKey: "detaches", runId: "child-1", success: false, output: "old", outputState: "present" }] }), "utf-8");
+		const state = { asyncJobs: new Map([[workflowRunId, { asyncId: workflowRunId, asyncDir, status: "paused" as const }]]) } as SubagentState;
+
+		assert.equal(reconcileDetachedWorkflowChildCompletion({
+			state,
+			workflowRunId,
+			childRunId: "child-1",
+			result: { index: 0, agent: "worker", task: `Write your findings to exactly this path: ${requestedPath}`, exitCode: 0, savedOutputPath: savedPath, usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 } },
+		}), true);
+
+		const published = JSON.parse(fs.readFileSync(path.join(DIRS.results, `${workflowRunId}.json`), "utf-8")) as { activityState?: string; summary?: string; results?: unknown[] };
+		assert.equal(published.activityState, undefined);
+		assert.equal(published.results?.[0], null);
+		assert.ok(published.summary?.includes(`'detaches': requested ${requestedPath} -> saved ${savedPath}`));
 	});
 
 	it("publishes detached completion when the workflow receipt is malformed", () => {
@@ -210,7 +595,7 @@ describe("reconcileDetachedWorkflowChildCompletion", () => {
 		const published = JSON.parse(fs.readFileSync(path.join(DIRS.results, `${workflowRunId}.json`), "utf-8")) as { state?: string; success?: boolean; error?: string; workflowReceipt?: unknown };
 		assert.equal(published.state, "failed");
 		assert.equal(published.success, false);
-		assert.match(published.error ?? "", /unsupported-continuation/);
+		assert.match(published.error ?? "", /evidence-persistence-failed/);
 		assert.equal(published.workflowReceipt, undefined);
 		const events = fs.readFileSync(path.join(asyncDir, "events.jsonl"), "utf-8");
 		assert.match(events, /"type":"subagent.workflow.receipt_write_failed"/);
@@ -245,10 +630,11 @@ describe("reconcileDetachedWorkflowChildCompletion", () => {
 			console.error = originalConsoleError;
 		}
 
-		const published = JSON.parse(fs.readFileSync(path.join(DIRS.results, `${workflowRunId}.json`), "utf-8")) as { state?: string; success?: boolean; error?: string; workflowReceipt?: unknown; reconciledFromDetachedChild?: string };
+		const published = JSON.parse(fs.readFileSync(path.join(DIRS.results, `${workflowRunId}.json`), "utf-8")) as { state?: string; success?: boolean; error?: string; summary?: string; workflowReceipt?: unknown; reconciledFromDetachedChild?: string };
 		assert.equal(published.state, "failed");
 		assert.equal(published.success, false);
-		assert.match(published.error ?? "", /unsupported-continuation/);
+		assert.match(published.error ?? "", /evidence-persistence-failed/);
+		assert.match(published.summary ?? "", /Available child evidence was preserved/);
 		assert.equal(published.workflowReceipt, undefined);
 		assert.equal(published.reconciledFromDetachedChild, "child-1");
 		assert.equal(emitted?.name, "subagent:async-complete");
@@ -260,7 +646,9 @@ describe("reconcileDetachedWorkflowChildCompletion", () => {
 			agent: "workflow",
 			success: false,
 			state: "failed",
-			summary: "unsupported-continuation: detached workflow child settled, but JavaScript workflow continuation was not persisted. Resume the workflow explicitly instead of treating the completed child as top-level workflow completion.",
+			workflowResolution: "settled-awaiting-resume",
+			recovery: [],
+			summary: published.summary,
 			reconciledFromDetachedChild: "child-1",
 			results: [{ workflowKey: "detaches", agent: "worker", runId: "child-1", success: true, output: "", outputState: "absent" }],
 			sessionId: "session-1",
@@ -270,6 +658,91 @@ describe("reconcileDetachedWorkflowChildCompletion", () => {
 		});
 	});
 
+	it("normalizes old external-cli child status while reconciling workflow receipts", () => {
+		const workflowRunId = "workflow-old-external-receipt";
+		const childRunId = "child-old-external";
+		const asyncDir = path.join(DIRS.async, workflowRunId);
+		const childDir = path.join(DIRS.async, childRunId);
+		fs.rmSync(asyncDir, { recursive: true, force: true });
+		fs.rmSync(childDir, { recursive: true, force: true });
+		fs.mkdirSync(asyncDir, { recursive: true });
+		fs.mkdirSync(childDir, { recursive: true });
+		fs.mkdirSync(DIRS.results, { recursive: true });
+		const status = { ...pausedWorkflow(childRunId), runId: workflowRunId, sessionId: "session-1" };
+		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify(status), "utf-8");
+		fs.writeFileSync(path.join(childDir, "status.json"), JSON.stringify({
+			runId: childRunId,
+			mode: "single",
+			state: "complete",
+			startedAt: 1,
+			lastUpdate: 2,
+			steps: [{ agent: "external", status: "complete", runner: { type: "external-cli", command: "review-cli", args: [], promptDelivery: "stdin", capabilities: { stop: true, steer: false, resume: false, structuredOutput: false, toolEvents: false } } }],
+		}), "utf-8");
+		writeWorkflowReceipt(asyncDir, buildWorkflowReceipt({
+			workflowRunId,
+			state: "paused",
+			children: [{ key: "detaches", ok: false, agent: "external", runId: childRunId, output: "paused", detached: true, artifactPaths: [], resumability: { state: "not-resumable", reason: "child detached" }, continuation: { runIds: [childRunId] } }],
+		}));
+		const state = { asyncJobs: new Map([[workflowRunId, { asyncId: workflowRunId, asyncDir, status: "paused" as const }]]) } as SubagentState;
+
+		assert.equal(reconcileDetachedWorkflowChildCompletion({
+			state,
+			workflowRunId,
+			childRunId,
+			result: { index: 0, agent: "external", task: "t", exitCode: 0, usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 } },
+		}), true);
+
+		const published = JSON.parse(fs.readFileSync(path.join(DIRS.results, `${workflowRunId}.json`), "utf-8")) as { workflowReceipt?: { receipt?: { entries?: Record<string, { externalAdapter?: { adapter?: { id?: string }; nonResumableReason?: string } }> } } };
+		assert.equal(published.workflowReceipt?.receipt?.entries?.detaches?.externalAdapter?.adapter?.id, "external-cli");
+		assert.match(published.workflowReceipt?.receipt?.entries?.detaches?.externalAdapter?.nonResumableReason ?? "", /no durable external session identity/);
+		assert.doesNotMatch(fs.readFileSync(path.join(asyncDir, "events.jsonl"), "utf-8"), /receipt_write_failed/);
+	});
+
+	it("keeps mixed Pi and external workflow receipt entries on their computed resumability", () => {
+		const workflowRunId = "workflow-mixed-receipt";
+		const childRunId = "child-mixed";
+		const asyncDir = path.join(DIRS.async, workflowRunId);
+		const childDir = path.join(DIRS.async, childRunId);
+		fs.rmSync(asyncDir, { recursive: true, force: true });
+		fs.rmSync(childDir, { recursive: true, force: true });
+		fs.mkdirSync(asyncDir, { recursive: true });
+		fs.mkdirSync(childDir, { recursive: true });
+		fs.mkdirSync(DIRS.results, { recursive: true });
+		const status = { ...pausedWorkflow(childRunId), runId: workflowRunId, sessionId: "session-1" };
+		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify(status), "utf-8");
+		const sessionFile = path.join(childDir, "pi-session.jsonl");
+		fs.writeFileSync(sessionFile, "", "utf-8");
+		fs.writeFileSync(path.join(childDir, "status.json"), JSON.stringify({
+			runId: childRunId,
+			mode: "parallel",
+			state: "complete",
+			startedAt: 1,
+			lastUpdate: 2,
+			steps: [
+				{ agent: "worker", status: "complete", sessionFile },
+				{ agent: "external", status: "complete", runner: { type: "external-cli", command: "review-cli", args: [], promptDelivery: "stdin" } },
+			],
+		}), "utf-8");
+		writeWorkflowReceipt(asyncDir, buildWorkflowReceipt({
+			workflowRunId,
+			state: "paused",
+			children: [{ key: "detaches", ok: false, agent: "worker", runId: childRunId, output: "paused", detached: true, artifactPaths: [], resumability: { state: "not-resumable", reason: "child detached" }, continuation: { runIds: [childRunId] } }],
+		}));
+		const state = { asyncJobs: new Map([[workflowRunId, { asyncId: workflowRunId, asyncDir, status: "paused" as const }]]) } as SubagentState;
+
+		assert.equal(reconcileDetachedWorkflowChildCompletion({
+			state,
+			workflowRunId,
+			childRunId,
+			result: { index: 0, agent: "worker", task: "t", exitCode: 0, sessionFile, usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 } },
+		}), true);
+
+		const published = JSON.parse(fs.readFileSync(path.join(DIRS.results, `${workflowRunId}.json`), "utf-8")) as { workflowReceipt?: { receipt?: { entries?: Record<string, { resumability?: { state?: string; reason?: string }; externalAdapter?: unknown }> } } };
+		assert.equal(published.workflowReceipt?.receipt?.entries?.detaches?.resumability?.state, "not-resumable");
+		assert.doesNotMatch(published.workflowReceipt?.receipt?.entries?.detaches?.resumability?.reason ?? "", /no durable external session identity/);
+		assert.equal(published.workflowReceipt?.receipt?.entries?.detaches?.externalAdapter, undefined);
+	});
+
 	it("does not log workflow completion while another detached child is still open", () => {
 		const workflowRunId = "workflow-still-paused";
 		const asyncDir = path.join(DIRS.async, workflowRunId);
@@ -296,7 +769,9 @@ describe("reconcileDetachedWorkflowChildCompletion", () => {
 			result: { index: 0, agent: "worker", task: "t", exitCode: 0, usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 } },
 		}), true);
 		assert.equal(fs.existsSync(path.join(asyncDir, "events.jsonl")), false);
-		const published = JSON.parse(fs.readFileSync(path.join(DIRS.results, `${workflowRunId}.json`), "utf-8")) as { state?: string };
+		const published = JSON.parse(fs.readFileSync(path.join(DIRS.results, `${workflowRunId}.json`), "utf-8")) as { state?: string; workflowResolution?: string; recovery?: unknown };
 		assert.equal(published.state, "paused");
+		assert.equal(published.workflowResolution, undefined);
+		assert.equal(published.recovery, undefined);
 	});
 });

package/dist/extensions/pi-subagents/test/unit/workflow-launch-params.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
-import { prepareWorkflowLaunchParams, sanitizeRunPathSegment } from "../../src/runs/foreground/subagent-executor.ts";
+import { prepareWorkflowLaunchParams, promptAuditRedoParams, sanitizeRunPathSegment } from "../../src/runs/foreground/subagent-executor.ts";
 
 describe("workflow launch params", () => {
 	it("keeps omitted workflow child async foreground", () => {
@@ -21,6 +21,42 @@ describe("workflow launch params", () => {
 		);
 	});
 
+	it("marks only new async workflow children to preserve live supervisor-detach awaits", () => {
+		// Retained workflow children already use the async result-file await path.
+		assert.equal(prepareWorkflowLaunchParams(
+			{},
+			{ agent: "worker", task: "Run" },
+			"workflow-run",
+			"run",
+			{ awaitDetachedChild: true },
+		).workflowAwaitDetached, true);
+		assert.equal(prepareWorkflowLaunchParams(
+			{},
+			{ resume: "retained-run", task: "Continue" },
+			"workflow-run",
+			"resume",
+			{ awaitDetachedChild: true },
+		).workflowAwaitDetached, undefined);
+	});
+
+	it("scrubs the live workflow detach bridge from prompt-audit redo params", () => {
+		const workflowChild = prepareWorkflowLaunchParams(
+			{},
+			{ agent: "worker", task: "Run" },
+			"workflow-run",
+			"run",
+			{ awaitDetachedChild: true },
+		);
+		assert.equal(workflowChild.workflowAwaitDetached, true);
+
+		const redo = promptAuditRedoParams(workflowChild, "Run with narrower guidance");
+		assert.equal(redo.workflowAwaitDetached, undefined);
+		assert.equal(redo.workflowParentRunId, undefined);
+		assert.equal(redo.workflowKey, undefined);
+		assert.equal(redo.async, false);
+		assert.equal(redo.task, "Run with narrower guidance");
+	});
+
 	it("passes an omitted child timeout parent deadline for default resolution", () => {
 		const parentDeadlineAt = Date.now() + 60_000;
 		const params = prepareWorkflowLaunchParams(
@@ -262,12 +298,11 @@ describe("workflow launch params", () => {
 	it("preserves execution limits and fan-out identity when routing retained resume items", () => {
 		assert.deepEqual(
 			prepareWorkflowLaunchParams(
-				{ turnBudget: { maxTurns: 8 }, toolBudget: { hard: 12, block: ["read"] } },
+				{ toolBudget: { hard: 12, block: ["read"] } },
 				{
 					resume: " retained-run ",
 					task: "Continue carefully",
 					maxRuntimeMs: 5_000,
-					turnBudget: { maxTurns: 3, graceTurns: 1 },
 					toolBudget: { soft: 2, hard: 4, block: "*" },
 				},
 				"workflow-run",
@@ -283,7 +318,6 @@ describe("workflow launch params", () => {
 				runFanoutBudget: { version: 1, rootRunId: "root-run", directory: "/tmp/fanout", limit: 64, parentPath: "parent/workflow[continue]" },
 				mission: false,
 				timeoutMs: 5_000,
-				turnBudget: { maxTurns: 3, graceTurns: 1 },
 				toolBudget: { soft: 2, hard: 4, block: "*" },
 			},
 		);