@hheei/pi-subagents 0.2.4 → 0.4.0

package/dist/manager.js

@@ -1,19 +1,37 @@
+import { readFile } from "node:fs/promises";
 import { errorMessage, isRecord } from "@hheei/pi-ext-core";
+import { attachRetainedChild } from "./child-process.js";
+import { isOperationError } from "./domain.js";
 import { stripHindsightContent } from "./launch-spec.js";
+import { commitLease, createConversationLease, RUNTIME_ENDED_RESUME, } from "./lease.js";
 import { BridgeError, isChildInputPayload, isChildLifecyclePayload, isContactReportPayload, } from "./protocol.js";
 import { findSessionFile, planSessionPlacement } from "./session-bootstrap.js";
-import { readSessionJsonlEntries } from "./session-fork.js";
-import { createStateProjector } from "./state.js";
+async function readSessionJsonlEntries(filePath) {
+    const content = await readFile(filePath, "utf8");
+    const entries = [];
+    for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed.length > 0) {
+            try {
+                entries.push(JSON.parse(trimmed));
+            }
+            catch {
+                // Ignore corrupted line
+            }
+        }
+    }
+    return entries;
+}
+import { createStateProjector, parseTranscriptFacts, transcriptFacts, } from "./state.js";
 /**
  * How long an idle child keeps its runtime. A background child holds a whole Pi process and its
- * session lock, so an idle one is reclaimed after this window and a later `send_agent` starts it
+ * session lock, so an idle one is reclaimed after this window and a later `agent_send` starts it
  * again from the same session.
  */
 export const SUBAGENT_IDLE_TIMEOUT_MS = 15_000;
 export const SUBAGENT_SETTLED_CLOSE_TIMEOUT_MS = 15_000;
 /** How long stop waits for an adopted child's bridge to go away before calling the exit unconfirmed. */
 export const SUBAGENT_EXIT_WAIT_MS = 2_000;
-const STOPPED_SEND_REASON = "Child is stopped; a stopped child never resumes — spawn a new child if this work is still needed";
 function diagnose(message) {
     if (process.env.DEBUG || process.env.PI_SUBAGENTS_DEBUG) {
         console.error(`pi-subagents: ${message}`);
@@ -29,9 +47,19 @@ function failure(operation, reason, childId, state, sideEffects = [], safeToRetr
         safeToRetry,
     };
 }
-function publicChild(record, live) {
+function acknowledgedPath(response) {
+    if (!isRecord(response) ||
+        response.accepted !== true ||
+        typeof response.path !== "string" ||
+        response.path === "") {
+        throw new BridgeError("invalid_state", "Child did not confirm its session path");
+    }
+    return response.path;
+}
+function publicChild(record, live, path = record.sessionPath) {
     return {
         id: record.subagentId,
+        ...(path === undefined ? {} : { path }),
         agent: record.launchConfig.agent.name,
         ...(record.launchConfig.agent.displayName === undefined
             ? {}
@@ -40,12 +68,12 @@ function publicChild(record, live) {
         presentation: record.presentation,
         cwd: record.cwd,
         sessionId: record.sessionId,
+        ...(record.initialTask === undefined ? {} : { task: record.initialTask }),
         ...(record.latestSummary === undefined ? {} : { summary: record.latestSummary }),
         ...(record.activeTool === undefined ? {} : { activeTool: record.activeTool }),
         ...(record.usage === undefined ? {} : { usage: record.usage }),
         ...(record.interrupted === undefined ? {} : { interrupted: record.interrupted }),
         freshness: live ? "live" : "last_known",
-        interactive: record.launchConfig.interactive,
         model: record.launchConfig.model,
         thinking: record.launchConfig.thinking,
         createdAt: record.createdAt,
@@ -64,25 +92,6 @@ function withDeadline(operation, timeoutMs) {
         });
     });
 }
-function sessionContainsUserInput(entries, expected) {
-    return entries.some((entry) => {
-        const value = isRecord(entry) ? entry : undefined;
-        const message = isRecord(value?.message) ? value.message : undefined;
-        if (message?.role !== "user")
-            return false;
-        if (typeof message.content === "string")
-            return message.content === expected;
-        if (!Array.isArray(message.content))
-            return false;
-        const text = message.content
-            .map((part) => {
-            const content = isRecord(part) ? part : undefined;
-            return content?.type === "text" && typeof content.text === "string" ? content.text : "";
-        })
-            .join("");
-        return text === expected;
-    });
-}
 /**
  * Extracts the trailing text of the most recent assistant message in session entries.
  * Used to automatically capture a subagent's final output without requiring a tool call.
@@ -114,6 +123,7 @@ export class SubagentManager {
     #deps;
     #chains = new Map();
     #processes = new Map();
+    #ready;
     /** Panels this process opened. A panel child's process is held by the host, not by us. */
     #attachments = new Map();
     /**
@@ -121,36 +131,22 @@ export class SubagentManager {
      * process is not this child's runtime any more, so it is neither live nor ours to close.
      */
     #leftSessions = new Set();
-    /**
-     * Children whose runtime this process never saw: a panel child outlives a parent restart, so a
-     * record that still names a runtime after recovery did not reconnect may be running right now.
-     * Nothing here can observe it and one session never gets two writers, so the next send refuses
-     * until an explicit stop clears the record.
-     */
-    #unresolvedRuntimes = new Set();
     /** Bumped by every inbound bridge signal, so a reclaim in flight can tell the child moved. */
     #activity = new Map();
     #projectors = new Map();
+    /** Display paths do not imply that a session has been flushed to disk. */
+    #paths = new Map();
     /** Known child work in flight, separate from failures recorded before Pi finally settles. */
     #working = new Set();
     /** A settled event from an older run cannot clear a newer synchronous start signal. */
     #workVersions = new Map();
     #settledPanelCloseTimers = new Map();
-    #autoReportTimers = new Map();
+    #pendingAutoReports = new Map();
+    #autoReportBatchTimer;
     #lastDeliveredTurn = new Map();
     #stopping = new Set();
     #listeners = new Set();
-    #childEventListeners = new Set();
     #unsubscribe = [];
-    #taskRegistry;
-    bindTaskRegistry(registry) {
-        this.#taskRegistry = registry;
-        return () => {
-            if (this.#taskRegistry === registry) {
-                this.#taskRegistry = undefined;
-            }
-        };
-    }
     constructor(deps) {
         this.#deps = deps;
         // The manager owns the transport's two inbound streams: child events and connection
@@ -158,17 +154,7 @@ export class SubagentManager {
         this.#unsubscribe.push(deps.bridge.onEvent((childId, event) => this.handleEvent(childId, event)));
         this.#unsubscribe.push(deps.bridge.onConnectionChange((childId, connected) => this.handleConnectionChange(childId, connected)));
     }
-    /**
-     * Observes the raw bridge events of every child. A Task producer needs the child's
-     * `task_result` and settle events without also owning the bridge connection.
-     */
-    onChildEvent(listener) {
-        this.#childEventListeners.add(listener);
-        return () => {
-            this.#childEventListeners.delete(listener);
-        };
-    }
-    /** Presentation-only: widget and similar projections re-read list() after this. */
+    /** Presentation-only: status and similar projections re-read list() after this. */
     onChange(listener) {
         this.#listeners.add(listener);
         return () => {
@@ -176,6 +162,11 @@ export class SubagentManager {
         };
     }
     dispose() {
+        if (this.#autoReportBatchTimer !== undefined) {
+            clearTimeout(this.#autoReportBatchTimer);
+            this.#autoReportBatchTimer = undefined;
+        }
+        this.#pendingAutoReports.clear();
         for (const timer of this.#settledPanelCloseTimers.values()) {
             clearTimeout(timer);
         }
@@ -190,12 +181,17 @@ export class SubagentManager {
      */
     closeLocalConnections() {
         this.dispose();
+        if (this.#autoReportBatchTimer !== undefined) {
+            clearTimeout(this.#autoReportBatchTimer);
+            this.#autoReportBatchTimer = undefined;
+        }
+        this.#pendingAutoReports.clear();
         this.#processes.clear();
         this.#attachments.clear();
         this.#leftSessions.clear();
-        this.#unresolvedRuntimes.clear();
         this.#activity.clear();
         this.#projectors.clear();
+        this.#paths.clear();
         this.#working.clear();
         this.#workVersions.clear();
         this.#notify();
@@ -215,10 +211,6 @@ export class SubagentManager {
             const launch = await openPanel(record);
             if (launch.handle !== undefined)
                 this.#attachments.set(record.subagentId, launch.handle);
-            // A panel that could not be opened may still exist and still own the child's session, and
-            // nothing here can observe it: the child stays unavailable until an explicit stop.
-            if (launch.unconfirmed === true)
-                this.#unresolvedRuntimes.add(record.subagentId);
             if (launch.failure !== undefined)
                 throw new Error(launch.failure);
             return;
@@ -249,117 +241,61 @@ export class SubagentManager {
      */
     async #runtimeEnded(id) {
         const runtime = this.#processes.get(id);
-        // A process that is still running is not an ended runtime: the bridge may be reconnecting.
+        // A live process is not over. The lock is the connection: an exit this process already
+        // saw is recorded here even when the claim has not dropped yet. A later release is the
+        // same end, and only the transition that leaves `running` schedules a report.
         if (runtime?.alive === true)
             return;
-        if (runtime !== undefined)
+        const sawExit = runtime !== undefined;
+        if (sawExit) {
             this.#processes.delete(id);
-        if (this.#deps.bridge.isConnected(id))
+            if (this.#deps.bridge.isConnected(id))
+                this.#deps.bridge.disconnect(id);
+        }
+        if (!sawExit && this.#deps.bridge.isConnected(id))
             return;
         this.#working.delete(id);
-        await this.#releasePanel(id);
+        await this.#dropDeadPanel(id);
         this.#clearSettledPanelClose(id);
         this.#projectors.delete(id);
-        const record = await this.#update(id, (current) => {
-            if (current.intent === "stopped")
-                return current;
-            if (current.state !== "running")
-                return current;
-            return {
-                ...current,
-                state: "blocked",
-                interrupted: current.presentation === "panel"
-                    ? "The child bridge disconnected; its panel process exit is not confirmed"
-                    : "The child runtime ended while a turn was in flight; the session is unchanged and a send resumes it",
-            };
-        });
-        if (record.interrupted !== undefined && record.intent !== "stopped") {
-            this.#scheduleAutoReport(id, record);
-        }
-        if (record.presentation === "panel" &&
-            record.intent === "active" &&
-            record.state !== "done" &&
-            record.runtime !== undefined &&
-            !this.#attachments.has(id)) {
-            // An adopted child has no host handle: losing its bridge cannot prove its exit.
-            this.#unresolvedRuntimes.add(id);
-        }
+        await this.#recordWriterGone(id);
     }
-    /** True when a runtime for this child was started here and may still own its session. */
+    /** True while a writer this process can see is still there: a held lock, or a process handle. A panel tab is not a writer. */
     #runtimeStarted(id) {
-        return this.#isLive(id) || this.#processes.has(id) || this.#attachments.has(id);
+        return this.#isLive(id) || this.#processes.has(id);
     }
     /**
-     * Says why this child cannot take input while a runtime may still own its session: one this
-     * process holds, one a host panel may still be running, or one the record names that never
-     * reconnected after a parent restart. Only an explicit stop clears that doubt.
+     * A new runtime may not start while a writer this process can see is still there. A connected
+     * bridge is that writer, so input goes to it instead of through here. A leftover tab is not a writer.
      */
-    async #runtimeDoubt(id) {
-        if (this.#attachments.has(id)) {
-            // A panel the host confirms is gone stops holding this child — the handle it left behind is
-            // also what a retried stop would act on, so it is released here before refusing.
-            await this.#releasePanel(id).catch(() => undefined);
-            if ((await this.#deps.registry.get(id))?.intent === "stopped") {
-                return STOPPED_SEND_REASON;
-            }
-        }
-        if (this.#runtimeStarted(id)) {
-            return "This child's previous runtime is not confirmed gone (its process or panel may still be running); stop the child to end it, then spawn a new one for this work";
-        }
-        if (this.#unresolvedRuntimes.has(id)) {
-            return "This child's panel runtime is disconnected and its exit cannot be confirmed; no replacement was started. Close any remaining panel, stop the child, then spawn a new child for this work";
+    #runtimeDoubt(id) {
+        if (this.#processes.get(id)?.alive === true) {
+            return "This child's process is still running; stop it, then send to this same child";
         }
         return undefined;
     }
-    /** Counts an inbound bridge signal, whether or not its handling is queued behind another task. */
-    #bumpActivity(id) {
+    /**
+     * Counts an inbound signal before its handler is queued, so a decision already in flight can see
+     * it. invalidateReport is only for a new turn: compaction, a late update, or the bridge dropping
+     * are not the child starting over, and treating them as such dropped the reply.
+     */
+    #bumpActivity(id, invalidateReport = true) {
         this.#activity.set(id, (this.#activity.get(id) ?? 0) + 1);
-        this.#clearAutoReport(id);
+        if (invalidateReport)
+            this.#clearAutoReport(id);
         this.#clearSettledPanelClose(id);
     }
     /**
-     * Releases a panel whose child has gone away, without being asked to. Only a panel the host
-     * confirms is no longer running its child is closed: a live process behind a missing bridge may
-     * be serving the session the human switched to, and nobody asked for that panel to be ended. A
-     * panel that stays keeps its handle, so an explicit stop can still close it.
+     * Forgets a panel the host already says is gone, and closes that leftover tab. A tab the host
+     * still reports, or cannot see, stays in hand so stop can close it. It does not block a send.
      */
-    async #releasePanel(id) {
+    async #dropDeadPanel(id) {
         const attachment = this.#attachments.get(id);
         if (attachment === undefined)
             return;
         const observed = await attachment.observe();
         if (!(observed.known && !observed.alive))
             return;
-        let retired;
-        const record = await this.#update(id, (current) => {
-            if (current.intent === "stopped")
-                return current;
-            retired = current.runtime?.runtimeIdentity;
-            const { runtime: _runtime, ...withoutRuntime } = current;
-            if (current.state === "done" || current.state === "blocked") {
-                return {
-                    ...withoutRuntime,
-                    state: current.state,
-                };
-            }
-            return {
-                ...withoutRuntime,
-                intent: "stopped",
-                state: "error",
-                interrupted: "The host reports that the child process exited while running; the cause is unknown. Spawn a new child for more work",
-            };
-        });
-        if (retired !== undefined)
-            this.#deps.tokens?.forget(retired);
-        const projector = this.#projectors.get(id);
-        if (record.state === "done" && projector !== undefined) {
-            projector.syncState("done");
-        }
-        if (record.intent === "stopped") {
-            this.#clearSettledPanelClose(id);
-            this.#projectors.delete(id);
-            this.#unresolvedRuntimes.delete(id);
-        }
         this.#attachments.delete(id);
         try {
             const cleanup = await attachment.cleanup();
@@ -371,6 +307,58 @@ export class SubagentManager {
             diagnose(`could not close the leftover ${attachment.identity.host} panel of child ${id}: ${errorMessage(error)}`);
         }
     }
+    /**
+     * The ledger stops naming a writer that is gone. A child that was running becomes blocked, once,
+     * unless its session already ends in a completed reply: that reply is delivered instead. The next
+     * send starts the same session again. Callers that still have a tab close it themselves.
+     */
+    async #recordWriterGone(id) {
+        const current = await this.#deps.registry.get(id);
+        if (current !== undefined &&
+            current.state === "running" &&
+            current.intent !== "stopped" &&
+            (await this.#finishedReply(id, current.unacknowledgedInput))) {
+            const released = await this.#releaseRuntime(id, "finished");
+            if (released === undefined)
+                return;
+            const next = await this.#update(id, (entry) => {
+                const { interrupted: _interrupted, ...rest } = entry;
+                return { ...rest, state: "done" };
+            });
+            this.#scheduleAutoReport(id, next);
+            return;
+        }
+        await this.#releaseRuntime(id, "drop");
+    }
+    /**
+     * True when the session file ends on a completed assistant reply and any send still being
+     * confirmed is already in that file. An unflushed prompt is not a finished turn.
+     */
+    async #finishedReply(id, expectedInput) {
+        const entries = await this.#diskEntries(id);
+        if (entries === undefined || !persistedReplyFinished(entries))
+            return false;
+        if (expectedInput === undefined)
+            return true;
+        return transcriptFacts(entries, expectedInput).containsInput;
+    }
+    /** Runtime leaves the ledger only through a lease edge. */
+    async #releaseRuntime(id, outcome) {
+        const current = await this.#deps.registry.get(id);
+        if (current === undefined)
+            return undefined;
+        const identity = current.runtime?.runtimeIdentity;
+        const next = await commitLease(this.#deps.registry, id, { type: "runtime-gone", outcome });
+        if (identity !== undefined && next.runtime === undefined)
+            this.#deps.tokens?.forget(identity);
+        if (outcome === "drop" &&
+            current.state === "running" &&
+            current.intent !== "stopped" &&
+            next.state === "blocked") {
+            this.#scheduleAutoReport(id, next);
+        }
+        return next;
+    }
     /** Waits for a child's bridge connection to end; false when it is still connected after the wait. */
     #awaitDisconnect(id, timeoutMs) {
         if (!this.#deps.bridge.isConnected(id))
@@ -397,21 +385,29 @@ export class SubagentManager {
      * only ever closed on a judgement, never on a guess.
      */
     #scheduleAutoReport(id, record) {
-        this.#clearAutoReport(id);
-        const timer = setTimeout(() => {
-            this.#autoReportTimers.delete(id);
-            void this.#performAutoReport(id, record).catch((error) => {
-                diagnose(`failed to report child ${id}: ${errorMessage(error)}`);
-            });
-        }, 5_000);
-        timer.unref?.();
-        this.#autoReportTimers.set(id, timer);
+        this.#pendingAutoReports.set(id, record);
+        if (this.#autoReportBatchTimer !== undefined) {
+            clearTimeout(this.#autoReportBatchTimer);
+        }
+        // Batch reports: if all children settled, flush in 500ms; otherwise wait up to 10000ms for others
+        const delayMs = this.#working.size > 0 ? 10_000 : 500;
+        this.#autoReportBatchTimer = setTimeout(async () => {
+            this.#autoReportBatchTimer = undefined;
+            const batch = [...this.#pendingAutoReports.entries()];
+            this.#pendingAutoReports.clear();
+            for (const [childId, childRecord] of batch) {
+                await this.#performAutoReport(childId, childRecord).catch((error) => {
+                    diagnose(`failed to report child ${childId}: ${errorMessage(error)}`);
+                });
+            }
+        }, delayMs);
+        this.#autoReportBatchTimer.unref?.();
     }
     #clearAutoReport(id) {
-        const timer = this.#autoReportTimers.get(id);
-        if (timer !== undefined) {
-            clearTimeout(timer);
-            this.#autoReportTimers.delete(id);
+        this.#pendingAutoReports.delete(id);
+        if (this.#pendingAutoReports.size === 0 && this.#autoReportBatchTimer !== undefined) {
+            clearTimeout(this.#autoReportBatchTimer);
+            this.#autoReportBatchTimer = undefined;
         }
     }
     #scheduleSettledPanelClose(id) {
@@ -461,7 +457,8 @@ export class SubagentManager {
             if (attachment !== undefined) {
                 const observed = await attachment.observe();
                 if (observed.known && !observed.alive) {
-                    await this.#releasePanel(id);
+                    await this.#dropDeadPanel(id);
+                    await this.#recordWriterGone(id);
                     return;
                 }
                 if ((this.#activity.get(id) ?? 0) !== activity) {
@@ -494,25 +491,9 @@ export class SubagentManager {
                     this.#processes.delete(id);
                 if (attachment !== undefined)
                     this.#attachments.delete(id);
-                this.#unresolvedRuntimes.delete(id);
-                await this.#update(id, (current) => {
-                    if (current.intent === "stopped")
-                        return current;
-                    const { runtime: _runtime, ...withoutRuntime } = current;
-                    return withoutRuntime;
-                });
-            }
-            else {
-                await this.#update(id, (current) => {
-                    if (current.intent === "stopped")
-                        return current;
-                    return {
-                        ...current,
-                        state: "error",
-                        interrupted: "The child panel is not confirmed gone: the child process may still be running",
-                    };
-                });
+                await this.#releaseRuntime(id, "drop");
             }
+            // The tab is still there, or the host could not say. Leave it. The caller closes it.
         });
     }
     async #performAutoReport(id, _record) {
@@ -523,21 +504,37 @@ export class SubagentManager {
             return;
         const activity = this.#activity.get(id) ?? 0;
         const workVersion = this.#workVersions.get(id) ?? 0;
-        const entries = await this.#entries(id);
-        const text = entries !== undefined ? extractLastAssistantText(entries) : undefined;
+        const facts = await this.#facts(id);
+        const text = facts?.summary;
         await this.#mutate(id, async () => {
             const current = await this.#deps.registry.get(id);
+            const activityMoved = (this.#activity.get(id) ?? 0) !== activity;
+            const versionMoved = (this.#workVersions.get(id) ?? 0) !== workVersion;
             if (current === undefined ||
                 current.intent === "stopped" ||
                 current.state === "running" ||
                 this.#working.has(id) ||
-                (this.#activity.get(id) ?? 0) !== activity ||
-                (this.#workVersions.get(id) ?? 0) !== workVersion)
+                activityMoved ||
+                versionMoved) {
+                // Still settled: the signal was bookkeeping, not a new turn. Dropping the reply here left
+                // the parent silent until the process died and the ledger was still running.
+                if (current !== undefined &&
+                    current.intent !== "stopped" &&
+                    current.state !== "running" &&
+                    !this.#working.has(id) &&
+                    (activityMoved || versionMoved)) {
+                    this.#scheduleAutoReport(id, current);
+                }
                 return;
-            const hasError = record.state === "error" ||
-                (record.interrupted !== undefined && record.interrupted.trim() !== "");
-            const isBlocked = hasError;
-            if (!isBlocked && (text === undefined || text.trim() === "")) {
+            }
+            const isError = current.state === "error" || record.state === "error";
+            const isBlocked = !isError &&
+                (current.state === "blocked" ||
+                    record.state === "blocked" ||
+                    (current.interrupted !== undefined && current.interrupted.trim() !== "") ||
+                    (record.interrupted !== undefined && record.interrupted.trim() !== ""));
+            const failed = isError || isBlocked;
+            if (!failed && (text === undefined || text.trim() === "")) {
                 const projector = this.#projectors.get(id);
                 if (projector !== undefined) {
                     projector.syncState("done");
@@ -549,22 +546,19 @@ export class SubagentManager {
                         state: "done",
                     };
                 });
-                if (this.#taskRegistry !== undefined) {
-                    this.#taskRegistry.settle(id, {
-                        status: "completed",
-                        output: "",
-                        truncated: false,
-                    });
-                }
                 return;
             }
             let message;
-            if (isBlocked) {
-                if (record.interrupted !== undefined && record.interrupted.trim() !== "") {
+            const interruptedText = current.interrupted?.trim() || record.interrupted?.trim();
+            if (isError) {
+                message = interruptedText || "Subagent failed without error details.";
+            }
+            else if (isBlocked) {
+                if (interruptedText !== undefined && interruptedText !== "") {
                     message =
                         text !== undefined && text.trim() !== ""
-                            ? `${record.interrupted}\n\n${text}`
-                            : record.interrupted;
+                            ? `${interruptedText}\n\n${text}`
+                            : interruptedText;
                 }
                 else if (text !== undefined && text.trim() !== "") {
                     message = text;
@@ -576,13 +570,15 @@ export class SubagentManager {
             else {
                 message = text ?? "";
             }
-            if (this.#lastDeliveredTurn.get(id) === message)
+            const lastDelivered = this.#lastDeliveredTurn.get(id);
+            if (lastDelivered !== undefined &&
+                lastDelivered.workVersion === workVersion &&
+                lastDelivered.message === message) {
                 return;
-            this.#lastDeliveredTurn.set(id, message);
-            const reason = isBlocked ? "blocked" : "success";
-            const taskStatus = isBlocked ? "failed" : "completed";
+            }
+            const reason = isError ? "error" : isBlocked ? "blocked" : "success";
             const projector = this.#projectors.get(id);
-            const updatedRecord = !isBlocked
+            const updatedRecord = !failed
                 ? await this.#update(id, (current) => {
                     const { interrupted: _interrupted, ...clean } = current;
                     return {
@@ -592,26 +588,26 @@ export class SubagentManager {
                 })
                 : await this.#update(id, (current) => ({
                     ...current,
-                    state: "blocked",
+                    state: isError ? "error" : "blocked",
                     interrupted: current.interrupted ?? message,
                 }));
             if (projector !== undefined) {
-                projector.syncState(isBlocked ? "blocked" : "done");
+                projector.syncState(isError ? "error" : isBlocked ? "blocked" : "done");
             }
             this.#scheduleSettledPanelClose(id);
+            let deliveryOk = true;
             if (this.#deps.channel !== undefined) {
-                await this.contactParent(id, reason, message, updatedRecord);
+                const contactResult = await this.contactParent(id, reason, message, updatedRecord);
+                if (isOperationError(contactResult)) {
+                    deliveryOk = false;
+                }
             }
-            if (this.#taskRegistry !== undefined) {
-                this.#taskRegistry.settle(id, {
-                    status: taskStatus,
-                    output: message,
-                    truncated: false,
-                });
+            if (deliveryOk) {
+                this.#lastDeliveredTurn.set(id, { workVersion, message });
             }
         });
     }
-    /** Reads a child's session entries; exposed for Task completion inspection. */
+    /** Reads a child's session entries; used by transcript inspection fallbacks. */
     async getEntries(id) {
         return this.#entries(id);
     }
@@ -664,6 +660,37 @@ export class SubagentManager {
         }
         return { sessionPath: record.sessionPath, persistence: record.persistence };
     }
+    /** The session file, when the bridge cannot answer. A missing file is not an empty transcript. */
+    async #diskEntries(id) {
+        const record = await this.#deps.registry.get(id).catch(() => undefined);
+        if (record === undefined)
+            return undefined;
+        const sessionPath = record.sessionPath ??
+            (await findSessionFile(record.launchConfig.sessionDir, record.sessionId));
+        if (sessionPath === undefined)
+            return undefined;
+        try {
+            const diskEntries = await readSessionJsonlEntries(sessionPath);
+            return diskEntries.length > 0 ? diskEntries : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Usage, the last assistant text, and whether one input landed. The child computes this
+     * from the session it already has; the transcript is not copied into the mailbox.
+     */
+    async #facts(id, expectedInput) {
+        if (this.#deps.bridge.isConnected(id)) {
+            const response = await this.#request(id, "session_facts", expectedInput === undefined ? undefined : { expectedInput }).catch(() => undefined);
+            const facts = parseTranscriptFacts(response);
+            if (facts !== undefined)
+                return facts;
+        }
+        const entries = await this.#diskEntries(id);
+        return entries === undefined ? undefined : transcriptFacts(entries, expectedInput);
+    }
     /** Reads a child's session entries over the bridge, falling back to disk when disconnected. */
     async #entries(id) {
         if (this.#deps.bridge.isConnected(id)) {
@@ -672,22 +699,7 @@ export class SubagentManager {
                 return response.entries;
             }
         }
-        const record = await this.#deps.registry.get(id).catch(() => undefined);
-        if (record !== undefined) {
-            const sessionPath = record.sessionPath ??
-                (await findSessionFile(record.launchConfig.sessionDir, record.sessionId));
-            if (sessionPath !== undefined) {
-                try {
-                    const diskEntries = await readSessionJsonlEntries(sessionPath);
-                    if (diskEntries.length > 0)
-                        return diskEntries;
-                }
-                catch {
-                    // return undefined below
-                }
-            }
-        }
-        return undefined;
+        return this.#diskEntries(id);
     }
     #request(id, operation, payload) {
         return withDeadline(this.#deps.bridge.request(id, operation, payload), this.#deps.deadlineMs ?? 30_000);
@@ -719,8 +731,6 @@ export class SubagentManager {
                     await this.#settleUnrecovered(record);
                     return undefined;
                 }
-                // The runtime this record names answered, so the doubt about it is gone.
-                this.#unresolvedRuntimes.delete(record.subagentId);
                 await this.#adopt(record.subagentId);
                 return { childId: record.subagentId };
             }
@@ -738,29 +748,18 @@ export class SubagentManager {
         };
     }
     /**
-     * A record that names a runtime which did not reconnect. A background child is held by its
-     * parent's stdin pipe, so it died with the parent and that evidence is stale; a panel child is
-     * held by the host and may still be running, so nothing here may start a second runtime for the
-     * same session until the user stops it.
+     * A record that names a runtime which did not reconnect. A background child died with this
+     * process, because its stdin pipe did. A panel child is the same fact as any other missing
+     * writer: the ledger drops it, and a later send starts the session again.
      */
     async #settleUnrecovered(record) {
         this.#working.delete(record.subagentId);
-        const retired = record.runtime;
-        if (retired === undefined)
-            return;
+        this.#projectors.delete(record.subagentId);
         if (record.presentation === "panel") {
-            this.#unresolvedRuntimes.add(record.subagentId);
+            await this.#recordWriterGone(record.subagentId);
             return;
         }
-        await this.#update(record.subagentId, (current) => {
-            const { runtime: _runtime, ...rest } = current;
-            return {
-                ...rest,
-                ...(current.state === "running" ? { state: "done" } : {}),
-                interrupted: "The child runtime ended with the parent process; a later send starts it again from the same session",
-            };
-        });
-        this.#deps.tokens?.forget(retired.runtimeIdentity);
+        await this.#releaseRuntime(record.subagentId, "parent-exit");
     }
     /** Reads a connected child's real state and puts the record back in step with it. */
     async #adopt(id) {
@@ -769,9 +768,9 @@ export class SubagentManager {
         const record = await this.#deps.registry.get(id);
         if (projector === undefined || record === undefined)
             return;
-        const entries = await this.#entries(id);
-        if (entries !== undefined)
-            projector.rebuild(entries);
+        const facts = await this.#facts(id, record.unacknowledgedInput);
+        if (facts !== undefined)
+            projector.applyTranscriptFacts(facts);
         const state = await this.#request(id, "get_state");
         if (!isRecord(state) ||
             typeof state.idle !== "boolean" ||
@@ -779,6 +778,9 @@ export class SubagentManager {
             throw new BridgeError("invalid_state", `Child ${id} did not confirm its current work state`);
         }
         const idle = state.idle && !state.pendingMessages;
+        if (typeof state.path === "string" && state.path !== "") {
+            this.#paths.set(id, state.path);
+        }
         if ((this.#workVersions.get(id) ?? 0) === workVersion) {
             if (idle)
                 this.#working.delete(id);
@@ -791,9 +793,7 @@ export class SubagentManager {
         if (projector.snapshot().state !== "error")
             projector.syncState(idle ? "done" : "running");
         const snapshot = projector.snapshot();
-        const confirmedInput = entries !== undefined &&
-            record.unacknowledgedInput !== undefined &&
-            sessionContainsUserInput(entries, record.unacknowledgedInput)
+        const confirmedInput = facts?.containsInput && record.unacknowledgedInput !== undefined
             ? record.unacknowledgedInput
             : undefined;
         await this.#update(id, (current) => {
@@ -803,12 +803,11 @@ export class SubagentManager {
                 ? current
                 : (({ unacknowledgedInput: _input, ...rest }) => rest)(current);
             const hasError = snapshot.state === "error";
+            const { interrupted: _interrupted, ...withoutInterrupted } = base;
+            const { latestSummary: _summary, activeTool: _tool, usage: _usage, ...withoutVolatile } = withoutInterrupted;
             return {
-                ...base,
+                ...withoutVolatile,
                 state: hasError ? "error" : idle ? "done" : "running",
-                ...(snapshot.summary === undefined ? {} : { latestSummary: snapshot.summary }),
-                usage: snapshot.usage,
-                ...(snapshot.interrupted === undefined ? {} : { interrupted: snapshot.interrupted }),
             };
         }, workVersion);
         if (snapshot.state === "done" || snapshot.state === "blocked" || snapshot.state === "error") {
@@ -866,8 +865,10 @@ export class SubagentManager {
             this.#working.add(childId);
             this.#notify();
             await withDeadline(this.#start(record), this.#deps.deadlineMs ?? 60_000);
+            let path;
             try {
-                await this.#request(record.subagentId, "prompt", { message: cleanTask });
+                path = acknowledgedPath(await this.#request(record.subagentId, "prompt", { message: cleanTask }));
+                this.#paths.set(record.subagentId, path);
             }
             catch (error) {
                 let failureState = "error";
@@ -893,30 +894,9 @@ export class SubagentManager {
                 const { latestSummary: _latestSummary, ...rest } = current;
                 return { ...rest, state: "running" };
             });
-            if (this.#taskRegistry !== undefined) {
-                try {
-                    this.#taskRegistry.create({
-                        id: record.subagentId,
-                        type: "agent",
-                        purpose: `${input.agent}: ${input.task}`,
-                        inlineResult: true,
-                        begin: () => ({
-                            stop: () => {
-                                void this.stop(record.subagentId);
-                            },
-                            describe: () => ({
-                                output: `Subagent ${record.subagentId} (${input.agent}) is running`,
-                                truncated: false,
-                            }),
-                        }),
-                    });
-                }
-                catch (regError) {
-                    diagnose(`failed to register background task for subagent ${record.subagentId}: ${errorMessage(regError)}`);
-                }
-            }
             return {
-                child: publicChild((await this.#deps.registry.get(record.subagentId)) ?? record, true),
+                child: publicChild((await this.#deps.registry.get(record.subagentId)) ?? record, true, path),
+                path,
                 ...(placement.note === undefined ? {} : { note: placement.note }),
             };
         }
@@ -926,12 +906,7 @@ export class SubagentManager {
             const failedId = childId;
             const reason = errorMessage(error);
             const failed = await this.#mutate(failedId, async () => {
-                const record = await this.#deps.registry.get(failedId);
-                const uncertain = this.#runtimeStarted(failedId) ||
-                    this.#unresolvedRuntimes.has(failedId) ||
-                    record?.runtime !== undefined;
-                if (uncertain)
-                    this.#unresolvedRuntimes.add(failedId);
+                const uncertain = this.#runtimeStarted(failedId);
                 if (!this.#isLive(failedId))
                     this.#working.delete(failedId);
                 await this.#update(failedId, (current) => ({
@@ -956,20 +931,13 @@ export class SubagentManager {
             const record = await this.#deps.registry.get(id);
             if (record === undefined)
                 return failure("send", "Unknown child", id);
-            if (record.intent === "stopped" || record.state === "error") {
-                const doubt = await this.#runtimeDoubt(id);
-                return failure("send", doubt ??
-                    `Subagent ${id} is in error state and cannot continue (${record.interrupted ?? "fatal error"}). You can reference its context via spawn_agent with forkFrom: "${id}".`, id, record.state, [], false);
-            }
             let isResumed = false;
             // Deliverability is the bridge connection, minus a process that left the delegated session:
             // input goes to a session, and this process no longer serves this child's session. What is
             // left to decide is whether a runtime of ours may still own it.
             if (this.#leftSessions.has(id) || !this.#deps.bridge.isConnected(id)) {
-                const doubt = await this.#runtimeDoubt(id);
+                const doubt = this.#runtimeDoubt(id);
                 if (doubt !== undefined) {
-                    // A runtime is still unaccounted for: it may not answer, but it may also still own the
-                    // delegated session, and one session never gets two writers.
                     return failure("send", doubt, id, record.state, ["runtime metadata retained"], false);
                 }
                 let placement;
@@ -984,6 +952,7 @@ export class SubagentManager {
                 const resumedRecord = await this.#update(id, (current) => ({
                     ...current,
                     state: "running",
+                    intent: "active",
                     persistence,
                     ...(sessionPath === undefined ? {} : { sessionPath }),
                     launchConfig: sessionPath === undefined
@@ -1042,31 +1011,30 @@ export class SubagentManager {
                 return {
                     ...clean,
                     state: "running",
+                    intent: "active",
                     unacknowledgedInput: message,
                 };
             });
             try {
-                await this.#request(id, operation, { message });
+                const path = acknowledgedPath(await this.#request(id, operation, { message }));
+                this.#paths.set(id, path);
             }
             catch (error) {
                 return failure("send", errorMessage(error), id, pending.state, ["input persisted as unacknowledged before dispatch"], false);
             }
-            return publicChild((await this.#deps.registry.get(id)) ?? record, true);
+            return publicChild((await this.#deps.registry.get(id)) ?? pending, true, this.#paths.get(id));
         });
     }
     async get(id) {
         const record = await this.#deps.registry.get(id);
-        return record === undefined
-            ? failure("get", "Unknown child", id)
-            : publicChild(record, this.#isLive(id));
+        if (record === undefined)
+            return failure("get", "Unknown child", id);
+        const live = this.#isLive(id);
+        return publicChild(this.#withSnapshot(record), live, this.#paths.get(id));
     }
     async list() {
         const records = await this.#deps.registry.list();
-        return records.map((record) => publicChild(record, this.#isLive(record.subagentId)));
-    }
-    /** Child startup and runs count until Pi settles, including post-agent_end continuation. */
-    get activeCount() {
-        return this.#working.size;
+        return records.map((record) => publicChild(this.#withSnapshot(record), this.#isLive(record.subagentId), this.#paths.get(record.subagentId)));
     }
     stop(id) {
         this.#clearSettledPanelClose(id);
@@ -1089,11 +1057,7 @@ export class SubagentManager {
             let stopped;
             try {
                 // The intent is written before anything is ended, so an interrupted stop is still a stop.
-                stopped = await this.#update(id, (current) => ({
-                    ...current,
-                    intent: "stopped",
-                    state: "error",
-                }));
+                stopped = await commitLease(this.#deps.registry, id, { type: "stop-intent" });
             }
             catch (error) {
                 this.#stopping.delete(id);
@@ -1122,6 +1086,7 @@ export class SubagentManager {
                     // bridge-only stop.
                     const cleanup = await attachment.cleanup();
                     if (!(await this.#panelGone(attachment))) {
+                        await this.#update(id, (current) => ({ ...current, state: "error" })).catch(() => undefined);
                         return failure("stop", `The child's ${attachment.identity.host} panel is not confirmed gone (${cleanup.stderr || "its state could not be observed"}): the child process may still be running`, id, "error", ["stopped intent persisted", "runtime metadata retained"], true);
                     }
                     this.#attachments.delete(id);
@@ -1139,27 +1104,10 @@ export class SubagentManager {
                     }
                 }
                 this.#projectors.delete(id);
-                // An explicit stop is the one thing that clears the doubt about a runtime this process
-                // never saw, so a later send may start a fresh one.
-                this.#unresolvedRuntimes.delete(id);
                 this.#activity.delete(id);
-                const runtimeIdentity = stopped.runtime?.runtimeIdentity;
-                const current = await this.#deps.registry.get(id);
-                if (current !== undefined) {
-                    stopped = await this.#deps.registry.update(id, current.revision, (value) => {
-                        const { runtime: _runtime, ...withoutRuntime } = value;
-                        return withoutRuntime;
-                    });
-                }
-                if (this.#taskRegistry !== undefined) {
-                    this.#taskRegistry.settle(id, {
-                        status: "cancelled",
-                        output: `Subagent ${id} was stopped`,
-                        truncated: false,
-                    });
-                }
-                if (runtimeIdentity !== undefined)
-                    this.#deps.tokens?.forget(runtimeIdentity);
+                const finished = await this.#releaseRuntime(id, "finished");
+                if (finished !== undefined)
+                    stopped = finished;
                 return publicChild(stopped, false);
             }
             catch (error) {
@@ -1196,13 +1144,6 @@ export class SubagentManager {
                     state: "blocked",
                     interrupted: message,
                 }));
-                if (this.#taskRegistry !== undefined) {
-                    this.#taskRegistry.settle(id, {
-                        status: "failed",
-                        output: message,
-                        truncated: false,
-                    });
-                }
                 this.#scheduleSettledPanelClose(id);
             }
             else if (reason === "error") {
@@ -1212,17 +1153,9 @@ export class SubagentManager {
                 }
                 await this.#update(id, (current) => ({
                     ...current,
-                    intent: "stopped",
                     state: "error",
                     interrupted: message,
                 }));
-                if (this.#taskRegistry !== undefined) {
-                    this.#taskRegistry.settle(id, {
-                        status: "failed",
-                        output: message,
-                        truncated: false,
-                    });
-                }
                 this.#scheduleSettledPanelClose(id);
             }
             return { delivered: true };
@@ -1231,11 +1164,7 @@ export class SubagentManager {
             return failure("contact_parent", errorMessage(error), id, record.state, [], true);
         }
     }
-    /**
-     * Handles a request a child sent to its parent. The two child-initiated operations are the
-     * child's report channel and its Task result, and both are answered here so the child learns
-     * whether the parent accepted them.
-     */
+    /** Answers a request a child sent to its parent, so the child learns whether the parent accepted it. */
     async handleChildRequest(childId, operation, payload) {
         const record = await this.#deps.registry.get(childId);
         if (record === undefined)
@@ -1296,15 +1225,16 @@ export class SubagentManager {
             this.#notify();
         }
         // Counted before the per-child queue: an event that arrives while a reclaim is running is
-        // queued behind it and could otherwise not cancel a decision already in flight.
-        this.#bumpActivity(childId);
+        // queued behind it and could otherwise not cancel a decision already in flight. Only a new
+        // turn cancels a reply that is already waiting.
+        this.#bumpActivity(childId, isRecord(event) && resumesChildWork(event.type));
         const workVersion = this.#workVersions.get(childId) ?? 0;
         void this.#mutate(childId, () => this.#observe(childId, event, workVersion)).catch((error) => {
             diagnose(`failed to project event for ${childId}: ${errorMessage(error)}`);
         });
     }
     handleConnectionChange(childId, connected) {
-        this.#bumpActivity(childId);
+        this.#bumpActivity(childId, false);
         void this.#mutate(childId, async () => {
             const record = await this.#deps.registry.get(childId);
             if (record === undefined)
@@ -1316,8 +1246,6 @@ export class SubagentManager {
                 // the child's transcript from the session the human switched to.
                 if (this.#leftSessions.has(childId))
                     return;
-                // The runtime this record names is answering, so the doubt about it is gone.
-                this.#unresolvedRuntimes.delete(childId);
                 if (!this.#projectors.has(childId)) {
                     this.#projectors.set(childId, createStateProjector(record.state));
                 }
@@ -1329,18 +1257,7 @@ export class SubagentManager {
             await this.#runtimeEnded(childId);
         });
     }
-    #dispatch(childId, event) {
-        for (const listener of this.#childEventListeners) {
-            try {
-                listener(childId, event);
-            }
-            catch (error) {
-                diagnose(`child event listener failed for ${childId}: ${errorMessage(error)}`);
-            }
-        }
-    }
     async #observe(id, event, workVersion) {
-        this.#dispatch(id, event);
         const value = isRecord(event) ? event : undefined;
         if (value === undefined)
             return;
@@ -1356,11 +1273,7 @@ export class SubagentManager {
                 const message = value.message === undefined || value.message === ""
                     ? "Task is unfinished and waiting for user intent."
                     : value.message;
-                const updated = await this.#update(id, (current) => ({
-                    ...current,
-                    interrupted: message,
-                }));
-                await this.contactParent(id, "user_interrupt", message, updated);
+                await this.contactParent(id, "user_interrupt", message, record);
                 return;
             }
             if (value.kind === "left_session") {
@@ -1374,18 +1287,10 @@ export class SubagentManager {
                 this.#projectors.delete(id);
                 this.#attachments.delete(id);
                 this.#leftSessions.add(id);
-                this.#unresolvedRuntimes.delete(id);
                 // The socket is not this child's channel any more either: leaving it up would let a
                 // relaunch mistake the old connection for the new runtime.
                 this.#deps.bridge.disconnect(id);
-                await this.#update(id, (current) => {
-                    const { runtime: _runtime, ...withoutRuntime } = current;
-                    return {
-                        ...withoutRuntime,
-                        state: "done",
-                        interrupted: "The child left its session; the surface is no longer controlled by the parent",
-                    };
-                });
+                await commitLease(this.#deps.registry, id, { type: "left-session" });
                 if (retired !== undefined)
                     this.#deps.tokens?.forget(retired);
                 return;
@@ -1410,14 +1315,13 @@ export class SubagentManager {
             return;
         projector.applyEvent(event);
         let confirmedInput;
-        if (value.type === "agent_end") {
+        if (value.type === "turn_end" || value.type === "agent_end") {
             // A finished turn is exactly when the session file has the message, so this is where
             // unacknowledged input becomes part of the child's conversation.
-            const entries = await this.#entries(id);
-            if (entries !== undefined) {
-                projector.rebuild(entries);
-                if (record.unacknowledgedInput !== undefined &&
-                    sessionContainsUserInput(entries, record.unacknowledgedInput)) {
+            const facts = await this.#facts(id, record.unacknowledgedInput);
+            if (facts !== undefined) {
+                projector.applyTranscriptFacts(facts);
+                if (record.unacknowledgedInput !== undefined && facts.containsInput) {
                     confirmedInput = record.unacknowledgedInput;
                 }
             }
@@ -1426,20 +1330,23 @@ export class SubagentManager {
         if (current === undefined || current.intent === "stopped")
             return;
         const snapshot = projector.snapshot();
-        await this.#update(id, (entry) => {
-            const { interrupted: _prevInterrupted, activeTool: _prevActiveTool, ...cleanEntry } = entry;
-            const base = confirmedInput === undefined
-                ? cleanEntry
-                : (({ unacknowledgedInput: _input, ...rest }) => rest)(cleanEntry);
-            return {
-                ...base,
-                state: snapshot.state,
-                ...(snapshot.summary === undefined ? {} : { latestSummary: snapshot.summary }),
-                ...(snapshot.activeTool === undefined ? {} : { activeTool: snapshot.activeTool }),
-                usage: snapshot.usage,
-                ...(snapshot.interrupted === undefined ? {} : { interrupted: snapshot.interrupted }),
-            };
-        }, workVersion);
+        const durable = durableProjection(current, snapshot, confirmedInput !== undefined);
+        if (durable !== undefined) {
+            await this.#update(id, (entry) => {
+                const { interrupted: _prevInterrupted, activeTool: _prevActiveTool, latestSummary: _prevSummary, usage: _prevUsage, ...cleanEntry } = entry;
+                const base = confirmedInput === undefined
+                    ? cleanEntry
+                    : (({ unacknowledgedInput: _input, ...rest }) => rest)(cleanEntry);
+                return {
+                    ...base,
+                    state: snapshot.state,
+                    ...(snapshot.interrupted === undefined ? {} : { interrupted: snapshot.interrupted }),
+                };
+            }, workVersion);
+        }
+        else {
+            this.#notify();
+        }
         if (snapshot.state === "done" || snapshot.state === "blocked" || snapshot.state === "error") {
             this.#scheduleSettledPanelClose(id);
         }
@@ -1453,6 +1360,82 @@ export class SubagentManager {
             this.#scheduleAutoReport(id, latestRecord);
         }
     }
+    holdAttachment(id, attachment) {
+        this.#attachments.set(id, attachment);
+    }
+    /** Starts restoration. `before_agent_start` waits on `ready` so the turn sees the same ledger. */
+    reconcile() {
+        if (this.#ready !== undefined)
+            return this.#ready;
+        const ready = this.#reconcile();
+        this.#ready = ready;
+        return ready;
+    }
+    ready() {
+        return this.reconcile();
+    }
+    async #reconcile() {
+        const directory = this.#deps.directory;
+        if (directory === undefined) {
+            const recovery = await this.recover();
+            return {
+                ok: true,
+                rebound: recovery.recovered,
+                rehydrated: [],
+                stopped: [],
+                released: [],
+            };
+        }
+        const lease = createConversationLease({
+            registry: this.#deps.registry,
+            hosts: directory,
+            processes: { alive: processAlive },
+            forgetRuntime: (runtimeIdentity) => {
+                this.#deps.tokens?.forget(runtimeIdentity);
+            },
+        });
+        const result = await lease.ready();
+        if (!result.ok)
+            return result;
+        for (const id of result.rebound) {
+            const record = await this.#deps.registry.get(id);
+            const attachment = record?.runtime?.attachment;
+            if (attachment?.kind === "panel") {
+                const handle = directory.rebind?.(attachment);
+                if (handle !== undefined)
+                    this.#attachments.set(id, handle);
+            }
+            else if (attachment?.kind === "process") {
+                const runtime = attachRetainedChild(attachment.pid);
+                if (runtime !== undefined)
+                    this.#watchRuntime(id, runtime);
+            }
+        }
+        for (const id of result.released) {
+            await this.#noteReleasedRuntime(id);
+        }
+        return result;
+    }
+    /** A writer the lease already dropped. Same ledger line as a watched exit. */
+    async #noteReleasedRuntime(id) {
+        const record = await this.#deps.registry.get(id);
+        if (record?.state !== "blocked" || record.interrupted !== RUNTIME_ENDED_RESUME)
+            return;
+        this.#scheduleAutoReport(id, record);
+    }
+    #withSnapshot(record) {
+        const projector = this.#projectors.get(record.subagentId);
+        if (projector === undefined)
+            return record;
+        const snap = projector.snapshot();
+        return {
+            ...record,
+            ...(snap.activeTool !== undefined ? { activeTool: snap.activeTool } : {}),
+            ...(snap.summary !== undefined ? { latestSummary: snap.summary } : {}),
+            ...(snap.interrupted !== undefined ? { interrupted: snap.interrupted } : {}),
+            usage: snap.usage ?? record.usage,
+        };
+    }
     /** Runs an update inside the per-child chain used by the mutating operations. */
     #mutateUpdate(id, updater) {
         return this.#mutate(id, () => this.#update(id, updater));
@@ -1483,3 +1466,43 @@ export class SubagentManager {
         return next;
     }
 }
+function durableProjection(record, snapshot, inputConfirmed) {
+    if (inputConfirmed)
+        return true;
+    if (snapshot.state !== record.state)
+        return true;
+    return undefined;
+}
+function resumesChildWork(type) {
+    return (type === "agent_start" ||
+        type === "turn_start" ||
+        type === "auto_retry_start" ||
+        type === "auto_retry");
+}
+/** The last conversational message is an assistant reply that already finished. */
+function persistedReplyFinished(entries) {
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+        const entry = entries[index];
+        if (!isRecord(entry) || entry.type !== "message" || !isRecord(entry.message))
+            continue;
+        const message = entry.message;
+        if (message.role === "user")
+            return false;
+        if (message.role !== "assistant")
+            continue;
+        return (message.stopReason !== "error" &&
+            message.stopReason !== "aborted" &&
+            message.stopReason !== "pending" &&
+            message.stopReason !== "deferred");
+    }
+    return false;
+}
+function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}