pi-subagents 0.81.0 → 0.82.0

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

@@ -49,7 +49,7 @@ import { nestedSummaryFromAsyncStatus, projectNestedEvents, resolveNestedAsyncDi
 import { isContextOverflow } from "../shared/model-resolution.js";
 import { processTerminalPath, writeProcessTerminalCandidate } from "./process-terminal.js";
 import { persistRunnerStartupFailure } from "./runner-startup-failure.js";
-import { currentPidNamespaceScope } from "./pid-namespace.js";
+import { currentRecordedPid } from "./boot-id.js";
 import { createSteeringStatus, recordSteeringRequest, steeringStatus, terminalSteeringNoticeState, unconsumedSteerReason, updateSteeringTarget } from "./steering.js";
 import { PROMPT_REDACTED, SUBAGENT_STOPPED_MESSAGE, SUBAGENT_TIMED_OUT_MESSAGE, detectSubagentError, extractTextFromContent, extractToolArgsPreview, formatEmptyTerminalAssistantResponseError, getAgentDir, hasEmptyTerminalAssistantResponse, readStatus } from "../../shared/utils.js";
 import { planAbortRecovery } from "../shared/abort-recovery.js";
@@ -77,6 +77,7 @@ import { resolveCodexExecLaunch } from "../shared/codex-exec-adapter.js";
 import { resolveCursorAgentLaunch } from "../shared/cursor-agent-adapter.js";
 import { resolveExternalCliRunnerStatus } from "../shared/external-cli-contract.js";
 import { formatHerdrMachineHint, prepareHerdrMachineExternalCliRun } from "../shared/herdr-machine.js";
+import { isRexLocalMachine } from "../shared/rex-machine.js";
 import { HerdrExternalNeedsAttentionError, createHerdrExternalAdapter, prepareInternalHerdrExternalAdapter } from "../shared/herdr-external-adapters.js";
 import { runExternalJob } from "../shared/external-job-runner.js";
 import { createOrcaProgressTab } from "../shared/orca-progress-tabs.js";
@@ -522,6 +523,7 @@ export async function runSingleStepInner(step, ctx) {
             capabilityCeiling: step.capabilityCeiling ?? ctx.capabilityCeiling,
             inheritedCapabilityCeiling: ctx.inheritedChildRuntime?.capabilityCeiling,
             requiredExtensions: step.requiredExtensions ?? ctx.inheritedChildRuntime?.requiredExtensions,
+            agentName: step.agent,
             permissionRules: step.permissionRules,
         }));
     }
@@ -608,6 +610,8 @@ export async function runSingleStepInner(step, ctx) {
             return omitUndefinedProperties({ agent: step.agent, context: step.context, output: message, error: message, exitCode: 1, stopped: stopped || undefined, timedOut: stopped ? undefined : true });
         }
         if (step.machine) {
+            if (step.machine.provider !== "herdr")
+                throw new Error("Rex supports native Pi children only.");
             const runner = resolveExternalCliRunnerStatus({ ...step.runner, machine: step.machine });
             const outputSnapshot = captureSingleOutputSnapshot(step.outputPath);
             const placedRunId = `${ctx.id}-${ctx.flatIndex}`;
@@ -781,7 +785,8 @@ export async function runSingleStepInner(step, ctx) {
     let toolBudget = step.toolBudget ? initialToolBudgetState(step.toolBudget) : undefined;
     let toolBudgetBlocked = false;
     let actualLaunchContractDigest = step.launchContractDigest;
-    const mutationSnapshot = step.machine ? { source: "tracked-files", trackedOnly: true, cwd: step.cwd ?? ctx.cwd, dirtyFiles: [], fingerprints: {}, unavailable: "Local Git evidence is not authoritative for a pane-native remote run." } : snapshotTrackedMutations(step.cwd ?? ctx.cwd);
+    // A machine 'local' child edits this disk, so its local Git evidence is authoritative, as for an unplaced run.
+    const mutationSnapshot = step.machine && !isRexLocalMachine(step.machine) ? { source: "tracked-files", trackedOnly: true, cwd: step.cwd ?? ctx.cwd, dirtyFiles: [], fingerprints: {}, unavailable: "Local Git evidence is not authoritative for a pane-native remote run." } : snapshotTrackedMutations(step.cwd ?? ctx.cwd);
     let finalMutationEvidence = collectTrackedMutationEvidence(mutationSnapshot, step.cwd ?? ctx.cwd);
     let contextOverflow = false;
     let launchWarningsEmitted = false;
@@ -1004,7 +1009,7 @@ export async function runSingleStepInner(step, ctx) {
             ? formatEmptyTerminalAssistantResponseError(run.messages)
             : undefined;
         const remoteGitChanged = run.nativeMachine?.initialGit && run.nativeMachine.finalGit ? run.nativeMachine.initialGit.head !== run.nativeMachine.finalGit.head || run.nativeMachine.initialGit.dirty !== run.nativeMachine.finalGit.dirty : undefined;
-        const mutationEvidence = run.nativeMachine ? { source: "tracked-files", trackedOnly: true, changedFiles: [], attemptedMutation: remoteGitChanged === true, ...(remoteGitChanged === undefined ? { unavailable: "Remote Git before/after evidence was incomplete." } : {}) } : collectTrackedMutationEvidence(mutationSnapshot, step.cwd ?? ctx.cwd);
+        const mutationEvidence = run.nativeMachine && !isRexLocalMachine(step.machine) ? { source: "tracked-files", trackedOnly: true, changedFiles: [], attemptedMutation: remoteGitChanged === true, ...(remoteGitChanged === undefined ? { unavailable: "Remote Git before/after evidence was incomplete." } : {}) } : collectTrackedMutationEvidence(mutationSnapshot, step.cwd ?? ctx.cwd);
         finalMutationEvidence = mutationEvidence;
         const mutationAttemptObserved = run.observedMutationAttempt === true || mutationEvidence.attemptedMutation === true;
         // Validated structured output is persistable file content even when the final text is only
@@ -1669,6 +1674,7 @@ export async function runSubagent(config, childSessions) {
         ...(config.toolCallId ? { toolCallId: config.toolCallId } : {}),
         ...(config.sessionId ? { sessionId: config.sessionId } : {}),
         ...(config.completionOwnerId ? { completionOwnerId: config.completionOwnerId } : {}),
+        ...(config.completionOwnerProcess ? { completionOwnerProcess: config.completionOwnerProcess } : {}),
         mode: config.resultMode ?? (flatSteps.length > 1 ? "chain" : "single"),
         ...(config.nestedSelf ? { isNested: true } : {}),
         state: "running",
@@ -1680,8 +1686,7 @@ export async function runSubagent(config, childSessions) {
         ...(config.deadlineAt !== undefined ? { deadlineAt: config.deadlineAt } : {}),
         ...(config.toolBudget ? { toolBudget: initialToolBudgetState(config.toolBudget) } : {}),
         ...(config.usageBudget ? { usageBudget: usageBudgetState(config.usageBudget, undefined) } : {}),
-        pid: process.pid,
-        pidNamespaceScope: currentPidNamespaceScope(),
+        ...currentRecordedPid(),
         cwd,
         currentStep: 0,
         chainStepCount: steps.length,
@@ -1909,6 +1914,8 @@ export async function runSubagent(config, childSessions) {
             cwd,
             sessionId: config.sessionId,
             completionOwnerId: config.completionOwnerId,
+            completionOwnerProcess: config.completionOwnerProcess,
+            parentWorkflowRunId: config.parentWorkflowRunId,
             sessionFile: statusPayload.sessionFile ?? latestSessionFile,
         }), (filePath, payload) => publishRunResult(filePath, () => writePendingAsyncResultFile(filePath, payload)));
     };
@@ -4797,6 +4804,7 @@ export async function runSubagent(config, childSessions) {
             runtimeAcknowledgedExtensions: singleRuntimeAcknowledgedExtensions,
             sessionId: config.sessionId,
             completionOwnerId: config.completionOwnerId,
+            completionOwnerProcess: config.completionOwnerProcess,
             sessionFile: effectiveSessionFile,
             intercomTarget: config.controlIntercomTarget,
             shareUrl,

package/src/runs/background/subagent-wait.d.ts

@@ -54,7 +54,7 @@ export interface SubagentWaitParams {
     all?: boolean;
     /** Give up after this many milliseconds. Defaults to waitTool.defaultTimeoutMs, then 30 minutes. */
     timeoutMs?: number;
-    /** False keeps a blocking wait open through idle attention; supervisor/contact requests still stop the wait. */
+    /** False keeps a blocking wait open through all attention except supervisor/contact requests, such as idle time, a tool held open, or repeated tool failures. */
     stopOnAttention?: boolean;
 }
 /** Minimal event-bus surface wait subscribes to (matches pi.events). */

package/src/runs/background/subagent-wait.js

@@ -707,8 +707,13 @@ export async function waitForSubagents(params, signal, deps) {
     const supervisorAttentionHint = relevantAttention.some(hasSupervisorTool)
         ? " Reply to any pending supervisor request. If subagent_supervisor({ action: \"pending\" }) is empty, check intercom({ action: \"pending\" }) because an external intercom tool may own the request."
         : "";
+    // Only when watchdog attention alone ended the wait: stopOnAttention: false would have kept blocking.
+    const keepWaitingHint = stopOnAttention && supervisorAttentionHint === ""
+        && (waitForAll || finishedAsyncCount + providerFinishedCount === 0)
+        ? " These runs are still running and none is waiting on a supervisor reply. To keep waiting through this kind of attention, call bg_wait again with stopOnAttention: false; supervisor requests still end that wait."
+        : "";
     const attentionNote = relevantAttention.length > 0
-        ? ` ${relevantAttention.length} run(s) need attention: ${relevantAttention.map((run) => run.id).join(", ")} —${supervisorAttentionHint} inspect with subagent({ action: "status" }) then steer a top-level live async child, resume a paused/completed/failed child, or interrupt explicitly.`
+        ? ` ${relevantAttention.length} run(s) need attention: ${relevantAttention.map((run) => run.id).join(", ")} —${supervisorAttentionHint} inspect with subagent({ action: "status" }) then steer a top-level live async child, resume a paused/completed/failed child, or interrupt explicitly.${keepWaitingHint}`
         : "";
     const stillRunning = active.filter((run) => initialAsyncIds.has(run.id)).length
         + providerActive.filter((item) => initialProviderIds.has(backgroundWorkIdentity(item))).length;

package/src/runs/background/terminal-run-index.d.ts

@@ -5,4 +5,5 @@ export declare function readTerminalRunToolCallIndex(asyncDirRoot: string, toolC
 export declare function readRecentTerminalRunIndex(asyncDirRoot: string, options?: {
     sessionId?: string;
     limit?: number;
+    endedAfter?: number;
 }): string[];

package/src/runs/background/terminal-run-index.js

@@ -99,8 +99,10 @@ function sessionDirs(asyncDirRoot, sessionId) {
         throw error;
     }
 }
-function recentMarkerFiles(dirs, limit) {
+function recentMarkerFiles(dirs, limit, endedAfter) {
     return dirs.flatMap(markerFiles)
+        // The name starts with the run's end time, so an old run is skipped without reading its marker.
+        .filter((marker) => endedAfter === undefined || !(Number(marker.name.slice(0, TIMESTAMP_WIDTH)) < endedAfter))
         .sort((left, right) => right.name.localeCompare(left.name))
         .slice(0, limit)
         .map((marker) => path.join(marker.dir, marker.name));
@@ -135,7 +137,7 @@ export function readTerminalRunToolCallIndex(asyncDirRoot, toolCallId) {
 }
 export function readRecentTerminalRunIndex(asyncDirRoot, options = {}) {
     const limit = options.limit === undefined ? Number.POSITIVE_INFINITY : Math.max(0, Math.floor(options.limit));
-    const candidates = recentMarkerFiles(sessionDirs(asyncDirRoot, options.sessionId), limit);
+    const candidates = recentMarkerFiles(sessionDirs(asyncDirRoot, options.sessionId), limit, options.endedAfter);
     const runIds = [];
     const seen = new Set();
     for (const marker of candidates) {

package/src/runs/foreground/async-stop-action.js

@@ -44,6 +44,8 @@ function sealPausedRun(asyncDir, status, resultsDir) {
             sessionId: status.sessionId,
             asyncDir,
             ...(status.completionOwnerId ? { completionOwnerId: status.completionOwnerId } : {}),
+            ...(status.completionOwnerProcess ? { completionOwnerProcess: status.completionOwnerProcess } : {}),
+            ...(status.parentWorkflowRunId ? { parentWorkflowRunId: status.parentWorkflowRunId } : {}),
             ...(status.toolCallId ? { toolCallId: status.toolCallId } : {}),
             results: (status.steps ?? []).map((step) => ({
                 agent: step.agent,
@@ -146,7 +148,7 @@ export function stopAsyncRun(state, runId, kill, location, childId) {
     if (!target)
         return null;
     const status = reconcileAsyncRun(target.asyncDir, { kill }).status;
-    // A workflow relaunched with options.reuseFrom stops the exact child run it re-attached, whichever session launched it.
+    // A relaunched workflow stops the exact child run it re-attached from its relaunch chain, whichever session launched it.
     if (state.currentSessionId && !ownsRun(state.currentSessionId, status?.sessionId) && location?.reattachedRunId !== target.asyncId) {
         return {
             content: [{ type: "text", text: `Async run '${target.asyncId}' was not found in the active session.` }],

package/src/runs/foreground/execution.js

@@ -46,6 +46,7 @@ import { buildInProcessChildLaunch, createReportedChildSessionInput } from "../s
 import { childSessionFactory, childSessionHasQueuedMessages, projectChildSessionEventForJson } from "../shared/child-session.js";
 import { reconcileAttemptUsage } from "../shared/usage-reconciliation.js";
 import { clearProviderRetry, observeProviderDiagnostics, snapshotProviderDiagnostics } from "../../shared/provider-diagnostics.js";
+import { isRexLocalMachine } from "../shared/rex-machine.js";
 const artifactOutputByResult = new WeakMap();
 const acceptanceOutputByResult = new WeakMap();
 function emptyUsage() {
@@ -441,7 +442,9 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
         };
         return result;
     }
-    const mutationSnapshot = options.machine ? { source: "tracked-files", trackedOnly: true, cwd: options.cwd ?? runtimeCwd, dirtyFiles: [], fingerprints: {}, unavailable: "Local Git evidence is not authoritative for a pane-native remote run." } : snapshotTrackedMutations(options.cwd ?? runtimeCwd);
+    // A machine 'local' child edits this disk, so its local Git evidence is authoritative, as for an unplaced run.
+    const mutationCwd = isRexLocalMachine(options.machine) ? options.machine.cwd : options.cwd ?? runtimeCwd;
+    const mutationSnapshot = options.machine && !isRexLocalMachine(options.machine) ? { source: "tracked-files", trackedOnly: true, cwd: mutationCwd, dirtyFiles: [], fingerprints: {}, unavailable: "Local Git evidence is not authoritative for a pane-native remote run." } : snapshotTrackedMutations(mutationCwd);
     let structuredOutputToolInvoked = false;
     let structuredOutputMessageStartIndex;
     let toolAvailabilityError;
@@ -1259,7 +1262,7 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
             toolAvailabilityError = toolDiagnosticError;
             result.runtimeAcknowledgedExtensions = capture.runtimeAcknowledgedExtensions();
             if (session?.machineEvidence)
-                result.nativeMachine = { provider: "herdr", machineId: session.machineEvidence.machineId, ...(session.machineEvidence.initial ? { initialGit: session.machineEvidence.initial } : {}), ...(session.machineEvidence.final ? { finalGit: session.machineEvidence.final } : {}) };
+                result.nativeMachine = { provider: session.machineEvidence.provider, machineId: session.machineEvidence.machineId, ...(session.machineEvidence.initial ? { initialGit: session.machineEvidence.initial } : {}), ...(session.machineEvidence.final ? { finalGit: session.machineEvidence.final } : {}) };
             let closeError = result.error ?? toolDiagnosticError ?? assistantError;
             const promptErrorMessage = promptError === undefined ? undefined : promptError instanceof Error ? promptError.message : String(promptError);
             if (promptError !== undefined)
@@ -1533,7 +1536,7 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
         durationMs: progress.durationMs,
     };
     const remoteGitChanged = result.nativeMachine?.initialGit && result.nativeMachine.finalGit ? result.nativeMachine.initialGit.head !== result.nativeMachine.finalGit.head || result.nativeMachine.initialGit.dirty !== result.nativeMachine.finalGit.dirty : undefined;
-    const mutationEvidence = result.nativeMachine ? { source: "tracked-files", trackedOnly: true, changedFiles: [], attemptedMutation: remoteGitChanged === true, ...(remoteGitChanged === undefined ? { unavailable: "Remote Git before/after evidence was incomplete." } : {}) } : collectTrackedMutationEvidence(mutationSnapshot, options.cwd ?? runtimeCwd);
+    const mutationEvidence = result.nativeMachine && !isRexLocalMachine(options.machine) ? { source: "tracked-files", trackedOnly: true, changedFiles: [], attemptedMutation: remoteGitChanged === true, ...(remoteGitChanged === undefined ? { unavailable: "Remote Git before/after evidence was incomplete." } : {}) } : collectTrackedMutationEvidence(mutationSnapshot, mutationCwd);
     const acceptanceOutput = getFinalOutput(result.messages ?? []);
     const structuredText = result.structuredOutput === undefined ? undefined : JSON.stringify(result.structuredOutput, null, 2);
     let fullOutput = stripAcceptanceReport(acceptanceOutput);

package/src/runs/foreground/foreground-history.d.ts

@@ -1,11 +1,25 @@
-import type { SubagentState } from "../../shared/types.ts";
+import type { ForegroundResumeChild, ForegroundResumeRun, SubagentState } from "../../shared/types.ts";
 export declare const MAX_REMEMBERED_FOREGROUND_RUNS = 50;
-export declare function persistForegroundRunHistory(state: SubagentState, options?: {
+export declare const FOREGROUND_OWNER_EXITED_STOP_ERROR = "Subagent stopped because the Pi process that ran it exited before the run finished.";
+/**
+ * Saves one foreground run to its own history file. A run with a `running` child is a launch-time
+ * record; the run's final save replaces it.
+ */
+export declare function persistForegroundRun(run: ForegroundResumeRun, options?: {
     resultsDir?: string;
     limit?: number;
 }): void;
+/** Drops this process's `running` record for a launch that threw, so it never loads as interrupted. */
+export declare function discardRunningForegroundRun(runId: string, options?: {
+    resultsDir?: string;
+}): void;
+/** For a record with a `running` child: its owning Pi process is gone. */
+export declare function ownerConfirmedDead(run: ForegroundResumeRun): boolean;
+/** State text for a remembered child; a child cut off by a Pi exit names the resume target. */
+export declare function foregroundChildStateLabel(run: Pick<ForegroundResumeRun, "runId">, child: Pick<ForegroundResumeChild, "status" | "error" | "sessionFile">): string;
 export declare function restoreForegroundRunHistory(state: SubagentState, options?: {
     resultsDir?: string;
     sessionId?: string | null;
     limit?: number;
+    observeForeign?: (run: ForegroundResumeRun) => void;
 }): number;

package/src/runs/foreground/foreground-history.js

@@ -5,12 +5,18 @@ import { writePrivateAtomicJson } from "../../shared/atomic-json.js";
 import { utf8Tail } from "../../shared/utf8.js";
 import { validateAcceptanceInput } from "../shared/acceptance.js";
 import { validateModelResponseAliases } from "../../shared/model-response-aliases.js";
+import { checkRecordedPidLiveness, isRecordedPid } from "../background/stale-run-reconciler.js";
+import { encodeIndexSegment } from "../background/index-segment.js";
 export const MAX_REMEMBERED_FOREGROUND_RUNS = 50;
-const HISTORY_VERSION = 1;
+export const FOREGROUND_OWNER_EXITED_STOP_ERROR = "Subagent stopped because the Pi process that ran it exited before the run finished.";
 const MAX_INLINE_OUTPUT_BYTES = 64 * 1024;
 const MAX_RESUME_CONTRACT_BYTES = 64 * 1024;
-function historyPath(resultsDir) {
-    return path.join(resultsDir, "foreground-history.json");
+// One file per run, so Pi processes sharing the results dir never rewrite each other's records.
+function historyDir(resultsDir) {
+    return path.join(resultsDir, "foreground-history");
+}
+function runHistoryPath(resultsDir, runId) {
+    return path.join(historyDir(resultsDir), `${encodeIndexSegment(runId)}.json`);
 }
 function boundedTail(value) {
     return utf8Tail(value, MAX_INLINE_OUTPUT_BYTES).text;
@@ -57,6 +63,13 @@ function compactChild(child) {
 function isRestorableForegroundStatus(status) {
     return status === "completed" || status === "failed" || status === "paused" || status === "stopped";
 }
+function hasRunningChild(run) {
+    return run.children.some((child) => child.status === "running");
+}
+/** A `running` record is kept only for a single run whose owning Pi process can be probed later. */
+function isAdmittedChildStatus(run, status) {
+    return isRestorableForegroundStatus(status) || (status === "running" && run.mode === "single" && isRecordedPid(run.owner));
+}
 function isRestorableResumeContract(value) {
     if (value === undefined)
         return true;
@@ -86,8 +99,9 @@ function isRestorableResumeContract(value) {
 function compactRun(run) {
     if (!run.sessionId)
         return undefined;
-    if (run.children.length === 0 || !run.children.every((child) => isRestorableForegroundStatus(child.status) && isRestorableResumeContract(child.resumeContract)))
+    if (run.children.length === 0 || !run.children.every((child) => isAdmittedChildStatus(run, child.status) && isRestorableResumeContract(child.resumeContract)))
         return undefined;
+    const running = hasRunningChild(run);
     return {
         runId: run.runId,
         mode: run.mode,
@@ -95,23 +109,26 @@ function compactRun(run) {
         sessionId: run.sessionId,
         updatedAt: run.updatedAt,
         children: run.children.map(compactChild),
+        ...(running ? { owner: run.owner } : {}),
+        ...(run.parentWorkflowRunId ? { parentWorkflowRunId: run.parentWorkflowRunId } : {}),
     };
 }
-function readIndex(resultsDir) {
-    const filePath = historyPath(resultsDir);
-    if (!fs.existsSync(filePath))
-        return { version: HISTORY_VERSION, runs: [] };
+/** One saved run, or undefined when the file is missing, unreadable or invalid. */
+function readRunFile(filePath) {
     try {
         const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
-            return { version: HISTORY_VERSION, runs: [] };
-        const record = parsed;
-        if (record.version !== HISTORY_VERSION || !Array.isArray(record.runs))
-            return { version: HISTORY_VERSION, runs: [] };
-        return { version: HISTORY_VERSION, runs: record.runs.filter(isRestorableRun) };
+        return isRestorableRun(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function historyFiles(dir) {
+    try {
+        return fs.readdirSync(dir).filter((name) => name.endsWith(".json"));
     }
     catch {
-        return { version: HISTORY_VERSION, runs: [] };
+        return [];
     }
 }
 function isRestorableRun(value) {
@@ -125,40 +142,125 @@ function isRestorableRun(value) {
         && typeof run.updatedAt === "number" && Number.isFinite(run.updatedAt)
         && Array.isArray(run.children)
         && run.children.length > 0
+        && (run.owner === undefined || isRecordedPid(run.owner))
+        && (run.parentWorkflowRunId === undefined || typeof run.parentWorkflowRunId === "string")
         && run.children.every((child) => Boolean(child && typeof child === "object" && !Array.isArray(child)
             && typeof child.agent === "string"
             && typeof child.index === "number"
             && isRestorableResumeContract(child.resumeContract)
-            && isRestorableForegroundStatus(child.status)));
+            && isAdmittedChildStatus(run, child.status)));
 }
-function sortAndBound(runs, limit) {
-    return [...runs].sort((left, right) => right.updatedAt - left.updatedAt).slice(0, limit);
+/** Deletes the oldest final run files beyond the cap; running records stay, so the cap can be exceeded while runs are live. */
+function pruneHistory(dir, limit) {
+    const files = historyFiles(dir);
+    if (files.length <= limit)
+        return;
+    const byAge = files.flatMap((name) => {
+        try {
+            return [{ name, mtimeMs: fs.statSync(path.join(dir, name)).mtimeMs }];
+        }
+        catch {
+            return [];
+        }
+    }).sort((left, right) => left.mtimeMs - right.mtimeMs);
+    for (const { name, mtimeMs } of byAge.slice(0, byAge.length - limit)) {
+        const filePath = path.join(dir, name);
+        // A running record is replaced later by its run's final save, possibly in another Pi process;
+        // once its owner is confirmed dead nothing can replace it, so it is final.
+        const run = readRunFile(filePath);
+        if (run && hasRunningChild(run) && !ownerConfirmedDead(run))
+            continue;
+        // A file rewritten since the snapshot is a fresh record, not the old one judged here.
+        try {
+            if (fs.statSync(filePath).mtimeMs !== mtimeMs)
+                continue;
+        }
+        catch {
+            continue;
+        }
+        fs.rmSync(filePath, { force: true });
+    }
 }
-export function persistForegroundRunHistory(state, options = {}) {
+/**
+ * Saves one foreground run to its own history file. A run with a `running` child is a launch-time
+ * record; the run's final save replaces it.
+ */
+export function persistForegroundRun(run, options = {}) {
+    const compact = compactRun(run);
+    if (!compact)
+        return;
     const resultsDir = options.resultsDir ?? DIRS.results;
-    const limit = options.limit ?? MAX_REMEMBERED_FOREGROUND_RUNS;
-    const existing = readIndex(resultsDir);
-    const merged = new Map(existing.runs.map((run) => [run.runId, run]));
-    for (const run of state.foregroundRuns?.values() ?? []) {
-        const compact = compactRun(run);
-        if (compact)
-            merged.set(compact.runId, compact);
+    const dir = historyDir(resultsDir);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+        // The single shared file used before per-run files is not read or migrated.
+        fs.rmSync(path.join(resultsDir, "foreground-history.json"), { force: true });
     }
-    const runs = sortAndBound([...merged.values()], limit);
-    writePrivateAtomicJson(historyPath(resultsDir), { version: HISTORY_VERSION, runs });
+    writePrivateAtomicJson(runHistoryPath(resultsDir, compact.runId), compact);
+    pruneHistory(dir, options.limit ?? MAX_REMEMBERED_FOREGROUND_RUNS);
+}
+/** Drops this process's `running` record for a launch that threw, so it never loads as interrupted. */
+export function discardRunningForegroundRun(runId, options = {}) {
+    const filePath = runHistoryPath(options.resultsDir ?? DIRS.results, runId);
+    const run = readRunFile(filePath);
+    if (run && hasRunningChild(run) && run.owner?.pid === process.pid)
+        fs.rmSync(filePath, { force: true });
+}
+/** For a record with a `running` child: its owning Pi process is gone. */
+export function ownerConfirmedDead(run) {
+    // readRunFile admits a running child only with a valid owner.
+    return checkRecordedPidLiveness(run.owner) === "dead";
+}
+/** A run whose owning Pi process is gone loads as stopped and resumable; one whose owner may be alive is not loaded. */
+function restoreInterruptedRun(run) {
+    if (!ownerConfirmedDead(run))
+        return undefined;
+    const { owner: _owner, ...rest } = run;
+    return {
+        ...rest,
+        children: run.children.map((child) => {
+            if (child.status !== "running")
+                return child;
+            const { activityState: _activityState, currentTool: _currentTool, currentToolStartedAt: _currentToolStartedAt, currentPath: _currentPath, sessionFile, ...stopped } = child;
+            return {
+                ...stopped,
+                status: "stopped",
+                exitCode: 1,
+                error: FOREGROUND_OWNER_EXITED_STOP_ERROR,
+                finalOutput: FOREGROUND_OWNER_EXITED_STOP_ERROR,
+                ...(sessionFile && fs.existsSync(sessionFile) ? { sessionFile } : {}),
+            };
+        }),
+    };
+}
+/** State text for a remembered child; a child cut off by a Pi exit names the resume target. */
+export function foregroundChildStateLabel(run, child) {
+    if (child.status !== "stopped" || child.error !== FOREGROUND_OWNER_EXITED_STOP_ERROR)
+        return child.status;
+    // Without a transcript there is nothing to resume from.
+    return child.sessionFile ? `interrupted when Pi exited · resume ${run.runId}` : "interrupted when Pi exited";
 }
 export function restoreForegroundRunHistory(state, options = {}) {
     const sessionId = options.sessionId ?? state.currentSessionId;
     if (!sessionId)
         return 0;
-    const index = readIndex(options.resultsDir ?? DIRS.results);
-    const runs = sortAndBound(index.runs.filter((run) => run.sessionId === sessionId), options.limit ?? MAX_REMEMBERED_FOREGROUND_RUNS);
+    const dir = historyDir(options.resultsDir ?? DIRS.results);
+    const saved = historyFiles(dir).flatMap((name) => readRunFile(path.join(dir, name)) ?? []);
+    // Other sessions' records that may have been cut off, for a read-only pointer to them.
+    if (options.observeForeign)
+        for (const run of saved)
+            if (run.sessionId !== sessionId && hasRunningChild(run))
+                options.observeForeign(run);
+    const runs = saved.filter((run) => run.sessionId === sessionId).sort((left, right) => right.updatedAt - left.updatedAt).slice(0, options.limit ?? MAX_REMEMBERED_FOREGROUND_RUNS);
     state.foregroundRuns ??= new Map();
     let restored = 0;
     for (const run of runs) {
         if (state.foregroundRuns.has(run.runId))
             continue;
-        state.foregroundRuns.set(run.runId, run);
+        const loaded = hasRunningChild(run) ? restoreInterruptedRun(run) : run;
+        if (!loaded)
+            continue;
+        state.foregroundRuns.set(run.runId, loaded);
         restored += 1;
     }
     return restored;

package/src/runs/foreground/subagent-executor.d.ts

@@ -15,6 +15,7 @@ import { steerAsyncRun } from "./async-steering-action.ts";
 import type { ChildRuntimeConfig } from "../shared/child-runtime-config.ts";
 import { type MissionLaunchBinding } from "../../missions/lifecycle.ts";
 import { type WorkflowSteerOptions, type WorkflowSteerResult } from "../../workflows/scripted-workflow.ts";
+import { type PreparedWorkflowResume, type WorkflowResumeRefusalReason } from "../../workflows/workflow-resume.ts";
 import { type AcceptanceInput, type AgentContract, type ControlConfig, type Details, type ExtensionConfig, type IntercomBridgeConfig, type JsonSchemaObject, type MaxOutputConfig, type ResolvedControlConfig, type RunFanoutBudgetDescriptor, type SteeringRecoveryDescriptor, type SingleResult, type ToolBudgetConfig, type UsageBudgetConfig, type SubagentState, type ScheduleOrigin } from "../../shared/types.ts";
 export declare function unknownSubagentActionMessage(action: string, disabled?: DisabledFeatureSurface): string;
 interface TaskParam {
@@ -287,6 +288,14 @@ export declare function resolveRevivalControlConfig(input: {
     requestedControl?: ControlConfig;
     recoveryControlConfig?: ResolvedControlConfig;
 }): ResolvedControlConfig;
+type WorkflowResumeOutcome = {
+    result: AgentToolResult<Details>;
+} & ({
+    launched: true;
+} | {
+    launched: false;
+    refusal: WorkflowResumeRefusalReason;
+});
 export declare function createSubagentExecutor(deps: ExecutorDeps): {
     execute: (id: string, params: SubagentParamsLike, signal: AbortSignal, onUpdate: ((r: AgentToolResult<Details>) => void) | undefined, ctx: ExtensionContext) => Promise<AgentToolResult<Details>>;
     /** Public/model-facing execution boundary. Internal direct launch primitives use execute or executeDelegated. */
@@ -299,6 +308,8 @@ export declare function createSubagentExecutor(deps: ExecutorDeps): {
     executeDelegated: (id: string, params: SubagentParamsLike, signal: AbortSignal, onUpdate: ((r: AgentToolResult<Details>) => void) | undefined, ctx: ExtensionContext) => Promise<AgentToolResult<Details>>;
     /** Scheduled launches retain their owning context without replacing the live active session. */
     executeScheduled: (id: string, params: SubagentParamsLike, signal: AbortSignal, ctx: ExtensionContext) => Promise<AgentToolResult<Details>>;
+    /** Relaunches a stopped workflow claimed by prepareWorkflowResume (resume by id and auto-resume); a launch that did not start gives up its claim. */
+    executeWorkflowResume: (id: string, prepared: PreparedWorkflowResume, signal: AbortSignal, ctx: ExtensionContext) => Promise<WorkflowResumeOutcome>;
     /** Scheduled state visible to the current runtime supervisor owner only. */
     getCurrentSupervisorOwnerStates: () => Iterable<SubagentState>;
 };