pi-subagents 0.45.2 → 0.47.0

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/control-channel.ts

@@ -21,6 +21,16 @@ import { POLL_INTERVAL_MS } from "../../shared/types.ts";
 import { resolveWatchPath } from "../../shared/utils.ts";
 
 export type ControlChannelFs = Pick<typeof fs, "mkdirSync" | "existsSync" | "rmSync" | "watch" | "readdirSync" | "readFileSync" | "realpathSync">;
+
+function writeJsonToExistingDir(filePath: string, payload: object): void {
+	const tempPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`);
+	try {
+		fs.writeFileSync(tempPath, JSON.stringify(payload, null, 2), { encoding: "utf-8", flag: "wx" });
+		fs.renameSync(tempPath, filePath);
+	} finally {
+		fs.rmSync(tempPath, { force: true });
+	}
+}
 export type ControlChannelTimers = { setInterval: typeof setInterval; clearInterval: typeof clearInterval };
 type KillFn = (pid: number, signal?: NodeJS.Signals | 0) => unknown;
 
@@ -205,6 +215,13 @@ export function writeSteerRequestToDir(dir: string, request: SteerRequest): stri
 	return requestPath;
 }
 
+export function writeSteerRequestToExistingDir(dir: string, request: SteerRequest): string {
+	if (!validSteerRequest(request)) throw new Error("steer request is malformed or exceeds transport limits.");
+	const requestPath = path.join(dir, steerRequestFileName(request));
+	writeJsonToExistingDir(requestPath, request);
+	return requestPath;
+}
+
 export function writeSteerCapabilityAt(filePath: string, capability: Omit<SteerCapability, "type" | "protocolVersion">): string {
 	assertChildIndex(capability.index);
 	if (!Number.isInteger(capability.pid) || capability.pid <= 0) throw new Error("steer capability pid must be a positive integer.");
@@ -385,6 +402,25 @@ export function consumeSteerCapabilities(asyncDir: string, fsImpl: Pick<typeof f
 	return capabilities;
 }
 
+export function consumeSteerAckFromDir(
+	dir: string,
+	requestId: string,
+	fsImpl: Pick<typeof fs, "existsSync" | "readdirSync" | "readFileSync" | "rmSync"> = fs,
+): SteerAck | undefined {
+	if (!fsImpl.existsSync(dir)) return undefined;
+	let entries: string[];
+	try { entries = fsImpl.readdirSync(dir).filter((name) => name.endsWith(".json")).sort(); } catch { return undefined; }
+	for (const entry of entries) {
+		const target = path.join(dir, entry);
+		let ack: SteerAck | undefined;
+		try { ack = parseSteerAck(JSON.parse(fsImpl.readFileSync(target, "utf-8"))); } catch { ack = undefined; }
+		if (ack?.requestId !== requestId) continue;
+		try { fsImpl.rmSync(target, { force: true }); } catch { return undefined; }
+		return ack;
+	}
+	return undefined;
+}
+
 export function consumeSteerAcks(asyncDir: string, fsImpl: Pick<typeof fs, "existsSync" | "readdirSync" | "readFileSync" | "rmSync"> = fs): SteerAck[] {
 	const root = path.join(controlInboxDir(asyncDir), STEER_ACKS_DIR);
 	if (!fsImpl.existsSync(root)) return [];

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;
@@ -125,6 +126,7 @@ export function createResultWatcher(
 	const processing = new Set<string>();
 	let deliveryActive = true;
 	let deliveryEpoch = 0;
+	let resultScanTimer: ReturnType<typeof setInterval> | null = null;
 	// The sole in-memory ownership lease. It is acquired for one active session
 	// and revoked before the watcher, queues, or callbacks are torn down.
 	let activeSessionId: string | null = null;
@@ -149,6 +151,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 +163,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) {
@@ -335,9 +344,15 @@ export function createResultWatcher(
 		}
 	};
 
+	const clearResultScan = () => {
+		if (resultScanTimer) timers.clearInterval(resultScanTimer);
+		resultScanTimer = null;
+	};
+
 	const startPolling = (reason: unknown) => {
 		state.watcher?.close();
 		state.watcher = null;
+		clearResultScan();
 		if (state.watcherRestartTimer) return;
 		console.error(`Subagent result watcher for '${resultsDir}' fell back to polling because native fs.watch is unavailable (${errorCode(reason) ?? "unknown error"}).`);
 		primeExistingResults();
@@ -346,6 +361,7 @@ export function createResultWatcher(
 	};
 
 	const scheduleRestart = () => {
+		clearResultScan();
 		if (state.watcherRestartTimer) return;
 		state.watcherRestartTimer = timers.setTimeout(() => {
 			state.watcherRestartTimer = null;
@@ -373,8 +389,11 @@ export function createResultWatcher(
 		}
 		try {
 			const watchDir = resolveWatchPath(resultsDir, fsApi.realpathSync.native);
-			state.watcher = fsApi.watch(watchDir, (event, file) => {
-				if (event !== "rename" || !file) return;
+			state.watcher = fsApi.watch(watchDir, (_event, file) => {
+				if (!file) {
+					primeExistingResults();
+					return;
+				}
 				const fileName = file.toString();
 				if (fileName.endsWith(".json")) scheduleResult(fileName, true);
 			});
@@ -386,6 +405,8 @@ export function createResultWatcher(
 				scheduleRestart();
 			});
 			state.watcher.unref?.();
+			resultScanTimer = timers.setInterval(primeExistingResults, POLL_INTERVAL_MS);
+			resultScanTimer.unref?.();
 		} catch (error) {
 			if (shouldPoll(error)) return startPolling(error);
 			console.error(`Failed to start subagent result watcher for '${resultsDir}':`, error);
@@ -405,6 +426,7 @@ export function createResultWatcher(
 			timers.clearInterval(state.watcherRestartTimer);
 		}
 		state.watcherRestartTimer = null;
+		clearResultScan();
 		state.resultFileCoalescer.clear();
 		pendingTriggerTurn.clear();
 		processing.clear();

package/src/runs/background/scheduled-runs.ts

@@ -3,6 +3,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { getProjectSubagentsDir } from "../../shared/artifacts.ts";
 import { writePrivateAtomicJson } from "../../shared/atomic-json.ts";
 import { shortenPath } from "../../shared/formatters.ts";
 import type { AsyncStatus, Details, ExtensionConfig } from "../../shared/types.ts";
@@ -87,7 +88,7 @@ export function scheduledRunsEnabled(config: ExtensionConfig): boolean {
 }
 
 export function scheduledRunStorePath(cwd: string, _sessionId?: string, root?: string): string {
-	if (!root) return path.join(path.resolve(cwd), ".pi-subagents", "schedules");
+	if (!root) return path.join(getProjectSubagentsDir(path.resolve(cwd)), "schedules");
 	const projectKey = createHash("sha256").update(path.resolve(cwd)).digest("hex").slice(0, 20);
 	return path.join(root, projectKey);
 }

package/src/runs/background/stale-run-reconciler.ts

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { writeAtomicJson } from "../../shared/atomic-json.ts";
+import { readStatus } from "../../shared/utils.ts";
 import { DIRS, type AsyncParallelGroupStatus, type AsyncStatus, type NestedRunSummary, type SubagentRunMode } from "../../shared/types.ts";
 import { resolveEffectiveThinking } from "../../shared/model-info.ts";
 import { normalizeParallelGroups } from "./parallel-groups.ts";
@@ -84,26 +85,6 @@ function appendJsonlBestEffort(filePath: string, payload: object): void {
 	}
 }
 
-function readStatusFile(asyncDir: string): AsyncStatus | null {
-	const statusPath = path.join(asyncDir, "status.json");
-	let content: string;
-	try {
-		content = fs.readFileSync(statusPath, "utf-8");
-	} catch (error) {
-		if (isNotFoundError(error)) return null;
-		throw new Error(`Failed to read async status file '${statusPath}': ${getErrorMessage(error)}`, {
-			cause: error instanceof Error ? error : undefined,
-		});
-	}
-	try {
-		return JSON.parse(content) as AsyncStatus;
-	} catch (error) {
-		throw new Error(`Failed to parse async status file '${statusPath}': ${getErrorMessage(error)}`, {
-			cause: error instanceof Error ? error : undefined,
-		});
-	}
-}
-
 interface ResultChildOutcome {
 	agent?: string;
 	success?: boolean;
@@ -348,7 +329,7 @@ export function checkPidLiveness(pid: number, kill: KillFn = process.kill): PidL
 
 export function reconcileAsyncRun(asyncDir: string, options: ReconcileAsyncRunOptions = {}): ReconcileAsyncRunResult {
 	const now = options.now?.() ?? Date.now();
-	const status = readStatusFile(asyncDir);
+	const status = readStatus(asyncDir);
 	const startedStatus = !status && options.startedRun ? buildStartedStatus(asyncDir, options.startedRun, now) : undefined;
 	const effectiveStatus = status ?? startedStatus;
 	if (!effectiveStatus) return { status: null, repaired: false };

package/src/runs/background/subagent-runner.ts

@@ -1955,6 +1955,47 @@ function combinedAbortSignal(signals: Array<AbortSignal | undefined>): AbortSign
 	return controller.signal;
 }
 
+async function runSingleStepWithTimeout(
+	step: SubagentStep,
+	ctx: SingleStepContext,
+	parentDeadlineAt?: number,
+): Promise<SingleStepResult> {
+	if (step.timeoutMs === undefined) return runSingleStep(step, ctx);
+
+	const parentRemainingMs = parentDeadlineAt === undefined ? undefined : Math.max(0, parentDeadlineAt - Date.now());
+	const timeoutMs = parentRemainingMs === undefined ? step.timeoutMs : Math.min(step.timeoutMs, parentRemainingMs);
+	const timeoutMessage = parentRemainingMs !== undefined && parentRemainingMs <= step.timeoutMs
+		? ctx.timeoutMessage
+		: `Subagent timed out after ${step.timeoutMs}ms.`;
+	const timeoutController = new AbortController();
+	let timeoutAction: (() => void) | undefined;
+	let timeoutTriggered = false;
+	const triggerTimeout = (): void => {
+		if (timeoutTriggered) return;
+		timeoutTriggered = true;
+		timeoutController.abort();
+		timeoutAction?.();
+	};
+	const registerTimeout = (action: (() => void) | undefined): void => {
+		timeoutAction = action;
+		ctx.registerTimeout?.(action ? triggerTimeout : undefined);
+		if (action && timeoutTriggered) action();
+	};
+	const timer = setTimeout(triggerTimeout, timeoutMs);
+	timer.unref?.();
+	try {
+		return await runSingleStep(step, {
+			...ctx,
+			registerTimeout,
+			timeoutSignal: combinedAbortSignal([ctx.timeoutSignal, timeoutController.signal]),
+			timeoutMessage,
+		});
+	} finally {
+		clearTimeout(timer);
+		ctx.registerTimeout?.(undefined);
+	}
+}
+
 async function runSubagent(
 	config: SubagentRunConfig,
 	onWriterProcess?: (writer: { state: "none" | "spawning" } | { state: "running"; pid: number }) => void,
@@ -3449,7 +3490,7 @@ async function runSubagent(
 				writeStatusPayload();
 				appendJsonl(eventsPath, JSON.stringify({ type: "subagent.step.started", ts: taskStartTime, runId: id, stepIndex: fi, agent: task.agent }));
 				flushPendingStepSteers(fi);
-				const singleResult = await runSingleStep(task, compactOptional<SingleStepContext>({
+				const singleResult = await runSingleStepWithTimeout(task, compactOptional<SingleStepContext>({
 					previousOutput, placeholder, cwd, sessionEnabled,
 					outputs,
 					sessionDir: config.sessionDir ? path.join(config.sessionDir, `dynamic-${stepIndex}-${taskIdx}`) : undefined,
@@ -3479,7 +3520,7 @@ async function runSubagent(
 					onWriterProcess,
 					onExternalProcess: (process) => updateExternalProcess(fi, process),
 					skipAcceptance: () => timedOut || stopped,
-				}));
+				}), config.deadlineAt);
 				const taskEndTime = Date.now();
 				const childInterrupted = singleResult.interrupted === true;
 				const childStopped = singleResult.stopped === true;
@@ -3831,7 +3872,7 @@ async function runSubagent(
 						const { taskForRun, taskCwd } = prepareParallelTaskRun(task, cwd, worktreeSetup, taskIdx);
 						flushPendingStepSteers(fi);
 
-						const singleResult = await runSingleStep(taskForRun, compactOptional<SingleStepContext>({
+						const singleResult = await runSingleStepWithTimeout(taskForRun, compactOptional<SingleStepContext>({
 							previousOutput, placeholder, cwd: taskCwd, sessionEnabled,
 							outputs,
 							sessionDir: taskSessionDir,
@@ -3861,7 +3902,7 @@ async function runSubagent(
 							onWriterProcess,
 							onExternalProcess: (process) => updateExternalProcess(fi, process),
 							skipAcceptance: () => timedOut || stopped,
-						}));
+						}), config.deadlineAt);
 						if (task.sessionFile) {
 							latestSessionFile = task.sessionFile;
 						}
@@ -4120,7 +4161,7 @@ async function runSubagent(
 			}));
 
 			flushPendingStepSteers(flatIndex);
-			const singleResult = await runSingleStep(seqStep, compactOptional<SingleStepContext>({
+			const singleResult = await runSingleStepWithTimeout(seqStep, compactOptional<SingleStepContext>({
 				previousOutput, placeholder, cwd, sessionEnabled,
 				outputs: statusPayload.mode === "single" ? undefined : outputs,
 				sessionDir: config.sessionDir,
@@ -4150,7 +4191,7 @@ async function runSubagent(
 				onWriterProcess,
 				onExternalProcess: (process) => updateExternalProcess(flatIndex, process),
 				skipAcceptance: () => timedOut || stopped,
-			}));
+			}), config.deadlineAt);
 			if (seqStep.sessionFile) {
 				latestSessionFile = seqStep.sessionFile;
 			}

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;