pi-subagents 0.81.0 → 0.82.1

package/src/runs/background/async-job-tracker.d.ts

@@ -1,6 +1,8 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import * as fs from "node:fs";
 import { type AsyncJobState, type AsyncWidgetLayout, type ControlEvent, type SubagentState } from "../../shared/types.ts";
+import type { RawDrainStatusObserver } from "../shared/readonly-drain-observation.ts";
+import type { ResultDeliveryOwnership } from "./result-delivery-ownership.ts";
 interface AsyncJobTrackerOptions {
     completionRetentionMs?: number;
     /** Slow safety sweep for liveness repair when filesystem events are missed. */
@@ -12,6 +14,8 @@ interface AsyncJobTrackerOptions {
     platform?: NodeJS.Platform;
     onJobTerminal?: (job: AsyncJobState) => void;
     onJobCleanup?: (asyncId: string) => void;
+    /** Lets a run whose launching Pi exited hold its publication in the session that owns it. */
+    deliveryOwnerId?: ResultDeliveryOwnership["deliveryOwnerId"];
     watch?: typeof fs.watch;
     kill?: (pid: number, signal?: NodeJS.Signals | 0) => boolean;
     now?: () => number;
@@ -26,7 +30,8 @@ export declare function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">,
     handleStarted: (data: unknown) => void;
     handleComplete: (data: unknown) => void;
     resetJobs: (ctx?: ExtensionContext) => void;
-    restoreActiveJobs: (ctx?: ExtensionContext) => void;
+    /** `observeStatus` also sees the statuses of other sessions' runs that the listing skips. */
+    restoreActiveJobs: (ctx?: ExtensionContext, observeStatus?: RawDrainStatusObserver) => void;
     dispose: () => void;
 };
 export {};

package/src/runs/background/async-job-tracker.js

@@ -15,6 +15,7 @@ import { withWorkflowChildRunModel } from "./workflow-terminal-proof.js";
 import { validHostStepNodes } from "../shared/host-step-status.js";
 import { readProcessTerminal } from "./process-terminal.js";
 import { withCachedUiContext } from "../../shared/extension-context.js";
+import { OWNING_SESSION_COMPLETION_OWNER } from "../../shared/completion-owner.js";
 const CONTROL_EVENT_READ_CHUNK_BYTES = 64 * 1024;
 const MAX_CONTROL_EVENT_LINE_BYTES = 1024 * 1024;
 const CONTROL_EVENT_SCAN_WINDOW_BYTES = 2 * 1024 * 1024;
@@ -560,8 +561,11 @@ export function createAsyncJobTracker(pi, state, asyncDirRoot, options = {}) {
                 if (isTerminalJobStatus(job.status)) {
                     let publication = terminalPublications.get(job.asyncId);
                     if (!publication && status.mode !== "workflow" && status.processTerminal?.state === "pending"
-                        && status.runId === job.asyncId && status.sessionId === state.currentSessionId
-                        && status.completionOwnerId && status.completionOwnerId === state.completionOwnerId) {
+                        && status.runId === job.asyncId && status.completionOwnerId
+                        && ((status.sessionId === state.currentSessionId && status.completionOwnerId === state.completionOwnerId)
+                            // Also covers a session inherited after /new or /resume: deliveryOwnerId checks run ownership.
+                            || (typeof status.sessionId === "string"
+                                && options.deliveryOwnerId?.(status.sessionId, status.completionOwnerId, status.completionOwnerProcess, status.parentWorkflowRunId) === OWNING_SESSION_COMPLETION_OWNER))) {
                         publication = { instanceId: status.processTerminal.runnerProcessInstanceId, pending: true };
                         terminalPublications.set(job.asyncId, publication);
                     }
@@ -883,7 +887,7 @@ export function createAsyncJobTracker(pi, state, asyncDirRoot, options = {}) {
             rerenderWidget(ctx, []);
         }
     };
-    const restoreActiveJobs = (ctx) => {
+    const restoreActiveJobs = (ctx, observeStatus) => {
         if (ctx?.hasUI)
             state.lastUiContext = ctx;
         state.statusProjectionSessionId = null;
@@ -891,7 +895,8 @@ export function createAsyncJobTracker(pi, state, asyncDirRoot, options = {}) {
             return;
         let runs;
         try {
-            runs = listAsyncRuns(asyncDirRoot, { states: ["queued", "running"], sessionId: state.currentSessionId, resultsDir, kill: options.kill, now: options.now });
+            // A workflow whose Pi exited is repaired here, in the session that owns it, which then delivers its notice.
+            runs = listAsyncRuns(asyncDirRoot, { states: ["queued", "running"], sessionId: state.currentSessionId, resultsDir, kill: options.kill, now: options.now, adoptCompletionOwnerId: state.completionOwnerId }, observeStatus);
         }
         catch (error) {
             console.error(`Failed to restore active async jobs from '${asyncDirRoot}':`, error);

package/src/runs/background/async-status.d.ts

@@ -142,6 +142,10 @@ interface AsyncRunListOptions {
     includeNested?: boolean;
     /** Explicit repair/debug escape hatch. Normal runtime paths must not set this. */
     repairScan?: boolean;
+    /** This process's completion owner, adopted by an owner-exited workflow repair of a run the session owns; needs `sessionId`. */
+    adoptCompletionOwnerId?: string;
+    /** Receives the warning for a skipped corrupt terminal status, so an open TUI can show it as a notice instead of console output. */
+    onCorruptStatus?: (warning: string) => void;
 }
 type TargetedAsyncRunResolution = {
     kind: "exact";

package/src/runs/background/async-status.js

@@ -37,6 +37,9 @@ function isAsyncStatusIsolationError(asyncDir, error) {
         || message.startsWith(`Invalid host step '${statusPath}`)
         || /^(workflowChildren|Invalid workflowChildren)/.test(message);
 }
+// Status path -> last logged signature. A corrupt run is re-scanned on every
+// status poll, so the line repeats only when the file or the outcome changes.
+const reportedCorruptStatus = new Map();
 function isolateCorruptActiveRun(asyncDir, runId, error, now) {
     const statusPath = path.join(asyncDir, "status.json");
     const processTerminal = readProcessTerminal(asyncDir, { runId });
@@ -61,7 +64,20 @@ function isolateCorruptActiveRun(asyncDir, runId, error, now) {
             markerAction = `failed to release active marker: ${getErrorMessage(releaseError)}`;
         }
     }
-    console.error(`[pi-subagents] Skipping corrupt active async run '${runId}' at '${statusPath}': ${getErrorMessage(error)}; ${markerAction}.`);
+    const line = `[pi-subagents] Skipping corrupt active async run '${runId}' at '${statusPath}': ${getErrorMessage(error)}; ${markerAction}.`;
+    let fileSignature = "";
+    try {
+        const stat = fs.statSync(statusPath);
+        fileSignature = `${stat.size}:${stat.mtimeMs}`;
+    }
+    catch {
+        // A missing file still gets the line once; its message carries the cause.
+    }
+    const signature = `${fileSignature}\n${line}`;
+    if (reportedCorruptStatus.get(statusPath) === signature)
+        return;
+    reportedCorruptStatus.set(statusPath, signature);
+    console.error(line);
 }
 function isNotFoundError(error) {
     return typeof error === "object"
@@ -388,7 +404,7 @@ export function listAsyncRuns(asyncDirRoot, options = {}, observeStatus) {
             }
             if (wantsTerminal) {
                 for (const sessionId of owners ?? [undefined]) {
-                    for (const entry of readRecentTerminalRunIndex(asyncDirRoot, { sessionId, ...(options.entryLimit !== undefined ? { limit: options.entryLimit } : {}) }))
+                    for (const entry of readRecentTerminalRunIndex(asyncDirRoot, { sessionId, onCorruptStatus: options.onCorruptStatus, ...(options.entryLimit !== undefined ? { limit: options.entryLimit } : {}) }))
                         indexed.add(entry);
                 }
             }
@@ -425,16 +441,19 @@ export function listAsyncRuns(asyncDirRoot, options = {}, observeStatus) {
         let status;
         try {
             // Reconciliation can rewrite state; session-scoped discovery does not own foreign runs.
+            let owned = false;
             if (owners) {
                 const stored = readStatus(asyncDir);
                 if (stored && !owners.has(stored.sessionId)) {
                     observeStatus?.(stored);
                     continue;
                 }
+                owned = stored !== null;
             }
+            // Only a run this session owns may adopt the caller's completion owner.
             const reconciliation = options.reconcile === false
                 ? undefined
-                : reconcileAsyncRun(asyncDir, { resultsDir: options.resultsDir, kill: options.kill, now: options.now }, observeStatus);
+                : reconcileAsyncRun(asyncDir, { resultsDir: options.resultsDir, kill: options.kill, now: options.now, adoptCompletionOwnerId: owned ? options.adoptCompletionOwnerId : undefined }, observeStatus);
             status = (reconciliation?.status ?? readStatus(asyncDir));
             if (options.reconcile === false)
                 observeStatus?.(status);

package/src/runs/background/await-async-run.js

@@ -2,9 +2,8 @@ import * as fs from "node:fs";
 import { readStatus } from "../../shared/utils.js";
 import { workflowAwaitedAsyncResultPath } from "./async-execution.js";
 import { waitForImportedAsyncRoot } from "./chain-root-attachment.js";
-import { currentPidNamespaceScope } from "./pid-namespace.js";
 import { resultPayloadPathForSessionRun, resultSnapshotReplaced, withResultRunLease } from "./result-files.js";
-import { checkPidLiveness } from "./stale-run-reconciler.js";
+import { checkRecordedPidLiveness } from "./stale-run-reconciler.js";
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -13,11 +12,8 @@ function runnerExitedWithoutResult(asyncDir, runId, resultPath) {
     const status = readStatus(asyncDir);
     if (!status || (status.state !== "running" && status.state !== "queued") || typeof status.pid !== "number")
         return false;
-    const observedScope = currentPidNamespaceScope();
-    if (status.pidNamespaceScope !== undefined && status.pidNamespaceScope !== observedScope)
-        return false;
-    const pidScopeVerified = status.pidNamespaceScope !== undefined && status.pidNamespaceScope === observedScope;
-    if (checkPidLiveness(status.pid, undefined, pidScopeVerified) !== "dead")
+    // A pid from another namespace never reads as dead here, so the runner is not presumed gone.
+    if (checkRecordedPidLiveness({ pid: status.pid, pidNamespaceScope: status.pidNamespaceScope, bootId: status.bootId }) !== "dead")
         return false;
     return !fs.existsSync(resultPath) && !(status.sessionId && resultPayloadPathForSessionRun(asyncDir, status.sessionId, runId));
 }

package/src/runs/background/boot-id.d.ts

@@ -0,0 +1,12 @@
+import type { RecordedPid } from "./stale-run-reconciler.ts";
+/**
+ * Identity of the current machine boot, read once per process. A pid recorded under a
+ * different boot id cannot still be running. Undefined when the platform has none.
+ */
+export declare function currentBootId(): string | undefined;
+/** This process as a recorded pid, without the fields the platform does not have. */
+export declare function currentRecordedPid(): RecordedPid;
+/** Fixes the boot id without reading the OS; runners take Pi's value from their config. */
+export declare function primeBootId(value: string | undefined): void;
+/** Clears the cache so the next read calls `nextReader` (default: the OS reader). */
+export declare function resetBootIdForTesting(nextReader?: () => string | undefined): void;

package/src/runs/background/boot-id.js

@@ -0,0 +1,47 @@
+import { execFileSync } from "node:child_process";
+import * as fs from "node:fs";
+import { currentPidNamespaceScope } from "./pid-namespace.js";
+function readBootIdFromOs() {
+    try {
+        if (process.platform === "linux")
+            return fs.readFileSync("/proc/sys/kernel/random/boot_id", "utf-8").trim() || undefined;
+        if (process.platform === "darwin") {
+            return execFileSync("sysctl", ["-n", "kern.bootsessionuuid"], { encoding: "utf-8", timeout: 1000, stdio: ["ignore", "pipe", "ignore"] }).trim() || undefined;
+        }
+    }
+    catch {
+        // An unreadable boot id only means liveness falls back to probing the pid.
+    }
+    return undefined;
+}
+// Process-wide, so the bundled extension and the compiled runner modules share one value.
+const BOOT_ID_KEY = Symbol.for("pi-subagents.boot-id.v1");
+const runtime = globalThis;
+let reader = readBootIdFromOs;
+/**
+ * Identity of the current machine boot, read once per process. A pid recorded under a
+ * different boot id cannot still be running. Undefined when the platform has none.
+ */
+export function currentBootId() {
+    const cached = runtime[BOOT_ID_KEY];
+    if (cached)
+        return cached.value;
+    const value = reader();
+    runtime[BOOT_ID_KEY] = { value };
+    return value;
+}
+/** This process as a recorded pid, without the fields the platform does not have. */
+export function currentRecordedPid() {
+    const pidNamespaceScope = currentPidNamespaceScope();
+    const bootId = currentBootId();
+    return { pid: process.pid, ...(pidNamespaceScope ? { pidNamespaceScope } : {}), ...(bootId ? { bootId } : {}) };
+}
+/** Fixes the boot id without reading the OS; runners take Pi's value from their config. */
+export function primeBootId(value) {
+    runtime[BOOT_ID_KEY] = { value };
+}
+/** Clears the cache so the next read calls `nextReader` (default: the OS reader). */
+export function resetBootIdForTesting(nextReader) {
+    reader = nextReader ?? readBootIdFromOs;
+    delete runtime[BOOT_ID_KEY];
+}

package/src/runs/background/interrupted-elsewhere.d.ts

@@ -0,0 +1,22 @@
+import type { ForegroundResumeRun } from "../../shared/types.ts";
+import type { RawDrainStatusObserver } from "../shared/readonly-drain-observation.ts";
+interface InterruptedElsewhereCollector {
+    /** Observer for the async statuses session start already reads; keeps foreign ones that may be interrupted. */
+    observeStatus: RawDrainStatusObserver;
+    /** Receives the foreground records of other sessions that session start already reads. */
+    observeForegroundRun: (run: ForegroundResumeRun) => void;
+    /** One line per other session that can be reopened and has runs whose Pi is dead. */
+    lines: () => string[];
+}
+/**
+ * Collects runs of other sessions in this folder that were cut off because their Pi died, from what
+ * session start reads anyway. Read-only: nothing is written to those runs or sessions. The cheap
+ * filters run as records arrive; `lines` reads each session file's header once, then probes each
+ * candidate's pid once.
+ */
+export declare function createInterruptedElsewhereCollector(input: {
+    currentSessionId: string;
+    cwd: string;
+    now: number;
+}): InterruptedElsewhereCollector;
+export {};

package/src/runs/background/interrupted-elsewhere.js

@@ -0,0 +1,68 @@
+import { resolvePiSessionId } from "../../shared/session-identity.js";
+import { ownerConfirmedDead } from "../foreground/foreground-history.js";
+import { ownerSessionIds } from "../shared/run-ownership.js";
+import { checkRecordedPidLiveness } from "./stale-run-reconciler.js";
+/** Runs interrupted longer ago than this are not pointed to. */
+const INTERRUPTED_ELSEWHERE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+function interruptedElsewhereLine(reopenId, count) {
+    const command = `\`pi --session ${reopenId}\``;
+    return count === 1
+        ? `1 subagent run was interrupted in another session. Reopen it to resume it: ${command}`
+        : `${count} subagent runs were interrupted in another session. Reopen it to resume them: ${command}`;
+}
+/**
+ * Collects runs of other sessions in this folder that were cut off because their Pi died, from what
+ * session start reads anyway. Read-only: nothing is written to those runs or sessions. The cheap
+ * filters run as records arrive; `lines` reads each session file's header once, then probes each
+ * candidate's pid once.
+ */
+export function createInterruptedElsewhereCollector(input) {
+    const ownSessions = ownerSessionIds(input.currentSessionId);
+    // sessionId -> runId -> whether its owner is dead; a run seen from both sources counts once.
+    const candidates = new Map();
+    const recent = (at) => typeof at === "number" && input.now - at <= INTERRUPTED_ELSEWHERE_MAX_AGE_MS;
+    const add = (sessionId, runId, ownerDead) => {
+        if (ownSessions.has(sessionId))
+            return;
+        const runs = candidates.get(sessionId) ?? new Map();
+        if (!runs.has(runId))
+            runs.set(runId, ownerDead);
+        candidates.set(sessionId, runs);
+    };
+    return {
+        observeStatus(observed) {
+            // The listing passes the status.json values it read.
+            const status = observed;
+            if (!status || typeof status.sessionId !== "string" || typeof status.runId !== "string" || (status.state !== "running" && status.state !== "queued"))
+                return;
+            if (status.parentWorkflowRunId !== undefined || status.cwd !== input.cwd || !recent(status.lastUpdate ?? status.startedAt))
+                return;
+            const { pid, pidNamespaceScope, bootId } = status;
+            if (typeof pid !== "number")
+                return;
+            add(status.sessionId, status.runId, () => checkRecordedPidLiveness({ pid, pidNamespaceScope, bootId }) === "dead");
+        },
+        observeForegroundRun(run) {
+            if (!run.sessionId || run.parentWorkflowRunId !== undefined || run.cwd !== input.cwd || !recent(run.updatedAt))
+                return;
+            add(run.sessionId, run.runId, () => ownerConfirmedDead(run));
+        },
+        lines() {
+            const lines = [];
+            for (const [sessionId, runs] of candidates) {
+                // Only a persisted session can be reopened; its id is then its file path, whose header names
+                // the id `pi --session` resolves, so the command needs no quoting in any shell.
+                const reopenId = resolvePiSessionId(sessionId);
+                if (!reopenId)
+                    continue;
+                let interrupted = 0;
+                for (const ownerDead of runs.values())
+                    if (ownerDead())
+                        interrupted += 1;
+                if (interrupted > 0)
+                    lines.push(interruptedElsewhereLine(reopenId, interrupted));
+            }
+            return lines;
+        },
+    };
+}

package/src/runs/background/notify.d.ts

@@ -43,6 +43,8 @@ export interface SubagentNotifyDetails {
     /** The finished run's id; for a workflow it equals workflowRunId. */
     runId?: string;
     workflowRunId?: string;
+    /** What happens next to a workflow that Pi's exit or a runtime replacement stopped; decided once at delivery. */
+    resumeNotice?: string;
     childRuns?: Array<{
         runId: string;
         workflowKey?: string;

package/src/runs/background/notify.js

@@ -15,6 +15,8 @@ import { COMPLETION_ACTION } from "../../shared/parent-wake.js";
 import { resolveSubagentResultStatus } from "../../intercom/result-intercom.js";
 import { isUnexplainedProcessSignal } from "../shared/process-signal.js";
 import { capSummaryOutputs } from "../shared/single-output.js";
+import { describeWorkflowResume } from "../../workflows/workflow-resume-claim.js";
+import { isReusableWorkflowStopCause } from "../../workflows/workflow-stop-cause.js";
 const CHILD_OUTPUT_PREVIEW_MAX_BYTES = 2_000;
 const ERROR_LINE_MAX_BYTES = 300;
 const CHILD_OUTPUT_PREVIEW_COUNT = 8;
@@ -187,10 +189,13 @@ function formatCorrelationLines(details) {
     return [
         details.asyncDir ? `Retention-managed async directory: ${boundedSafeText(details.asyncDir)}` : undefined,
         details.workflowRunId ? `Workflow run: ${details.workflowRunId}` : undefined,
+        details.resumeNotice,
         details.childRuns?.length ? `Child runs: ${details.childRuns.map(formatChildRun).join(", ")}` : undefined,
         details.reconciledFromDetachedChild ? `Reconciled detached child: ${details.reconciledFromDetachedChild}` : undefined,
     ].filter((line) => line !== undefined);
 }
+// The forms of describeWorkflowResume, so a re-render keeps the line out of the result preview.
+const RESUME_NOTICE_PREFIXES = ["Auto-resumed as ", "Resumed as ", "Relaunched as ", "Not auto-resumed: ", "Resume by hand: ", "Relaunch it by hand with "];
 const WATCHDOG_BLOCKERS_HEADING = "Watchdog blockers:";
 function formatWatchdogBlockerLines(details) {
     if (!details.watchdogBlockers?.length)
@@ -295,6 +300,9 @@ export function parseSubagentNotifyContent(content) {
     const workflowRunIndex = body.findIndex((line) => line.startsWith("Workflow run: "));
     const childRunsIndex = body.findIndex((line) => line.startsWith("Child runs: "));
     const reconciledIndex = body.findIndex((line) => line.startsWith("Reconciled detached child: "));
+    // Only the slot right after `Workflow run:` carries the resume line; the same text elsewhere is output.
+    const resumeNoticeLine = workflowRunIndex >= 0 ? body[workflowRunIndex + 1] : undefined;
+    const resumeNotice = resumeNoticeLine && RESUME_NOTICE_PREFIXES.some((prefix) => resumeNoticeLine.startsWith(prefix)) ? resumeNoticeLine : undefined;
     const watchdogIndex = body.findIndex((line) => line === WATCHDOG_BLOCKERS_HEADING);
     const watchdogBlockers = watchdogIndex >= 0 ? parseWatchdogBlockerLines(body.slice(watchdogIndex + 1)) : [];
     const metadataIndexes = [sessionIndex, handoffIndex, workflowRunIndex, childRunsIndex, reconciledIndex, watchdogIndex].filter((index) => index >= 0);
@@ -332,6 +340,7 @@ export function parseSubagentNotifyContent(content) {
         resultPreview,
         ...(handoffPath ? { handoffPath } : {}),
         ...(workflowRunId ? { workflowRunId } : {}),
+        ...(resumeNotice ? { resumeNotice } : {}),
         ...(childRuns?.length ? { childRuns } : {}),
         ...(reconciledFromDetachedChild ? { reconciledFromDetachedChild } : {}),
         ...(watchdogBlockers.length ? { watchdogBlockers } : {}),
@@ -614,6 +623,9 @@ export function buildCompletionDetails(result) {
         : undefined;
     const reconciledFromDetachedChild = typeof result.reconciledFromDetachedChild === "string" ? result.reconciledFromDetachedChild : undefined;
     const asyncDir = nonemptyPath(result.asyncDir);
+    // Read here, once per delivery; a re-render parses the line back instead of reading the run again.
+    const stopCause = result.workflow?.stopCause;
+    const resumeNotice = workflowRunId && asyncDir && isReusableWorkflowStopCause(stopCause) ? describeWorkflowResume(asyncDir, workflowRunId) : undefined;
     const watchdogBlockers = [];
     const watchdogConcerns = [];
     const collectWatchdogFindings = (owner, progress) => {
@@ -653,6 +665,7 @@ export function buildCompletionDetails(result) {
         ...(handoffPath ? { handoffPath } : {}),
         ...(rawRunId ? { runId: rawRunId } : {}),
         ...(workflowRunId ? { workflowRunId } : {}),
+        ...(resumeNotice ? { resumeNotice } : {}),
         ...(childRuns.length ? { childRuns } : {}),
         ...(childOutputs?.length ? { childOutputs } : {}),
         ...(reconciledFromDetachedChild ? { reconciledFromDetachedChild } : {}),

package/src/runs/background/result-delivery-ownership.d.ts

@@ -2,6 +2,12 @@ import type { SubagentState } from "../../shared/types.ts";
 type ResultDeliveryState = Pick<SubagentState, "currentSessionId" | "completionOwnerId">;
 export interface ResultDeliveryOwnership {
     owns(sessionId: string, completionOwnerId: unknown): boolean;
+    /**
+     * The completion owner a result is delivered under: `owning-session` when its own owner is another Pi
+     * process that is confirmed dead and this session owns the run, so nothing else can ever deliver it;
+     * otherwise `completionOwnerId`.
+     */
+    deliveryOwnerId(sessionId: string | undefined, completionOwnerId: string | null | undefined, ownerProcess: unknown, parentWorkflowRunId: unknown): string | null | undefined;
     claimedSessionIds(): readonly string[];
 }
 export declare function createResultDeliveryOwnership(state: ResultDeliveryState): ResultDeliveryOwnership;

package/src/runs/background/result-delivery-ownership.js

@@ -1,5 +1,9 @@
 import { ownsRun } from "../shared/run-ownership.js";
 import { inheritedSessionIds } from "../../shared/session-succession.js";
+import { OWNING_SESSION_COMPLETION_OWNER } from "../../shared/completion-owner.js";
+import { checkRecordedPidLiveness, isRecordedPid } from "./stale-run-reconciler.js";
+// A dead process cannot come back, so only that verdict is kept.
+const deadCompletionOwnerIds = new Set();
 export function createResultDeliveryOwnership(state) {
     const currentOwner = () => typeof state.completionOwnerId === "string" && state.completionOwnerId
         ? state.completionOwnerId
@@ -7,10 +11,24 @@ export function createResultDeliveryOwnership(state) {
     return {
         owns(sessionId, completionOwnerId) {
             const owner = currentOwner();
-            if (!owner || completionOwnerId !== owner)
+            if (!owner || (completionOwnerId !== owner && completionOwnerId !== OWNING_SESSION_COMPLETION_OWNER))
                 return false;
             return ownsRun(state.currentSessionId, sessionId);
         },
+        deliveryOwnerId(sessionId, completionOwnerId, ownerProcess, parentWorkflowRunId) {
+            const owner = currentOwner();
+            // A workflow child is reported by its workflow, which has its own owner-exited notice.
+            if (!owner || typeof completionOwnerId !== "string" || completionOwnerId === owner
+                || completionOwnerId === OWNING_SESSION_COMPLETION_OWNER || parentWorkflowRunId
+                || !ownsRun(state.currentSessionId, sessionId))
+                return completionOwnerId;
+            if (!deadCompletionOwnerIds.has(completionOwnerId)) {
+                if (!isRecordedPid(ownerProcess) || checkRecordedPidLiveness(ownerProcess) !== "dead")
+                    return completionOwnerId;
+                deadCompletionOwnerIds.add(completionOwnerId);
+            }
+            return OWNING_SESSION_COMPLETION_OWNER;
+        },
         claimedSessionIds() {
             if (!currentOwner() || !state.currentSessionId)
                 return [];

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

@@ -31,7 +31,7 @@ type ResultWatcherDeps = {
     resultScanLogging?: "all" | "activity" | "off";
     platform?: NodeJS.Platform;
     /** Shared current/predecessor session ownership used by the notifier. */
-    ownership?: Pick<ResultDeliveryOwnership, "owns" | "claimedSessionIds">;
+    ownership?: Pick<ResultDeliveryOwnership, "owns" | "claimedSessionIds" | "deliveryOwnerId">;
     /** Called once the parent has this run's result: the notifier accepted it, or an earlier delivery already did. */
     onResultDelivered?: (runId: string) => void;
 };
@@ -69,6 +69,8 @@ type ResultFileData = CompletionNotification & {
     intercomTarget?: string;
     parallelHandoff?: ParallelHandoffReference;
     notificationDeliveredAt?: unknown;
+    completionOwnerProcess?: unknown;
+    parentWorkflowRunId?: unknown;
 };
 /**
  * Watches persisted async results for the session currently owned by this

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

@@ -19,25 +19,31 @@ const RETRY_DELAY_MS = 100;
 // lease attempt instead of parking this event loop while a runner publishes the same run.
 const CLEANUP_LEASE_WAIT_MS = 0;
 const SLOW_RESULT_SCAN_MS = 500;
-function jsonStringProperty(raw, property) {
-    const matches = raw.matchAll(new RegExp(`"${property}"\\s*:\\s*("(?:\\\\.|[^"\\\\])*")`, "g"));
+/** The last `"property": <value>` whose value matches `valuePattern`, parsed without reading the whole file; malformed reads as none. */
+function jsonPropertyValue(raw, property, valuePattern) {
     let encoded;
-    for (const match of matches)
+    for (const match of raw.matchAll(new RegExp(`"${property}"\\s*:\\s*(${valuePattern})`, "g")))
         encoded = match[1];
     if (!encoded)
         return undefined;
     try {
-        const value = JSON.parse(encoded);
-        return typeof value === "string" && value ? value : undefined;
+        return JSON.parse(encoded);
     }
     catch {
         return undefined;
     }
 }
+function jsonStringProperty(raw, property) {
+    const value = jsonPropertyValue(raw, property, `"(?:\\\\.|[^"\\\\])*"`);
+    return typeof value === "string" && value ? value : undefined;
+}
 function resultFileIdentity(raw, file) {
     return {
         sessionId: jsonStringProperty(raw, "sessionId"),
         completionOwnerId: jsonStringProperty(raw, "completionOwnerId"),
+        // Recorded as a flat object, so a brace-free match is the whole value.
+        completionOwnerProcess: jsonPropertyValue(raw, "completionOwnerProcess", `\\{[^{}]*\\}`),
+        parentWorkflowRunId: jsonStringProperty(raw, "parentWorkflowRunId"),
         runId: file.replace(/\.json$/i, ""),
     };
 }
@@ -105,6 +111,9 @@ export function createResultWatcher(pi, state, resultsDir, completionTtlMs, deps
     // While deliverPendingResults runs, completions skip the batch delay.
     let deliveringPending = 0;
     const identityCache = new Map();
+    // Result file -> last logged mission-sync error. A failed sync is retried
+    // every pass, so the same error is logged once per result file.
+    const reportedMissionSyncFailures = new Map();
     let deliveryActive = true;
     let deliveryEpoch = 0;
     let resultScanTimer = null;
@@ -116,6 +125,7 @@ export function createResultWatcher(pi, state, resultsDir, completionTtlMs, deps
             && typeof completionOwnerId === "string"
             && completionOwnerId === state.completionOwnerId);
     const claimedSessionIds = () => deps.ownership?.claimedSessionIds() ?? [];
+    const deliveryOwnerId = deps.ownership?.deliveryOwnerId ?? ((_sessionId, completionOwnerId) => completionOwnerId);
     const ownsCompletion = (sessionId, completionOwnerId, epoch) => {
         if (!deliveryActive || epoch !== deliveryEpoch)
             return false;
@@ -223,7 +233,7 @@ export function createResultWatcher(pi, state, resultsDir, completionTtlMs, deps
         // files keep their existing diagnostics and compatibility behavior.
         if (!identity.sessionId)
             return true;
-        if (ownsResult(identity.sessionId, identity.completionOwnerId))
+        if (ownsResult(identity.sessionId, deliveryOwnerId(identity.sessionId, identity.completionOwnerId, identity.completionOwnerProcess, identity.parentWorkflowRunId)))
             return true;
         // Acknowledgment removes the observer index; gating on the mission binding instead
         // re-ran mission sync for an unowned result on every scan.
@@ -306,7 +316,7 @@ export function createResultWatcher(pi, state, resultsDir, completionTtlMs, deps
             if (typeof data.sessionId !== "string" || !data.sessionId)
                 return;
             const sessionId = data.sessionId;
-            const completionOwnerId = data.completionOwnerId;
+            const completionOwnerId = deliveryOwnerId(sessionId, data.completionOwnerId, data.completionOwnerProcess, data.parentWorkflowRunId);
             const runId = typeof data.runId === "string" && data.runId
                 ? data.runId
                 : typeof data.id === "string" && data.id ? data.id : file.replace(/\.json$/i, "");
@@ -329,10 +339,15 @@ export function createResultWatcher(pi, state, resultsDir, completionTtlMs, deps
             let observerSucceeded = true;
             try {
                 syncMissionFromAsyncCompletion({ ...data, runId });
+                reportedMissionSyncFailures.delete(file);
             }
             catch (error) {
                 observerSucceeded = false;
-                console.error(`Mission completion sync failed for '${resultPath}':`, error);
+                const message = error instanceof Error ? error.message : String(error);
+                if (reportedMissionSyncFailures.get(file) !== message) {
+                    reportedMissionSyncFailures.set(file, message);
+                    console.error(`Mission completion sync failed for '${resultPath}':`, error);
+                }
             }
             try {
                 deps.observeCompletion?.({ ...data, runId });
@@ -484,6 +499,7 @@ export function createResultWatcher(pi, state, resultsDir, completionTtlMs, deps
                 ...data,
                 id: data.id ?? runId,
                 runId,
+                completionOwnerId,
                 triggerTurn,
                 intercomDelivered,
                 ...(nestedChildren?.length ? { nestedChildren } : {}),

package/src/runs/background/run-child-session.d.ts

@@ -91,12 +91,7 @@ export interface RunChildSessionResult {
     toolCount: number;
     durationMs: number;
     model?: string;
-    nativeMachine?: {
-        provider: "herdr";
-        machineId: string;
-        initialGit?: import("../../shared/types.ts").HerdrRemoteGitStatus;
-        finalGit?: import("../../shared/types.ts").HerdrRemoteGitStatus;
-    };
+    nativeMachine?: import("../../shared/types.ts").SingleResult["nativeMachine"];
     error?: string;
     finalOutput: string;
     outputState: SubagentOutputState;

package/src/runs/background/run-child-session.js

@@ -526,7 +526,7 @@ export function runChildSession(input) {
                     toolCount,
                     durationMs: Date.now() - startedAt,
                     model,
-                    nativeMachine: session?.machineEvidence ? { provider: "herdr", machineId: session.machineEvidence.machineId, ...(session.machineEvidence.initial ? { initialGit: session.machineEvidence.initial } : {}), ...(session.machineEvidence.final ? { finalGit: session.machineEvidence.final } : {}) } : undefined,
+                    nativeMachine: session?.machineEvidence ? { provider: session.machineEvidence.provider, machineId: session.machineEvidence.machineId, ...(session.machineEvidence.initial ? { initialGit: session.machineEvidence.initial } : {}), ...(session.machineEvidence.final ? { finalGit: session.machineEvidence.final } : {}) } : undefined,
                     error: stopped ? stopMessage() : timedOut ? (error ?? timeoutMessage()) : interrupted || (forcedDrainAfterFinalSuccess && !forcedDrainAfterEmptyTerminal && !commandError) ? undefined : finalError,
                     finalOutput: (timedOut || stopped) && !finalOutput.trim() ? (stopped ? stopMessage() : error ?? timeoutMessage()) : finalOutput,
                     outputState: finalOutput.trim() ? "present" : "absent",

package/src/runs/background/run-status.js

@@ -36,6 +36,7 @@ import { workflowAsyncChildSteeringGuidance } from "../shared/workflow-async-chi
 import { formatWorkflowKeyRevival, projectWorkflowKeyRevival } from "../../workflows/workflow-revival.js";
 import { capSummaryOutputs } from "../shared/single-output.js";
 import { ownsRun } from "../shared/run-ownership.js";
+import { foregroundChildStateLabel } from "../foreground/foreground-history.js";
 /** A step whose structured output has a path line needs only a short inline preview. */
 const STRUCTURED_PREVIEW_WITH_PATH_CHARS = 500;
 function formatProcessTerminal(value) {
@@ -200,7 +201,7 @@ function formatRememberedForegroundStatus(run) {
     for (const child of run.children) {
         const output = rememberedForegroundChildOutput(child).trim().split(/\r?\n/).find((line) => line.trim());
         const parts = [
-            `${child.index + 1}. ${child.sessionName?.trim() || child.agent} ${child.status}`,
+            `${child.index + 1}. ${child.sessionName?.trim() || child.agent} ${foregroundChildStateLabel(run, child)}`,
             child.exitCode !== undefined ? `exit ${child.exitCode}` : undefined,
             child.detachedReason ? `detached: ${child.detachedReason}` : undefined,
             child.acceptance ? `acceptance: ${child.acceptance.status}` : undefined,

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

@@ -24,6 +24,12 @@ interface ReconcileAsyncRunOptions {
     missingStatusGraceMs?: number;
     staleAlivePidMs?: number;
     pidNamespaceScope?: () => string | undefined;
+    bootId?: () => string | undefined;
+    /**
+     * This process's completion owner, for an owner-exited workflow repair to adopt so the session that
+     * reopened it delivers its notice. Only callers whose session owns the run pass it.
+     */
+    adoptCompletionOwnerId?: string;
 }
 interface ReconcileAsyncRunResult {
     status: AsyncStatus | null;
@@ -33,5 +39,24 @@ interface ReconcileAsyncRunResult {
 }
 export declare function reconcileNestedAsyncDescendants(route: NestedRoute, options?: ReconcileAsyncRunOptions): void;
 export declare function checkPidLiveness(pid: number, kill?: KillFn, probeZombie?: boolean): PidLiveness;
+export interface RecordedPid {
+    pid: number;
+    pidNamespaceScope?: string;
+    bootId?: string;
+}
+export declare function isRecordedPid(value: unknown): value is RecordedPid;
+export interface RecordedPidObservation {
+    observedScope: string | undefined;
+    observedBootId: string | undefined;
+    kill?: KillFn;
+    /** Replaces the default `checkPidLiveness` probe. */
+    probe?: (pid: number) => PidLiveness;
+}
+/**
+ * Liveness of a pid saved in a status file. A pid saved under another boot is dead without a
+ * probe, but only when both sides are in the same pid namespace or neither records one: a
+ * macOS host reading a Linux container's runs must not compare their boot ids.
+ */
+export declare function checkRecordedPidLiveness(recorded: RecordedPid, observation?: RecordedPidObservation): PidLiveness;
 export declare function reconcileAsyncRun(asyncDir: string, options?: ReconcileAsyncRunOptions, observeStatus?: RawDrainStatusObserver): ReconcileAsyncRunResult;
 export {};