pi-subagents 0.45.2 → 0.46.0

package/src/missions/lifecycle.ts

@@ -160,7 +160,7 @@ function persistedBinding(binding: MissionLaunchBinding): PersistedMissionBindin
 	};
 }
 
-function writeAsyncBinding(asyncDir: string, binding: MissionLaunchBinding): void {
+export function writeMissionAsyncBinding(asyncDir: string, binding: MissionLaunchBinding): void {
 	writePrivateAtomicJson(path.join(asyncDir, MISSION_BINDING_FILE), persistedBinding(binding));
 }
 
@@ -210,7 +210,7 @@ export function attachMissionToLaunchResult(input: {
 		...(input.result.details.results.length === 1 && input.result.details.results[0]?.acceptance ? { acceptance: input.result.details.results[0].acceptance } : {}),
 	});
 	if (input.result.details.asyncDir) {
-		writeAsyncBinding(input.result.details.asyncDir, input.binding);
+		writeMissionAsyncBinding(input.result.details.asyncDir, input.binding);
 		const statusPath = path.join(input.result.details.asyncDir, "status.json");
 		if (fs.existsSync(statusPath)) {
 			try {
@@ -337,10 +337,29 @@ export function syncMissionFromAsyncCompletion(value: unknown): MissionRecord |
 				return total + (usageFromUnknown((result as { tokens?: unknown }).tokens)?.tokens ?? 0);
 			}, 0) }
 			: undefined);
+	const workflowRunId = typeof event.parentWorkflowRunId === "string" && event.parentWorkflowRunId.trim() ? event.parentWorkflowRunId.trim() : undefined;
+	const workflowKey = typeof event.workflowKey === "string" && event.workflowKey.trim() ? event.workflowKey.trim() : undefined;
+	const workflowChildStatus = runStatus === "complete" || runStatus === "completed" || event.success === true
+		? "completed"
+		: runStatus === "paused"
+			? "paused"
+			: runStatus === "stopped"
+				? "stopped"
+				: "failed";
+	const workflowChildTerminal = !["running", "queued", "active", "paused"].includes(workflowChildStatus);
 	return updateMission(binding.location, binding.missionId, {
 		status: missionStatusForRun(current, runId, runStatus),
 		addRuns: [{ runId, mode: typeof event.mode === "string" && ["single", "parallel", "chain", "workflow"].includes(event.mode) ? event.mode as SubagentRunMode : "external", asyncDir: event.asyncDir, status: runStatus, completedAt, ...(usage && usage.tokens > 0 ? { usage } : {}) }],
 		addArtifacts: artifacts,
+		...(workflowRunId && workflowKey ? { upsertWorkflowChildren: [{
+			workflowRunId,
+			key: workflowKey,
+			runId,
+			status: workflowChildStatus,
+			artifactPaths: artifacts.map((artifact) => artifact.path),
+			...(workflowChildTerminal ? { completedAt } : {}),
+			heartbeat: { status: workflowChildStatus, ...(summary ? { message: summary } : {}) },
+		}] } : {}),
 		...(summary ? { summary } : {}),
 	});
 }

package/src/missions/store.ts

@@ -27,6 +27,7 @@ import {
 	type MissionTokenBudget,
 	type MissionTokenUsage,
 	type MissionUpdateInput,
+	type MissionWorkflowChild,
 } from "./types.ts";
 
 const MISSION_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
@@ -149,6 +150,33 @@ function parseDecision(value: unknown, label: string): MissionDecision {
 	};
 }
 
+function parseWorkflowChild(value: unknown, label: string): MissionWorkflowChild {
+	const input = asObject(value, label);
+	const artifactPaths = input.artifactPaths === undefined ? [] : stringArray(input.artifactPaths, `${label}.artifactPaths`);
+	const heartbeat = input.heartbeat === undefined ? undefined : asObject(input.heartbeat, `${label}.heartbeat`);
+	return {
+		workflowRunId: requiredString(input.workflowRunId, `${label}.workflowRunId`),
+		key: validateMissionId(input.key, `${label}.key`),
+		status: requiredString(input.status, `${label}.status`),
+		startedAt: timestamp(input.startedAt, `${label}.startedAt`),
+		updatedAt: timestamp(input.updatedAt, `${label}.updatedAt`),
+		artifactPaths,
+		...(optionalString(input.runId, `${label}.runId`) ? { runId: input.runId as string } : {}),
+		...(optionalString(input.agent, `${label}.agent`) ? { agent: input.agent as string } : {}),
+		...(optionalString(input.task, `${label}.task`) ? { task: input.task as string } : {}),
+		...(optionalString(input.label, `${label}.label`) ? { label: input.label as string } : {}),
+		...(optionalString(input.phase, `${label}.phase`) ? { phase: input.phase as string } : {}),
+		...(input.completedAt !== undefined ? { completedAt: timestamp(input.completedAt, `${label}.completedAt`) } : {}),
+		...(optionalString(input.sessionPath, `${label}.sessionPath`) ? { sessionPath: input.sessionPath as string } : {}),
+		...(heartbeat ? { heartbeat: {
+			updatedAt: timestamp(heartbeat.updatedAt, `${label}.heartbeat.updatedAt`),
+			...(optionalString(heartbeat.status, `${label}.heartbeat.status`) ? { status: heartbeat.status as string } : {}),
+			...(optionalString(heartbeat.phase, `${label}.heartbeat.phase`) ? { phase: heartbeat.phase as string } : {}),
+			...(optionalString(heartbeat.message, `${label}.heartbeat.message`) ? { message: heartbeat.message as string } : {}),
+		} } : {}),
+	};
+}
+
 function parseArtifact(value: unknown, label: string): MissionArtifact {
 	const input = asObject(value, label);
 	const kind = requiredString(input.kind, `${label}.kind`) as MissionArtifactKind;
@@ -186,10 +214,12 @@ export function parseMissionRecord(value: unknown, source = "mission record"): M
 	const input = asObject(value, source);
 	if (input.schemaVersion !== 1) throw new Error(`${source}.schemaVersion must be 1`);
 	if (!Array.isArray(input.runs)) throw new Error(`${source}.runs must be an array`);
+	if (input.workflowChildren !== undefined && !Array.isArray(input.workflowChildren)) throw new Error(`${source}.workflowChildren must be an array`);
 	if (!Array.isArray(input.decisions)) throw new Error(`${source}.decisions must be an array`);
 	if (!Array.isArray(input.artifacts)) throw new Error(`${source}.artifacts must be an array`);
 	if (input.receipts !== undefined && !Array.isArray(input.receipts)) throw new Error(`${source}.receipts must be an array`);
 	const runs = input.runs as unknown[];
+	const workflowChildren = (input.workflowChildren ?? []) as unknown[];
 	const decisions = input.decisions as unknown[];
 	const artifacts = input.artifacts as unknown[];
 	const receipts = (input.receipts ?? []) as unknown[];
@@ -211,6 +241,7 @@ export function parseMissionRecord(value: unknown, source = "mission record"): M
 		createdAt: timestamp(input.createdAt, `${source}.createdAt`),
 		updatedAt: timestamp(input.updatedAt, `${source}.updatedAt`),
 		runs: runs.map((item, index) => parseRunLink(item, `${source}.runs[${index}]`)),
+		workflowChildren: workflowChildren.map((item, index) => parseWorkflowChild(item, `${source}.workflowChildren[${index}]`)),
 		decisions: decisions.map((item, index) => parseDecision(item, `${source}.decisions[${index}]`)),
 		artifacts: artifacts.map((item, index) => parseArtifact(item, `${source}.artifacts[${index}]`)),
 		receipts: receipts.map((item, index) => parseReceipt(item, `${source}.receipts[${index}]`)),
@@ -346,6 +377,7 @@ export function createMission(location: MissionStoreLocation, input: MissionCrea
 		updatedAt: createdAt,
 		cwd: location.projectRoot,
 		runs: [],
+		workflowChildren: [],
 		decisions: [],
 		artifacts: [],
 		receipts: [],
@@ -412,6 +444,28 @@ export function updateMission(location: MissionStoreLocation, missionId: string,
 		if (existingIndex === -1) runs.push(run);
 		else runs[existingIndex] = { ...runs[existingIndex]!, ...run };
 	}
+	const workflowChildren = [...current.workflowChildren];
+	for (const candidate of update.upsertWorkflowChildren ?? []) {
+		const nowIso = now.toISOString();
+		const parsed = parseWorkflowChild({
+			...candidate,
+			startedAt: candidate.startedAt ?? nowIso,
+			updatedAt: nowIso,
+			artifactPaths: candidate.artifactPaths ?? [],
+			...(candidate.heartbeat ? { heartbeat: { ...candidate.heartbeat, updatedAt: nowIso } } : {}),
+		}, "mission.update.upsertWorkflowChildren[]");
+		const existingIndex = workflowChildren.findIndex((child) => child.workflowRunId === parsed.workflowRunId && child.key === parsed.key);
+		if (existingIndex === -1) workflowChildren.push(parsed);
+		else {
+			const existing = workflowChildren[existingIndex]!;
+			workflowChildren[existingIndex] = parseWorkflowChild({
+				...existing,
+				...parsed,
+				startedAt: existing.startedAt,
+				artifactPaths: [...new Set([...existing.artifactPaths, ...parsed.artifactPaths])],
+			}, "mission.update.upsertWorkflowChildren[]");
+		}
+	}
 	const artifacts = [...current.artifacts];
 	for (const candidate of update.addArtifacts ?? []) {
 		const artifact = parseArtifact(candidate, "mission.update.addArtifacts[]");
@@ -439,6 +493,18 @@ export function updateMission(location: MissionStoreLocation, missionId: string,
 			...(decision.recommendation ? { recommendation: requiredString(decision.recommendation, "mission.update.addDecisions[].recommendation") } : {}),
 		})),
 	];
+	if (update.resolveDecision) {
+		const decisionId = validateMissionId(update.resolveDecision.id, "mission.update.resolveDecision.id");
+		const decisionIndex = decisions.findIndex((decision) => decision.id === decisionId);
+		if (decisionIndex === -1) throw new Error(`Decision '${decisionId}' was not found in mission '${missionId}'`);
+		if (decisions[decisionIndex]!.status === "resolved") throw new Error(`Decision '${decisionId}' is already resolved`);
+		decisions[decisionIndex] = {
+			...decisions[decisionIndex]!,
+			status: "resolved",
+			resolvedAt: createdAt,
+			resolution: requiredString(update.resolveDecision.resolution, "mission.update.resolveDecision.resolution").trim(),
+		};
+	}
 	const budget = update.budget !== undefined ? parseBudget(update.budget, "mission.update.budget") : current.budget;
 	const usage = update.usage !== undefined
 		? parseUsage(update.usage, "mission.update.usage")
@@ -452,10 +518,20 @@ export function updateMission(location: MissionStoreLocation, missionId: string,
 				? { status: "active" }
 				: goal;
 	}
+	const hasOpenDecisions = decisions.some((decision) => decision.status === "open");
+	const requestedStatus = update.status !== undefined ? missionStatus(update.status, "mission.update.status") : undefined;
+	const candidateStatus = requestedStatus
+		?? (update.addDecisions?.length && current.status === "active"
+			? "needs_decision"
+			: update.resolveDecision && current.status === "needs_decision" && !hasOpenDecisions
+				? "active"
+				: current.status);
+	const decisionStatus = hasOpenDecisions && (candidateStatus === "active" || candidateStatus === "completed") ? "needs_decision" : candidateStatus;
 	const next: MissionRecord = {
 		...current,
 		updatedAt: createdAt,
 		runs,
+		workflowChildren,
 		artifacts,
 		receipts,
 		decisions,
@@ -463,7 +539,7 @@ export function updateMission(location: MissionStoreLocation, missionId: string,
 		...(update.objective !== undefined ? { objective: requiredString(update.objective, "mission.update.objective").trim() } : {}),
 		...(budget ? { budget } : {}),
 		...(goal ? { goal, usage } : {}),
-		...(update.status !== undefined ? { status: missionStatus(update.status, "mission.update.status") } : {}),
+		status: decisionStatus,
 		...(update.summary !== undefined ? { summary: requiredString(update.summary, "mission.update.summary") } : {}),
 		...(update.labels !== undefined ? { labels: stringArray(update.labels, "mission.update.labels") } : {}),
 		...(update.acceptance !== undefined ? { acceptance: update.acceptance } : {}),

package/src/missions/types.ts

@@ -51,6 +51,36 @@ export interface MissionDecision {
 	resolution?: string;
 }
 
+export interface MissionChildHeartbeat {
+	updatedAt: string;
+	status?: string;
+	phase?: string;
+	message?: string;
+}
+
+export interface MissionWorkflowChild {
+	workflowRunId: string;
+	key: string;
+	status: string;
+	startedAt: string;
+	updatedAt: string;
+	runId?: string;
+	agent?: string;
+	task?: string;
+	label?: string;
+	phase?: string;
+	completedAt?: string;
+	sessionPath?: string;
+	artifactPaths: string[];
+	heartbeat?: MissionChildHeartbeat;
+}
+
+export type MissionWorkflowChildUpdate = Pick<MissionWorkflowChild, "workflowRunId" | "key" | "status"> & Partial<Omit<MissionWorkflowChild, "workflowRunId" | "key" | "status" | "startedAt" | "updatedAt" | "artifactPaths" | "heartbeat">> & {
+	startedAt?: string;
+	artifactPaths?: string[];
+	heartbeat?: Omit<MissionChildHeartbeat, "updatedAt"> & { updatedAt?: string };
+};
+
 export interface MissionArtifact {
 	kind: MissionArtifactKind;
 	path: string;
@@ -80,6 +110,7 @@ export interface MissionRecord {
 	cwd?: string;
 	ownerSessionId?: string;
 	runs: MissionRunLink[];
+	workflowChildren: MissionWorkflowChild[];
 	decisions: MissionDecision[];
 	artifacts: MissionArtifact[];
 	receipts: MissionReceipt[];
@@ -151,7 +182,9 @@ export interface MissionUpdateInput {
 	labels?: string[];
 	acceptance?: unknown;
 	addRuns?: MissionRunLink[];
+	upsertWorkflowChildren?: MissionWorkflowChildUpdate[];
 	addArtifacts?: MissionArtifact[];
 	addDecisions?: Array<Omit<MissionDecision, "id" | "status" | "createdAt">>;
+	resolveDecision?: { id: string; resolution: string };
 	addReceipts?: Array<Omit<MissionReceipt, "createdAt">>;
 }

package/src/runs/background/async-execution.ts

@@ -1197,6 +1197,10 @@ export function executeAsyncChain(
 /**
  * Execute a single agent asynchronously
  */
+export function workflowAwaitedAsyncResultPath(asyncDir: string): string {
+	return path.join(asyncDir, "workflow-result.json");
+}
+
 export function executeAsyncSingle(
 	id: string,
 	params: AsyncSingleParams,
@@ -1456,7 +1460,9 @@ export function executeAsyncSingle(
 						...(resolvedToolBudget.budget ? { toolBudget: resolvedToolBudget.budget } : {}),
 					},
 				],
-				resultPath: inheritedNestedRoute ? nestedResultsPath(inheritedNestedRoute.rootRunId, id) : path.join(DIRS.results, `${id}.json`),
+				resultPath: params.parentWorkflowRunId !== undefined && params.revivalLease !== undefined
+					? workflowAwaitedAsyncResultPath(asyncDir)
+					: inheritedNestedRoute ? nestedResultsPath(inheritedNestedRoute.rootRunId, id) : path.join(DIRS.results, `${id}.json`),
 				cwd: runnerCwd,
 				placeholder: "{previous}",
 				maxOutput,

package/src/runs/background/completion-replay.ts

@@ -0,0 +1,267 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { writePrivateAtomicJson } from "../../shared/atomic-json.ts";
+import type { WaitCompletion } from "../../shared/types.ts";
+import { utf8Tail } from "../../shared/utf8.ts";
+
+const REPLAY_VERSION = 1;
+const ARCHIVE_VERSION = 1;
+const ARCHIVE_TEXT_LIMIT_BYTES = 64 * 1024;
+const REPLAY_DIR_NAME = "completion-replay";
+const ARCHIVE_DIR_NAME = "output-archives";
+
+export interface CompletionArchiveEntry {
+	agent?: string;
+	source: "output-artifact" | "session" | "result-tail";
+	path?: string;
+	text?: string;
+	truncated?: boolean;
+}
+
+export interface CompletionArchive {
+	version: 1;
+	runId: string;
+	createdAt: number;
+	entries: CompletionArchiveEntry[];
+}
+
+export interface CompletionReplayRecord {
+	version: 1;
+	runId: string;
+	sessionId: string;
+	completedAt: number;
+	expiresAt: number;
+	completion: WaitCompletion;
+	archivePath: string;
+}
+
+function safeRunFile(runId: string): string {
+	return `${encodeURIComponent(runId)}.json`;
+}
+
+export function completionReplayPath(resultsDir: string, runId: string): string {
+	return path.join(resultsDir, REPLAY_DIR_NAME, safeRunFile(runId));
+}
+
+export function completionArchivePath(resultsDir: string, runId: string): string {
+	return path.join(resultsDir, ARCHIVE_DIR_NAME, safeRunFile(runId));
+}
+
+function nonEmptyString(value: unknown): string | undefined {
+	return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function existingFile(value: unknown): string | undefined {
+	const filePath = nonEmptyString(value);
+	if (!filePath) return undefined;
+	try {
+		return fs.statSync(filePath).isFile() ? filePath : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function outputArtifactPath(child: Record<string, unknown>): string | undefined {
+	if (!child.artifactPaths || typeof child.artifactPaths !== "object" || Array.isArray(child.artifactPaths)) return undefined;
+	return existingFile((child.artifactPaths as Record<string, unknown>).outputPath);
+}
+
+/** Create a small archive that references saved child artifacts and retains only bounded fallback output text. */
+export function writeCompletionArchive(resultsDir: string, runId: string, data: Record<string, unknown>, createdAt: number): string {
+	const entries: CompletionArchiveEntry[] = [];
+	const fallback: string[] = [];
+	const results = Array.isArray(data.results) ? data.results : [];
+	for (const value of results) {
+		if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+		const child = value as Record<string, unknown>;
+		const agent = nonEmptyString(child.agent);
+		const artifactPath = outputArtifactPath(child);
+		if (artifactPath) {
+			entries.push({ ...(agent ? { agent } : {}), source: "output-artifact", path: artifactPath });
+			continue;
+		}
+		const sessionPath = existingFile(child.sessionFile);
+		if (sessionPath) {
+			entries.push({ ...(agent ? { agent } : {}), source: "session", path: sessionPath });
+			continue;
+		}
+		const output = nonEmptyString(child.output);
+		const error = nonEmptyString(child.error);
+		if (output || error) {
+			fallback.push([agent ? `[${agent}]` : undefined, error ? `Error: ${error}` : undefined, output].filter(Boolean).join("\n"));
+		}
+	}
+	if (results.length === 0) {
+		const sessionPath = existingFile(data.sessionFile);
+		if (sessionPath) entries.push({ source: "session", path: sessionPath });
+	}
+	if (entries.length === 0 && fallback.length === 0) {
+		const summary = nonEmptyString(data.summary);
+		if (summary) fallback.push(summary);
+	}
+	if (fallback.length > 0) {
+		const bounded = utf8Tail(fallback.join("\n\n"), ARCHIVE_TEXT_LIMIT_BYTES);
+		entries.push({ source: "result-tail", text: bounded.text, ...(bounded.truncated ? { truncated: true } : {}) });
+	}
+	const archive: CompletionArchive = { version: ARCHIVE_VERSION, runId, createdAt, entries };
+	const archivePath = completionArchivePath(resultsDir, runId);
+	writePrivateAtomicJson(archivePath, archive);
+	return archivePath;
+}
+
+function parseCompletion(value: unknown, runId: string): WaitCompletion | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	const completion = value as Partial<WaitCompletion>;
+	if (completion.runId !== runId) return undefined;
+	return completion as WaitCompletion;
+}
+
+function parseReplay(value: unknown): CompletionReplayRecord | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	const record = value as Partial<CompletionReplayRecord>;
+	if (record.version !== REPLAY_VERSION
+		|| typeof record.runId !== "string"
+		|| typeof record.sessionId !== "string"
+		|| typeof record.completedAt !== "number"
+		|| typeof record.expiresAt !== "number"
+		|| typeof record.archivePath !== "string") return undefined;
+	const completion = parseCompletion(record.completion, record.runId);
+	return completion ? { ...record, completion } as CompletionReplayRecord : undefined;
+}
+
+function validateReplayRecord(resultsDir: string, runId: string, record: CompletionReplayRecord): CompletionReplayRecord | undefined {
+	if (record.runId !== runId) return undefined;
+	const archivePath = completionArchivePath(resultsDir, runId);
+	return path.resolve(record.archivePath) === path.resolve(archivePath)
+		? { ...record, archivePath, completion: { ...record.completion, archivePath } }
+		: undefined;
+}
+
+function runIdFromReplayFile(file: string): string | undefined {
+	if (!file.endsWith(".json")) return undefined;
+	try {
+		const runId = decodeURIComponent(file.slice(0, -".json".length));
+		return safeRunFile(runId) === file ? runId : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function removeBestEffort(filePath: string): void {
+	try {
+		fs.rmSync(filePath, { force: true });
+	} catch { /* cleanup only */ }
+}
+
+function parseArchive(value: unknown): CompletionArchive | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	const archive = value as Partial<CompletionArchive>;
+	if (archive.version !== ARCHIVE_VERSION || typeof archive.runId !== "string" || typeof archive.createdAt !== "number" || !Array.isArray(archive.entries)) return undefined;
+	const entries = archive.entries.flatMap((value): CompletionArchiveEntry[] => {
+		if (!value || typeof value !== "object" || Array.isArray(value)) return [];
+		const entry = value as Partial<CompletionArchiveEntry>;
+		if (entry.source !== "output-artifact" && entry.source !== "session" && entry.source !== "result-tail") return [];
+		return [{
+			...(typeof entry.agent === "string" ? { agent: entry.agent } : {}),
+			source: entry.source,
+			...(typeof entry.path === "string" ? { path: entry.path } : {}),
+			...(typeof entry.text === "string" ? { text: entry.text } : {}),
+			...(entry.truncated === true ? { truncated: true } : {}),
+		}];
+	});
+	return { version: ARCHIVE_VERSION, runId: archive.runId, createdAt: archive.createdAt, entries };
+}
+
+/** Persist a terminal completion before its one-shot result file is removed. */
+export function writeCompletionReplay(input: {
+	resultsDir: string;
+	runId: string;
+	sessionId: string;
+	completion: WaitCompletion;
+	data: Record<string, unknown>;
+	now: number;
+	ttlMs: number;
+}): CompletionReplayRecord {
+	const archivePath = writeCompletionArchive(input.resultsDir, input.runId, input.data, input.now);
+	const completion = { ...input.completion, archivePath };
+	const record: CompletionReplayRecord = {
+		version: REPLAY_VERSION,
+		runId: input.runId,
+		sessionId: input.sessionId,
+		completedAt: input.now,
+		expiresAt: input.now + input.ttlMs,
+		completion,
+		archivePath,
+	};
+	writePrivateAtomicJson(completionReplayPath(input.resultsDir, input.runId), record);
+	cleanupCompletionReplay(input.resultsDir, input.now, input.ttlMs);
+	return record;
+}
+
+/** Read a current replay record. Unknown fields are ignored and unknown versions are skipped. */
+export function readCompletionReplay(resultsDir: string, runId: string, options: { sessionId?: string; now?: number } = {}): CompletionReplayRecord | undefined {
+	const replayPath = completionReplayPath(resultsDir, runId);
+	let parsed: CompletionReplayRecord | undefined;
+	try {
+		parsed = parseReplay(JSON.parse(fs.readFileSync(replayPath, "utf-8")));
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+		throw error;
+	}
+	if (!parsed) return undefined;
+	const safeRecord = validateReplayRecord(resultsDir, runId, parsed);
+	if (!safeRecord) {
+		removeBestEffort(replayPath);
+		return undefined;
+	}
+	parsed = safeRecord;
+	if (options.sessionId !== undefined && parsed.sessionId !== options.sessionId) return undefined;
+	if (parsed.expiresAt <= (options.now ?? Date.now())) {
+		removeBestEffort(replayPath);
+		removeBestEffort(parsed.archivePath);
+		return undefined;
+	}
+	return parsed;
+}
+
+export function readCompletionArchive(archivePath: string): CompletionArchive | undefined {
+	try {
+		return parseArchive(JSON.parse(fs.readFileSync(archivePath, "utf-8")));
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+		throw error;
+	}
+}
+
+/** Opportunistically remove expired replay and orphan archive files without affecting delivery. */
+export function cleanupCompletionReplay(resultsDir: string, now: number, maxAgeMs: number): void {
+	const replayDir = path.join(resultsDir, REPLAY_DIR_NAME);
+	try {
+		for (const file of fs.readdirSync(replayDir)) {
+			const runId = runIdFromReplayFile(file);
+			if (!runId) continue;
+			const filePath = path.join(replayDir, file);
+			try {
+				const record = parseReplay(JSON.parse(fs.readFileSync(filePath, "utf-8")));
+				const safeRecord = record ? validateReplayRecord(resultsDir, runId, record) : undefined;
+				if (record && !safeRecord) {
+					fs.rmSync(filePath, { force: true });
+				} else if (safeRecord && safeRecord.expiresAt <= now) {
+					fs.rmSync(filePath, { force: true });
+					fs.rmSync(safeRecord.archivePath, { force: true });
+				} else if (!record && now - fs.statSync(filePath).mtimeMs > maxAgeMs) {
+					fs.rmSync(filePath, { force: true });
+				}
+			} catch { /* one bad entry must not block cleanup */ }
+		}
+	} catch { /* replay directory may not exist yet */ }
+	const archiveDir = path.join(resultsDir, ARCHIVE_DIR_NAME);
+	try {
+		for (const file of fs.readdirSync(archiveDir)) {
+			const filePath = path.join(archiveDir, file);
+			try {
+				if (now - fs.statSync(filePath).mtimeMs > maxAgeMs) fs.rmSync(filePath, { force: true });
+			} catch { /* one bad entry must not block cleanup */ }
+		}
+	} catch { /* archive directory may not exist yet */ }
+}

package/src/runs/background/result-watcher.ts

@@ -21,6 +21,7 @@ import {
 import { projectNestedRegistryForRoot, sanitizeSummary } from "../shared/nested-events.ts";
 import { resolveWatchPath } from "../../shared/utils.ts";
 import { recordWaitCompletion } from "./wait-completions.ts";
+import { syncMissionFromAsyncCompletion } from "../../missions/lifecycle.ts";
 import type { CompletionNotifier, CompletionNotification } from "./notify.ts";
 
 const WATCHER_RESTART_DELAY_MS = 3000;
@@ -149,6 +150,11 @@ export function createResultWatcher(
 			const data = JSON.parse(fsApi.readFileSync(resultPath, "utf-8")) as ResultFileData;
 			if (typeof data.sessionId !== "string" || !data.sessionId) return;
 			const runId = data.runId ?? data.id ?? file.replace(/\.json$/i, "");
+			try {
+				syncMissionFromAsyncCompletion({ ...data, runId });
+			} catch (error) {
+				console.error(`Mission completion sync failed for '${resultPath}':`, error);
+			}
 			try {
 				deps.observeCompletion?.({ ...data, runId });
 			} catch (error) {
@@ -156,10 +162,12 @@ export function createResultWatcher(
 			}
 			const epoch = deliveryEpoch;
 			if (!ownsSession(data.sessionId, epoch)) return;
-			// Recorded before dedupe and before the unlink below: the result file is
-			// the only durable carrier of the per-run payload, and subagent_wait
-			// surfaces this record in details once the file is gone.
-			recordWaitCompletion(state, runId, data, Date.now(), completionTtlMs);
+			// Recorded before dedupe and before the unlink below so subagent_wait can
+			// use the in-memory record or its bounded durable replay after cleanup.
+			recordWaitCompletion(state, runId, data, Date.now(), completionTtlMs, {
+				resultsDir,
+				sessionId: data.sessionId,
+			});
 			const hasExplicitNestedChildren = data.nestedChildren !== undefined;
 			let nestedChildren = compactNestedResultChildren(sanitizeNestedResultChildren(data.nestedChildren, resultPath, "nestedChildren"));
 			if (!nestedChildren?.length && !hasExplicitNestedChildren) {

package/src/runs/background/wait-completions.ts

@@ -2,6 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { ArtifactPaths, SubagentState, WaitCompletion, WaitCompletionChild } from "../../shared/types.ts";
 import type { AsyncRunSummary } from "./async-status.ts";
+import { readCompletionReplay, writeCompletionReplay } from "./completion-replay.ts";
 
 function asNonEmptyString(value: unknown): string | undefined {
 	return typeof value === "string" && value ? value : undefined;
@@ -68,12 +69,34 @@ export function toWaitCompletion(data: Record<string, unknown>, runId: string):
  * file is deleted after delivery, so this record is the only in-process source once
  * the watcher has consumed it.
  */
-export function recordWaitCompletion(state: SubagentState, runId: string, data: Record<string, unknown>, now: number, ttlMs: number): void {
+export function recordWaitCompletion(
+	state: SubagentState,
+	runId: string,
+	data: Record<string, unknown>,
+	now: number,
+	ttlMs: number,
+	persistence?: { resultsDir: string; sessionId: string },
+): void {
 	const store = state.completedResults ??= new Map();
 	for (const [key, entry] of store) {
 		if (now - entry.seenAt > ttlMs) store.delete(key);
 	}
-	store.set(runId, { seenAt: now, completion: toWaitCompletion(data, runId) });
+	let completion = toWaitCompletion(data, runId);
+	if (persistence) {
+		try {
+			completion = writeCompletionReplay({
+				...persistence,
+				runId,
+				completion,
+				data,
+				now,
+				ttlMs,
+			}).completion;
+		} catch (error) {
+			console.error(`Failed to persist completion replay for '${runId}':`, error);
+		}
+	}
+	store.set(runId, { seenAt: now, completion });
 }
 
 /**
@@ -102,10 +125,21 @@ export function collectWaitCompletions(terminal: AsyncRunSummary[], state: Subag
 				});
 			}
 			// The watcher may have consumed the file between the store check and the
-			// read; its record is authoritative when present, otherwise the payload
-			// is gone and the text summary remains the only surface for this run.
+			// read. Prefer its in-memory record, then the durable replay written before
+			// result cleanup so watcher reloads do not lose completion details.
 			const late = state.completedResults?.get(run.id);
-			if (late) completions.push(late.completion);
+			if (late) {
+				completions.push(late.completion);
+				continue;
+			}
+			try {
+				const replay = readCompletionReplay(resultsDir, run.id, { sessionId: run.sessionId });
+				if (replay) completions.push(replay.completion);
+			} catch (replayError) {
+				throw new Error(`Failed to read completion replay for '${run.id}': ${errorMessage(replayError)}`, {
+					cause: replayError instanceof Error ? replayError : undefined,
+				});
+			}
 		}
 	}
 	return completions.length > 0 ? completions : undefined;