@hheei/pi-subagents 0.1.2 → 0.2.3

package/dist/manager.js

@@ -1,8 +1,24 @@
-import { isRecord } from "./domain.js";
-import { buildLaunchSpec, withBridgeToken } from "./launch-spec.js";
-import { isIdlePiState } from "./rpc-events.js";
-import { planSessionPlacement } from "./session-bootstrap.js";
+import { errorMessage, isRecord } from "@hheei/pi-ext-core";
+import { stripHindsightContent } from "./launch-spec.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";
+/**
+ * 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
+ * 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}`);
+    }
+}
 function failure(operation, reason, childId, state, sideEffects = [], safeToRetry = true) {
     return {
         operation,
@@ -21,10 +37,11 @@ function publicChild(record, live) {
             ? {}
             : { displayName: record.launchConfig.agent.displayName }),
         state: record.state,
-        mode: record.mode,
+        presentation: record.presentation,
         cwd: record.cwd,
         sessionId: record.sessionId,
         ...(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",
@@ -47,16 +64,6 @@ function withDeadline(operation, timeoutMs) {
         });
     });
 }
-async function waitForRunnerDisconnect(runner, timeoutMs, signal) {
-    const deadline = Date.now() + timeoutMs;
-    while (runner.connected) {
-        if (signal?.aborted)
-            throw new Error("Runner shutdown wait was aborted");
-        if (Date.now() >= deadline)
-            throw new Error("Runner did not disconnect after shutdown");
-        await new Promise((resolve) => setTimeout(resolve, 10));
-    }
-}
 function sessionContainsUserInput(entries, expected) {
     return entries.some((entry) => {
         const value = isRecord(entry) ? entry : undefined;
@@ -76,27 +83,90 @@ function sessionContainsUserInput(entries, expected) {
         return text === expected;
     });
 }
-function throwIfAborted(signal) {
-    if (signal?.aborted)
-        throw new Error("Attach was cancelled");
-}
-function hostCleanupFailed(result) {
-    return result.timedOut || result.exitCode !== 0;
+/**
+ * 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.
+ */
+export function extractLastAssistantText(entries) {
+    for (let i = entries.length - 1; i >= 0; i--) {
+        const entry = entries[i];
+        const message = isRecord(entry) && isRecord(entry.message) ? entry.message : undefined;
+        if (message?.role !== "assistant")
+            continue;
+        if (typeof message.content === "string") {
+            const text = message.content.trim();
+            if (text !== "")
+                return text;
+        }
+        else if (Array.isArray(message.content)) {
+            const text = message.content
+                .filter((p) => isRecord(p) && p.type === "text" && typeof p.text === "string")
+                .map((p) => p.text)
+                .join("\n")
+                .trim();
+            if (text !== "")
+                return text;
+        }
+    }
+    return undefined;
 }
 export class SubagentManager {
     #deps;
     #chains = new Map();
-    #runners = new Map();
+    #processes = new Map();
+    /** Panels this process opened. A panel child's process is held by the host, not by us. */
+    #attachments = new Map();
+    /**
+     * Children whose process moved to another session. The connection may still be up, but that
+     * 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();
+    /** 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();
+    #lastDeliveredTurn = new Map();
     #stopping = new Set();
-    #frozen = new Set();
-    #attachCancels = new Map();
-    #hostAttachments = new Map();
-    #hostWatches = new Map();
-    #tuiQuitExpected = 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
+        // transitions are what keep a record in step with a child that is running somewhere else.
+        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. */
     onChange(listener) {
@@ -105,166 +175,865 @@ export class SubagentManager {
             this.#listeners.delete(listener);
         };
     }
+    dispose() {
+        for (const timer of this.#settledPanelCloseTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.#settledPanelCloseTimers.clear();
+        for (const unsubscribe of this.#unsubscribe.splice(0))
+            unsubscribe();
+    }
+    /**
+     * Releases this process's local view of its children. Child processes are deliberately left
+     * alone: a background child is held by its stdin pipe, so it ends when this Pi process ends and
+     * not when extensions are reloaded.
+     */
+    closeLocalConnections() {
+        this.dispose();
+        this.#processes.clear();
+        this.#attachments.clear();
+        this.#leftSessions.clear();
+        this.#unresolvedRuntimes.clear();
+        this.#activity.clear();
+        this.#projectors.clear();
+        this.#working.clear();
+        this.#workVersions.clear();
+        this.#notify();
+    }
+    /**
+     * Starts the child's runtime where its frozen presentation says. A panel child is owned by the
+     * host, so this process keeps only the attachment handle; a background child is ours to kill.
+     */
+    async #start(record) {
+        // Whatever this child was doing before, a fresh runtime now serves the delegated session.
+        this.#leftSessions.delete(record.subagentId);
+        if (record.presentation === "panel") {
+            const openPanel = this.#deps.presentation?.openPanel;
+            if (openPanel === undefined) {
+                throw new Error("This parent has no presentation host for a panel child");
+            }
+            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;
+        }
+        const launch = await this.#deps.launch(record);
+        if (launch.handle !== undefined)
+            this.#watchRuntime(record.subagentId, launch.handle);
+        if (launch.failure !== undefined)
+            throw new Error(launch.failure);
+    }
+    /**
+     * Keeps a background child's process handle, and treats its exit as the end of its runtime: the
+     * bridge may already be gone by then (a child that disposes its client before exiting would
+     * otherwise stay "running" forever, with a handle nobody ever releases).
+     */
+    #watchRuntime(id, runtime) {
+        this.#processes.set(id, runtime);
+        void runtime.exited.then(() => {
+            void this.#mutate(id, () => this.#runtimeEnded(id)).catch((error) => {
+                diagnose(`failed to settle child ${id} after exit: ${errorMessage(error)}`);
+            });
+        });
+    }
+    /**
+     * The child's runtime is gone: release what it left behind and say so on the record. Called from
+     * both exits a runtime can take — the process ending, and the bridge connection dropping — so the
+     * order they happen in does not matter.
+     */
+    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.
+        if (runtime?.alive === true)
+            return;
+        if (runtime !== undefined)
+            this.#processes.delete(id);
+        if (this.#deps.bridge.isConnected(id))
+            return;
+        this.#working.delete(id);
+        await this.#releasePanel(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);
+        }
+    }
+    /** True when a runtime for this child was started here and may still own its session. */
+    #runtimeStarted(id) {
+        return this.#isLive(id) || this.#processes.has(id) || this.#attachments.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.
+     */
+    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";
+        }
+        return undefined;
+    }
+    /** Counts an inbound bridge signal, whether or not its handling is queued behind another task. */
+    #bumpActivity(id) {
+        this.#activity.set(id, (this.#activity.get(id) ?? 0) + 1);
+        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.
+     */
+    async #releasePanel(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 child panel was closed while running; 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();
+            if (cleanup.exitCode !== 0) {
+                diagnose(`could not close the leftover ${attachment.identity.host} panel of child ${id}: ${cleanup.stderr}`);
+            }
+        }
+        catch (error) {
+            diagnose(`could not close the leftover ${attachment.identity.host} panel of child ${id}: ${errorMessage(error)}`);
+        }
+    }
+    /** 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))
+            return Promise.resolve(true);
+        return new Promise((resolve) => {
+            let unsubscribe = () => { };
+            const timer = setTimeout(() => {
+                unsubscribe();
+                resolve(false);
+            }, timeoutMs);
+            unsubscribe = this.#deps.bridge.onConnectionChange((childId, connected) => {
+                if (childId !== id || connected)
+                    return;
+                clearTimeout(timer);
+                unsubscribe();
+                resolve(true);
+            });
+        });
+    }
+    /**
+     * Arms the idle countdown for a child whose runtime this process can actually reclaim. A child
+     * this process does not own (one adopted after a parent restart) and a host that cannot report
+     * focus (cmux) never get a timer: neither the exit nor the focus could be judged, and a panel is
+     * 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);
+        }, 5_000);
+        timer.unref?.();
+        this.#autoReportTimers.set(id, timer);
+    }
+    #clearAutoReport(id) {
+        const timer = this.#autoReportTimers.get(id);
+        if (timer !== undefined) {
+            clearTimeout(timer);
+            this.#autoReportTimers.delete(id);
+        }
+    }
+    #scheduleSettledPanelClose(id) {
+        const attachment = this.#attachments.get(id);
+        const runtime = this.#processes.get(id);
+        if (attachment === undefined && runtime === undefined)
+            return;
+        if (attachment !== undefined && !attachment.reportsFocus)
+            return;
+        this.#clearSettledPanelClose(id);
+        const timeoutMs = this.#deps.settledCloseTimeoutMs ??
+            this.#deps.failedPanelCloseTimeoutMs ??
+            this.#deps.idleTimeoutMs ??
+            SUBAGENT_SETTLED_CLOSE_TIMEOUT_MS;
+        const timer = setTimeout(() => {
+            this.#settledPanelCloseTimers.delete(id);
+            void this.#closeSettledPanel(id).catch((error) => {
+                diagnose(`failed to close settled panel for child ${id}: ${errorMessage(error)}`);
+            });
+        }, timeoutMs);
+        timer.unref?.();
+        this.#settledPanelCloseTimers.set(id, timer);
+    }
+    #clearSettledPanelClose(id) {
+        const timer = this.#settledPanelCloseTimers.get(id);
+        if (timer !== undefined) {
+            clearTimeout(timer);
+            this.#settledPanelCloseTimers.delete(id);
+        }
+    }
+    async #closeSettledPanel(id) {
+        await this.#mutate(id, async () => {
+            const record = await this.#deps.registry.get(id);
+            if (record === undefined || record.state === "running" || record.intent === "stopped") {
+                return;
+            }
+            const attachment = this.#attachments.get(id);
+            const runtime = this.#processes.get(id);
+            if (attachment === undefined && runtime === undefined)
+                return;
+            if (!this.#isLive(id))
+                return;
+            const activity = this.#activity.get(id) ?? 0;
+            if (attachment !== undefined) {
+                const observed = await attachment.observe();
+                if (observed.known && !observed.alive) {
+                    await this.#releasePanel(id);
+                    return;
+                }
+                if ((this.#activity.get(id) ?? 0) !== activity) {
+                    this.#scheduleSettledPanelClose(id);
+                    return;
+                }
+                if (attachment.reportsFocus && (!observed.known || observed.focused !== false)) {
+                    this.#scheduleSettledPanelClose(id);
+                    return;
+                }
+            }
+            if (this.#deps.bridge.isConnected(id)) {
+                await this.#request(id, "shutdown").catch(() => undefined);
+                this.#deps.bridge.disconnect(id);
+            }
+            if (runtime !== undefined) {
+                await runtime.terminate().catch(() => undefined);
+            }
+            if (attachment !== undefined) {
+                try {
+                    await attachment.cleanup();
+                }
+                catch (error) {
+                    diagnose(`failed to cleanup panel for child ${id}: ${errorMessage(error)}`);
+                }
+            }
+            const exited = (runtime === undefined || !runtime.alive) && (await this.#panelGone(attachment));
+            if (exited) {
+                if (runtime !== undefined)
+                    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",
+                    };
+                });
+            }
+        });
+    }
+    async #performAutoReport(id, _record) {
+        if (this.#working.has(id))
+            return;
+        const record = (await this.#deps.registry.get(id)) ?? _record;
+        if (record.intent === "stopped" || record.state === "running")
+            return;
+        const entries = await this.#entries(id);
+        const text = entries !== undefined ? extractLastAssistantText(entries) : undefined;
+        const hasError = record.state === "error" ||
+            (record.interrupted !== undefined && record.interrupted.trim() !== "");
+        const isBlocked = hasError;
+        if (!isBlocked && (text === undefined || text.trim() === "")) {
+            const projector = this.#projectors.get(id);
+            if (projector !== undefined) {
+                projector.syncState("done");
+            }
+            await this.#update(id, (current) => {
+                const { interrupted: _interrupted, ...clean } = current;
+                return {
+                    ...clean,
+                    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() !== "") {
+                message =
+                    text !== undefined && text.trim() !== ""
+                        ? `${record.interrupted}\n\n${text}`
+                        : record.interrupted;
+            }
+            else if (text !== undefined && text.trim() !== "") {
+                message = text;
+            }
+            else {
+                message = "Subagent became idle without completing its task (interrupted or failed).";
+            }
+        }
+        else {
+            message = text ?? "";
+        }
+        if (this.#lastDeliveredTurn.get(id) === message)
+            return;
+        this.#lastDeliveredTurn.set(id, message);
+        const reason = isBlocked ? "blocked" : "success";
+        const taskStatus = isBlocked ? "failed" : "completed";
+        const projector = this.#projectors.get(id);
+        const updatedRecord = !isBlocked
+            ? await this.#update(id, (current) => {
+                const { interrupted: _interrupted, ...clean } = current;
+                return {
+                    ...clean,
+                    state: "done",
+                };
+            })
+            : await this.#update(id, (current) => ({
+                ...current,
+                state: "blocked",
+                interrupted: current.interrupted ?? message,
+            }));
+        if (projector !== undefined) {
+            projector.syncState(isBlocked ? "blocked" : "done");
+        }
+        this.#scheduleSettledPanelClose(id);
+        if (this.#deps.channel !== undefined) {
+            await this.contactParent(id, reason, message, updatedRecord);
+        }
+        if (this.#taskRegistry !== undefined) {
+            this.#taskRegistry.settle(id, {
+                status: taskStatus,
+                output: message,
+                truncated: false,
+            });
+        }
+    }
+    /** Reads a child's session entries; exposed for Task completion inspection. */
+    async getEntries(id) {
+        return this.#entries(id);
+    }
+    /** A child is live while its bridge connection is up, or while a process we started still runs. */
+    #isLive(id) {
+        // A process that left the delegated session is not this child's runtime, however healthy its
+        // connection looks: sending to it would drive the session the human switched to.
+        if (this.#leftSessions.has(id))
+            return false;
+        if (this.#deps.bridge.isConnected(id))
+            return true;
+        return this.#processes.get(id)?.alive === true;
+    }
+    /**
+     * True only when the host positively reports the panel is gone. An unobservable panel is not a
+     * closed one, and treating it as closed is what would let a second runtime start for a session
+     * whose first process may still be running.
+     */
+    async #panelGone(attachment) {
+        if (attachment === undefined)
+            return true;
+        const observed = await attachment.observe();
+        return observed.known && !observed.alive;
+    }
+    /**
+     * Resolves where the child's session lives now: a child that finished while
+     * the parent was busy may have been flushed after its record was written.
+     *
+     * Discovery is not an existence test. A record that was only ever known by session
+     * id would otherwise turn an unreadable session directory into "the session does not
+     * exist", and the next resume would let Pi mint a new session under the same id and
+     * silently drop the child's context. A failure is therefore reported to the caller.
+     */
+    async #currentPlacement(record) {
+        let placement;
+        try {
+            placement = await planSessionPlacement({
+                sessionId: record.sessionId,
+                cwd: record.cwd,
+                sessionDir: record.launchConfig.sessionDir,
+                persistence: record.persistence,
+                ...(record.sessionPath === undefined ? {} : { sessionPath: record.sessionPath }),
+            });
+        }
+        catch (error) {
+            throw new Error(`Session placement for child ${record.subagentId} could not be verified: ${errorMessage(error)}`, { cause: error });
+        }
+        if (placement.persistence === "flushed" && placement.sessionPath !== undefined) {
+            return { sessionPath: placement.sessionPath, persistence: "flushed" };
+        }
+        return { sessionPath: record.sessionPath, persistence: record.persistence };
+    }
+    /** Reads a child's session entries over the bridge, falling back to disk when disconnected. */
+    async #entries(id) {
+        if (this.#deps.bridge.isConnected(id)) {
+            const response = await this.#request(id, "get_entries").catch(() => undefined);
+            if (isRecord(response) && Array.isArray(response.entries) && response.entries.length > 0) {
+                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;
+    }
+    #request(id, operation, payload) {
+        return withDeadline(this.#deps.bridge.request(id, operation, payload), this.#deps.deadlineMs ?? 30_000);
+    }
     #notify() {
         for (const listener of this.#listeners) {
             try {
                 listener();
             }
             catch (error) {
-                console.error(`pi-subagents: onChange listener failed: ${error instanceof Error ? error.message : String(error)}`);
+                diagnose(`onChange listener failed: ${errorMessage(error)}`);
             }
         }
     }
-    /** Reattaches active persisted children without replaying any historical input. */
+    /**
+     * Adopts the children that are still running. Nothing is launched here: a child that survived a
+     * parent restart reconnects its bridge by itself, and a child that did not is simply not live
+     * until a later send starts it from its recorded session.
+     */
     async recover() {
-        const connect = this.#deps.connect;
-        if (connect === undefined)
-            return { recovered: [], failures: [] };
-        const records = (await this.#deps.registry.list()).filter((record) => record.intent === "active" && record.state !== "done" && record.state !== "stopped");
+        const records = (await this.#deps.registry.list()).filter((record) => record.intent === "active" && record.state === "running");
         const outcomes = await Promise.all(records.map(async (record) => {
+            this.#working.add(record.subagentId);
+            if (!this.#projectors.has(record.subagentId)) {
+                this.#projectors.set(record.subagentId, createStateProjector(record.state));
+            }
             try {
-                const runner = await withDeadline(connect(record), this.#deps.deadlineMs ?? 30_000);
-                this.#attach(record, runner);
-                const response = await runner.request("get_entries").catch(() => undefined);
-                const entries = isRecord(response) && Array.isArray(response.entries) ? response.entries : [];
-                const projector = this.#projectors.get(record.subagentId);
-                projector?.rebuild(entries);
-                const snapshot = projector?.snapshot();
-                await this.#update(record.subagentId, (current) => {
-                    const interrupted = snapshot?.interrupted ??
-                        (current.unacknowledgedInput === undefined
-                            ? current.interrupted
-                            : (current.interrupted ?? "Parent recovered; pending input was not replayed"));
-                    return {
-                        ...current,
-                        ...(snapshot === undefined
-                            ? {}
-                            : {
-                                state: snapshot.state,
-                                ...(snapshot.summary === undefined ? {} : { latestSummary: snapshot.summary }),
-                                usage: snapshot.usage,
-                            }),
-                        ...(interrupted === undefined ? {} : { interrupted }),
-                    };
-                });
+                if (!(await this.#deps.connect(record))) {
+                    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 };
             }
             catch (error) {
-                return {
-                    childId: record.subagentId,
-                    reason: error instanceof Error ? error.message : String(error),
-                };
+                return { childId: record.subagentId, reason: errorMessage(error) };
             }
         }));
+        const settled = outcomes.filter((outcome) => outcome !== undefined);
         this.#notify();
         return {
-            recovered: outcomes
+            recovered: settled
                 .filter((outcome) => !("reason" in outcome))
                 .map((outcome) => outcome.childId),
-            failures: outcomes.filter((outcome) => "reason" in outcome),
+            failures: settled.filter((outcome) => "reason" in outcome),
         };
     }
+    /**
+     * 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.
+     */
+    async #settleUnrecovered(record) {
+        this.#working.delete(record.subagentId);
+        const retired = record.runtime;
+        if (retired === undefined)
+            return;
+        if (record.presentation === "panel") {
+            this.#unresolvedRuntimes.add(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);
+    }
+    /** Reads a connected child's real state and puts the record back in step with it. */
+    async #adopt(id) {
+        const workVersion = this.#workVersions.get(id) ?? 0;
+        const projector = this.#projectors.get(id);
+        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 state = await this.#request(id, "get_state");
+        if (!isRecord(state) ||
+            typeof state.idle !== "boolean" ||
+            typeof state.pendingMessages !== "boolean") {
+            throw new BridgeError("invalid_state", `Child ${id} did not confirm its current work state`);
+        }
+        const idle = state.idle && !state.pendingMessages;
+        if ((this.#workVersions.get(id) ?? 0) === workVersion) {
+            if (idle)
+                this.#working.delete(id);
+            else
+                this.#working.add(id);
+        }
+        // The child's own answer decides whether it is working right now; a transcript that recorded a
+        // failed turn still outranks it. Without this the projector keeps saying "running" and the
+        // next event that carries no state of its own writes that back onto the record.
+        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)
+            ? record.unacknowledgedInput
+            : undefined;
+        await this.#update(id, (current) => {
+            if (current.intent === "stopped")
+                return current;
+            const base = confirmedInput === undefined
+                ? current
+                : (({ unacknowledgedInput: _input, ...rest }) => rest)(current);
+            const hasError = snapshot.state === "error";
+            return {
+                ...base,
+                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") {
+            this.#scheduleSettledPanelClose(id);
+        }
+        else {
+            this.#clearSettledPanelClose(id);
+        }
+    }
+    /**
+     * Where this child runs. `auto` means a panel whenever this parent has a host and the background
+     * otherwise, and the fallback travels back in the spawn result so the caller sees that the child
+     * runs headless; only an explicit request for a panel can fail, because nothing else can satisfy
+     * it.
+     */
+    #placement(input) {
+        const requested = input.presentation ?? "auto";
+        const panelAvailable = this.#deps.presentation?.openPanel !== undefined;
+        if (requested === "panel") {
+            return panelAvailable
+                ? { presentation: "panel" }
+                : { reason: "This parent has no presentation host, so the child cannot run in a panel" };
+        }
+        if (requested === "background" || !panelAvailable) {
+            return {
+                presentation: "background",
+                ...(requested === "background"
+                    ? {}
+                    : {
+                        note: `No presentation host is available (${this.#deps.presentation?.reason ?? "no host adapter"}), so this child runs in the background`,
+                    }),
+            };
+        }
+        return { presentation: "panel" };
+    }
     async spawn(input) {
-        if (input.task.trim() === "")
+        const cleanTask = stripHindsightContent(input.task).trim();
+        if (cleanTask === "")
             return failure("spawn", "Task must not be empty");
+        let childId;
         try {
             const config = await withDeadline(this.#deps.resolve(input), this.#deps.deadlineMs ?? 30_000);
+            const cleanTask = stripHindsightContent(input.task);
+            const placement = this.#placement(input);
+            if ("reason" in placement)
+                return failure("spawn", placement.reason, undefined, undefined, [], false);
             const record = await withDeadline(this.#deps.bootstrap({
                 parentSessionId: this.#deps.parentSessionId,
-                task: input.task,
+                task: cleanTask,
                 launchConfig: config,
+                presentation: placement.presentation,
             }), this.#deps.deadlineMs ?? 30_000);
+            this.#projectors.set(record.subagentId, createStateProjector(record.state));
+            childId = record.subagentId;
+            this.#working.add(childId);
             this.#notify();
-            const runner = await withDeadline(this.#deps.launch(record), this.#deps.deadlineMs ?? 30_000);
-            this.#attach(record, runner);
+            await withDeadline(this.#start(record), this.#deps.deadlineMs ?? 30_000);
             try {
-                await withDeadline(runner.request("prompt", { message: input.task }), this.#deps.deadlineMs ?? 30_000);
+                await this.#request(record.subagentId, "prompt", { message: cleanTask });
             }
             catch (error) {
-                let failureState = "starting";
+                let failureState = "error";
                 try {
-                    await this.#update(record.subagentId, (current) => ({
+                    await this.#mutateUpdate(record.subagentId, (current) => ({
                         ...current,
-                        state: "failed",
+                        state: "error",
                         interrupted: "Initial task delivery was not confirmed",
-                        unacknowledgedInput: input.task,
+                        unacknowledgedInput: cleanTask,
                     }));
-                    failureState = "failed";
+                    failureState = "error";
                 }
                 catch (updateError) {
-                    console.error(`pi-subagents: failed to persist initial delivery uncertainty for ${record.subagentId}: ${updateError instanceof Error ? updateError.message : String(updateError)}`);
+                    diagnose(`failed to persist initial delivery uncertainty for ${record.subagentId}: ${errorMessage(updateError)}`);
                 }
-                return failure("spawn", error instanceof Error ? error.message : String(error), record.subagentId, failureState, [
+                return failure("spawn", errorMessage(error), record.subagentId, failureState, [
                     "registry record persisted",
-                    "runner launched",
+                    "child launched",
                     "initial task delivery was not confirmed",
                 ], false);
             }
-            await this.#update(record.subagentId, (current) => {
+            await this.#mutateUpdate(record.subagentId, (current) => {
                 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),
+                ...(placement.note === undefined ? {} : { note: placement.note }),
             };
         }
         catch (error) {
-            return failure("spawn", error instanceof Error ? error.message : String(error), undefined, undefined, [], true);
+            if (childId !== undefined &&
+                !this.#runtimeStarted(childId) &&
+                !this.#unresolvedRuntimes.has(childId)) {
+                this.#working.delete(childId);
+            }
+            this.#notify();
+            return failure("spawn", errorMessage(error), undefined, undefined, [], true);
         }
     }
-    send(id, message, mode = "auto", signal) {
+    send(id, rawMessage, mode = "auto", signal) {
+        const message = stripHindsightContent(rawMessage);
+        this.#clearSettledPanelClose(id);
         return this.#mutate(id, async () => {
             const record = await this.#deps.registry.get(id);
             if (record === undefined)
                 return failure("send", "Unknown child", id);
-            if (this.#frozen.has(id) || record.mode === "tui")
-                return failure("send", "Child input is frozen for attach", id, record.state);
-            if (record.intent === "stopped" ||
-                record.state === "done" ||
-                record.state === "failed" ||
-                record.state === "stopped")
-                return failure("send", "Child is not accepting input", id, record.state);
-            const runner = this.#runners.get(id);
-            if (runner === undefined)
-                return failure("send", "Child runtime is not live", id, record.state, [], true);
-            const state = record.state;
-            const operation = mode === "auto"
-                ? state === "running"
-                    ? "steer"
-                    : state === "idle"
-                        ? "follow_up"
-                        : undefined
-                : mode;
+            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);
+                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;
+                try {
+                    placement = await this.#currentPlacement(record);
+                }
+                catch (error) {
+                    // Nothing was launched, so the record is untouched and a later retry is safe.
+                    return failure("send", errorMessage(error), id, record.state, ["no runtime was started"]);
+                }
+                const { sessionPath, persistence } = placement;
+                const resumedRecord = await this.#update(id, (current) => ({
+                    ...current,
+                    state: "running",
+                    persistence,
+                    ...(sessionPath === undefined ? {} : { sessionPath }),
+                    launchConfig: sessionPath === undefined
+                        ? current.launchConfig
+                        : { ...current.launchConfig, sessionPath },
+                }));
+                if (!this.#projectors.has(id)) {
+                    this.#projectors.set(id, createStateProjector(resumedRecord.state));
+                }
+                try {
+                    await withDeadline(this.#start(resumedRecord), this.#deps.deadlineMs ?? 30_000);
+                    isResumed = true;
+                }
+                catch (error) {
+                    const reason = errorMessage(error);
+                    // A launch that failed may still have started a process that owns the session, so the
+                    // two outcomes must not collapse into one retry: while a runtime may exist, refusing is
+                    // the only safe answer.
+                    const started = this.#runtimeStarted(id);
+                    const settled = await this.#update(id, (current) => {
+                        if (current.state !== "running")
+                            return current;
+                        if (started) {
+                            return {
+                                ...current,
+                                state: "error",
+                                interrupted: `Resume failed after the runtime was started (${reason}); the recorded runtime was kept and the child stays unavailable until it is gone`,
+                            };
+                        }
+                        return {
+                            ...current,
+                            state: record.state,
+                            interrupted: `Resume failed before a runtime was confirmed started (${reason}); the child session is untouched`,
+                        };
+                    });
+                    return failure("send", `Failed to resume subagent: ${reason}`, id, settled.state, started
+                        ? ["running state persisted", "runtime start unconfirmed"]
+                        : ["running state rolled back", "no runtime was confirmed started"], !started);
+                }
+            }
+            const state = isResumed ? "running" : record.state;
+            const operation = isResumed
+                ? "prompt"
+                : mode === "auto"
+                    ? state === "running"
+                        ? "steer"
+                        : "follow_up"
+                    : mode;
             if (operation === undefined)
                 return failure("send", "Cannot infer send mode from unknown state", id, state);
-            const pending = await this.#update(id, (current) => ({
-                ...current,
-                unacknowledgedInput: message,
-                interrupted: "Input delivery was accepted for dispatch but is not yet confirmed in the session",
-            }));
+            if (signal?.aborted)
+                return failure("send", "Send was cancelled", id, state);
+            this.#clearSettledPanelClose(id);
+            const pending = await this.#update(id, (current) => {
+                const { interrupted: _interrupted, ...clean } = current;
+                return {
+                    ...clean,
+                    state: "running",
+                    unacknowledgedInput: message,
+                };
+            });
             try {
-                await withDeadline(runner.request(operation, { message }, signal === undefined ? {} : { signal }), this.#deps.deadlineMs ?? 30_000);
+                await this.#request(id, operation, { message });
             }
             catch (error) {
-                return failure("send", error instanceof Error ? error.message : String(error), id, pending.state, ["input persisted as unacknowledged before dispatch"], false);
+                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);
         });
     }
     async get(id) {
         const record = await this.#deps.registry.get(id);
-        const runner = this.#runners.get(id);
         return record === undefined
             ? failure("get", "Unknown child", id)
-            : publicChild(record, runner?.connected === true);
+            : publicChild(record, this.#isLive(id));
     }
     async list() {
         const records = await this.#deps.registry.list();
-        return records.map((record) => publicChild(record, this.#runners.get(record.subagentId)?.connected === true));
+        return records.map((record) => publicChild(record, this.#isLive(record.subagentId)));
     }
-    stop(id, signal) {
-        this.#attachCancels.get(id)?.abort();
-        this.#stopHostWatch(id);
+    /** Child startup and runs count until Pi settles, including post-agent_end continuation. */
+    get activeCount() {
+        return this.#working.size;
+    }
+    stop(id) {
+        this.#clearSettledPanelClose(id);
         return this.#mutate(id, async () => {
             if (this.#stopping.has(id))
                 return this.get(id);
@@ -275,7 +1044,7 @@ export class SubagentManager {
             }
             catch (error) {
                 this.#stopping.delete(id);
-                return failure("stop", error instanceof Error ? error.message : String(error), id, undefined, [], true);
+                return failure("stop", errorMessage(error), id, undefined, [], true);
             }
             if (record === undefined) {
                 this.#stopping.delete(id);
@@ -283,509 +1052,385 @@ 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: "stopped",
+                    state: "error",
                 }));
             }
             catch (error) {
                 this.#stopping.delete(id);
-                return failure("stop", error instanceof Error ? error.message : String(error), id, record.state, [], true);
-            }
-            const runner = this.#runners.get(id);
-            if (runner === undefined && stopped.runtime !== undefined) {
-                this.#stopping.delete(id);
-                return failure("stop", "Runtime termination could not be confirmed because no live controller is attached", id, "stopped", ["stopped intent persisted", "runtime metadata retained"], true);
+                return failure("stop", errorMessage(error), id, record.state, [], true);
             }
             try {
-                if (runner !== undefined) {
-                    await withDeadline(runner.request("shutdown", undefined, signal === undefined ? {} : { signal }), this.#deps.deadlineMs ?? 30_000);
-                    await waitForRunnerDisconnect(runner, this.#deps.deadlineMs ?? 30_000, signal);
-                    runner.close();
-                    this.#runners.delete(id);
-                }
-                await this.#releaseHost(id);
-                this.#frozen.delete(id);
-                const runtimeIdentity = stopped.runtime?.runtimeIdentity;
-                if (runtimeIdentity !== undefined) {
-                    this.#deps.tokens?.forget(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;
-                        }, runtimeIdentity);
+                if (this.#isLive(id) && this.#deps.bridge.isConnected(id)) {
+                    await this.#request(id, "shutdown").catch((error) => {
+                        diagnose(`child ${id} did not answer shutdown: ${errorMessage(error)}`);
+                    });
+                }
+                const runtime = this.#processes.get(id);
+                const attachment = this.#attachments.get(id);
+                if (runtime !== undefined) {
+                    await runtime.terminate();
+                    if (runtime.alive) {
+                        // The handle is kept so a retried stop can try again instead of losing the process.
+                        return failure("stop", "Child process termination is not confirmed: the process may still be running", id, "error", ["stopped intent persisted", "runtime metadata retained"], true);
+                    }
+                    this.#processes.delete(id);
+                }
+                if (attachment !== undefined) {
+                    // The host owns a panel child, so ending it means closing the panel and confirming
+                    // it is gone; the close itself is not the proof. A panel that is still there keeps
+                    // its handle, so a retry can try the close again instead of falling back to a
+                    // bridge-only stop.
+                    const cleanup = await attachment.cleanup();
+                    if (!(await this.#panelGone(attachment))) {
+                        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);
+                }
+                if (runtime === undefined &&
+                    attachment === undefined &&
+                    this.#isLive(id) &&
+                    this.#deps.bridge.isConnected(id)) {
+                    // Nothing of this child's runtime is ours: it was adopted after a parent restart, so
+                    // the shutdown request above is all this process can do and the bridge is the only
+                    // evidence that it worked.
+                    const gone = await this.#awaitDisconnect(id, SUBAGENT_EXIT_WAIT_MS);
+                    if (!gone) {
+                        return failure("stop", "Child was asked to shut down but its exit is unconfirmed: this process does not own the child's runtime, so close its panel manually", id, "error", ["stopped intent persisted", "runtime metadata retained"], true);
                     }
                 }
+                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);
                 return publicChild(stopped, false);
             }
             catch (error) {
-                return failure("stop", error instanceof Error ? error.message : String(error), id, "stopped", ["stopped intent persisted", "runtime termination may be incomplete"], true);
+                return failure("stop", errorMessage(error), id, "error", ["stopped intent persisted", "runtime termination may be incomplete"], true);
             }
             finally {
                 this.#stopping.delete(id);
             }
         });
     }
-    ownsHostAttachment(identity) {
-        for (const attachment of this.#hostAttachments.values()) {
-            if (attachment.identity.host === identity.host &&
-                attachment.identity.attachmentId === identity.attachmentId)
-                return true;
-        }
-        return false;
-    }
-    attach(id, options = {}) {
-        const cancel = new AbortController();
-        this.#attachCancels.set(id, cancel);
-        if (options.signal?.aborted)
-            cancel.abort();
-        else
-            options.signal?.addEventListener("abort", () => cancel.abort(), { once: true });
-        this.#frozen.add(id);
-        return this.#mutate(id, () => this.#runAttach(id, options.preferredHost, cancel.signal)).finally(() => {
-            this.#attachCancels.delete(id);
-        });
-    }
-    restoreRpc(id) {
-        return this.detach(id, { origin: "manual", closeHost: true, operation: "restore_rpc" });
-    }
-    detach(id, options) {
-        return this.#mutate(id, () => this.#runDetach(id, options));
-    }
-    inspectHost(id) {
-        return this.#mutate(id, async () => {
-            const attachment = this.#hostAttachments.get(id);
-            if (attachment === undefined) {
-                return failure("inspect_host", "No host attachment is owned", id);
-            }
-            const observed = await attachment.observe();
-            if (!observed.known || observed.alive) {
-                return { alive: observed.alive, known: observed.known, detail: observed.detail };
-            }
-            return this.#runDetach(id, {
-                origin: this.#tuiQuitExpected.has(id) ? "tui_exit" : "tui_crash",
-                closeHost: true,
-            });
-        });
-    }
-    async #runAttach(id, preferredHost, signal) {
-        const failBeforeClose = async (reason, record, sideEffects = []) => {
-            this.#frozen.delete(id);
-            return failure("attach", reason, id, record?.state, sideEffects, true);
-        };
+    async contactParent(id, reason, message, knownRecord) {
+        const record = knownRecord ?? (await this.#deps.registry.get(id));
+        if (record === undefined)
+            return failure("contact_parent", "Unknown child", id);
+        if (this.#deps.channel === undefined)
+            return failure("contact_parent", "Parent channel unavailable", id, record.state, [], true);
         try {
-            throwIfAborted(signal);
-            const record = await this.#deps.registry.get(id);
-            if (record === undefined)
-                return failBeforeClose("Unknown child", undefined);
-            if (record.intent === "stopped" || record.state === "stopped" || record.state === "done")
-                return failBeforeClose("Child is not attachable", record);
-            if (record.mode === "tui")
-                return failBeforeClose("Child is already attached as TUI", record);
-            const runner = this.#runners.get(id);
-            if (runner === undefined || !runner.connected)
-                return failBeforeClose("Child runtime is not live", record);
-            const hostApi = this.#deps.attachHost;
-            if (hostApi === undefined)
-                return failBeforeClose("No presentation host is configured", record);
-            const token = record.runtime === undefined
-                ? undefined
-                : this.#deps.tokens?.get(record.runtime.runtimeIdentity);
-            if (token === undefined)
-                return failBeforeClose("Bridge token is unavailable for TUI launch", record);
-            throwIfAborted(signal);
-            const selection = await hostApi.select(preferredHost);
-            if (!selection.available)
-                return failBeforeClose(selection.reason, record, ["RPC writer retained"]);
-            throwIfAborted(signal);
-            const state = await withDeadline(runner.request("get_state", undefined, { signal }), this.#deps.deadlineMs ?? 30_000);
-            if (!isIdlePiState(state)) {
-                try {
-                    await withDeadline(runner.request("pause", undefined, { signal }), this.#deps.deadlineMs ?? 30_000);
-                }
-                catch (error) {
-                    try {
-                        await runner.request("cancel_pause");
-                    }
-                    catch {
-                        // Keep RPC; attach still fails below.
-                    }
-                    return failBeforeClose(error instanceof Error && error.message === "Attach was cancelled"
-                        ? error.message
-                        : `Child did not pause before attach deadline: ${error instanceof Error ? error.message : String(error)}`, record, ["RPC writer retained"]);
-                }
-            }
-            throwIfAborted(signal);
-            const placement = await planSessionPlacement({
-                sessionId: record.sessionId,
-                cwd: record.cwd,
-                sessionDir: record.launchConfig.sessionDir,
-                persistence: record.persistence,
-                ...(record.sessionPath === undefined ? {} : { sessionPath: record.sessionPath }),
+            await this.#deps.channel.deliver({
+                parentSessionId: record.parentSessionId,
+                childId: id,
+                agent: record.launchConfig.agent.displayName ?? record.launchConfig.agent.name,
+                task: record.initialTask,
+                status: record.state,
+                reason,
+                message,
             });
-            if (placement.persistence !== "flushed" || placement.sessionPath === undefined)
-                return failBeforeClose("Session has not been flushed; attach refused", record, [
-                    "RPC writer retained",
-                ]);
-            const sessionPath = placement.sessionPath;
-            const flushed = sessionPath === record.sessionPath && record.persistence === "flushed"
-                ? record
-                : await this.#update(id, (current) => ({
+            if (reason === "blocked") {
+                const projector = this.#projectors.get(id);
+                if (projector !== undefined) {
+                    projector.syncState("blocked");
+                }
+                await this.#update(id, (current) => ({
                     ...current,
-                    persistence: "flushed",
-                    sessionPath,
-                    launchConfig: { ...current.launchConfig, sessionPath },
+                    state: "blocked",
+                    interrupted: message,
                 }));
-            throwIfAborted(signal);
-            await withDeadline(runner.request("close_writer", undefined, { signal }), this.#deps.deadlineMs ?? 30_000);
-            const writerClosed = true;
-            try {
-                throwIfAborted(signal);
-                const launch = buildLaunchSpec({
-                    config: {
-                        ...flushed.launchConfig,
-                        sessionPath,
-                    },
-                    invocation: flushed.launchConfig.invocation,
-                    mode: "tui",
-                    persistence: "flushed",
-                    bridge: {
-                        parentSessionId: flushed.parentSessionId,
-                        subagentId: flushed.subagentId,
-                        runtimeIdentity: flushed.runtime?.runtimeIdentity ?? "missing",
-                        endpoint: flushed.runtime?.endpoint ?? "",
-                    },
-                });
-                const attachment = await selection.adapter.attach({
-                    ...launch,
-                    env: withBridgeToken(launch.env, token),
-                });
-                if (signal.aborted) {
-                    this.#hostAttachments.set(id, attachment);
-                    const restored = await this.#restoreRpcAfterHost(id, runner);
-                    this.#frozen.delete(id);
-                    return failure("attach", "Attach was cancelled", id, flushed.state, [restored], false);
+                if (this.#taskRegistry !== undefined) {
+                    this.#taskRegistry.settle(id, {
+                        status: "failed",
+                        output: message,
+                        truncated: false,
+                    });
                 }
-                const observed = await attachment.observe();
-                if (attachment.launch.timedOut && !observed.known) {
-                    this.#hostAttachments.set(id, attachment);
-                    this.#watchHost(id);
-                    await this.#update(id, (current) => ({ ...current, mode: "tui" }));
-                    this.#frozen.delete(id);
-                    return failure("attach", "Host timed out and TUI writer state is unknown; not starting another writer", id, flushed.state, ["RPC writer closed", "TUI writer state unknown"], false);
-                }
-                if (attachment.launch.timedOut && !observed.alive) {
-                    this.#hostAttachments.set(id, attachment);
-                    const restored = await this.#restoreRpcAfterHost(id, runner);
-                    this.#frozen.delete(id);
-                    return failure("attach", "Host timed out and TUI writer was not confirmed", id, flushed.state, [restored, "pending input was not replayed"], false);
-                }
-                if (attachment.launch.timedOut && observed.alive) {
-                    this.#hostAttachments.set(id, attachment);
-                    this.#watchHost(id);
-                    await this.#update(id, (current) => ({ ...current, mode: "tui" }));
-                    return failure("attach", "Host timed out after TUI started; not starting another writer", id, "idle", ["TUI writer may be live", "RPC writer closed"], false);
-                }
-                this.#hostAttachments.set(id, attachment);
-                this.#watchHost(id);
-                const next = await this.#update(id, (current) => ({
+                this.#scheduleSettledPanelClose(id);
+            }
+            else if (reason === "error") {
+                const projector = this.#projectors.get(id);
+                if (projector !== undefined) {
+                    projector.syncState("error");
+                }
+                await this.#update(id, (current) => ({
                     ...current,
-                    mode: "tui",
-                    state: "idle",
+                    intent: "stopped",
+                    state: "error",
+                    interrupted: message,
                 }));
-                return {
-                    child: publicChild(next, true),
-                    host: selection.selectedHost,
-                    attachmentId: attachment.identity.attachmentId,
-                };
-            }
-            catch (error) {
-                if (!writerClosed)
-                    throw error;
-                const restored = await this.#restoreRpcAfterHost(id, runner);
-                this.#frozen.delete(id);
-                return failure("attach", error instanceof Error ? error.message : String(error), id, flushed.state, [restored, "pending input was not replayed"], false);
+                if (this.#taskRegistry !== undefined) {
+                    this.#taskRegistry.settle(id, {
+                        status: "failed",
+                        output: message,
+                        truncated: false,
+                    });
+                }
+                this.#scheduleSettledPanelClose(id);
             }
+            return { delivered: true };
         }
         catch (error) {
-            this.#frozen.delete(id);
-            return failure("attach", error instanceof Error ? error.message : String(error), id, undefined, ["RPC writer retained"], true);
-        }
-    }
-    async #restoreRpcAfterHost(id, runner) {
-        try {
-            await this.#releaseHost(id);
-        }
-        catch (error) {
-            return `RPC not restored: ${error instanceof Error ? error.message : String(error)}`;
+            return failure("contact_parent", errorMessage(error), id, record.state, [], true);
         }
-        return this.#restoreRpc(id, runner);
     }
-    async #restoreRpc(id, runner) {
-        try {
-            await withDeadline(runner.request("start_rpc"), this.#deps.deadlineMs ?? 30_000);
-            await this.#update(id, (current) => ({ ...current, mode: "rpc" }));
-            return "RPC writer restored; waiting for input";
-        }
-        catch (error) {
-            return `RPC restore failed: ${error instanceof Error ? error.message : String(error)}`;
+    /**
+     * 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.
+     */
+    async handleChildRequest(childId, operation, payload) {
+        const record = await this.#deps.registry.get(childId);
+        if (record === undefined)
+            throw new BridgeError("unknown_child", `Unknown child ${childId}`);
+        if (operation === "contact_parent") {
+            if (!isContactReportPayload(payload)) {
+                throw new BridgeError("invalid_payload", "contact_parent requires a report payload");
+            }
+            if (payload.parentSessionId !== record.parentSessionId ||
+                payload.childId !== childId ||
+                payload.runtimeIdentity !== record.runtime?.runtimeIdentity) {
+                throw new BridgeError("stale_report", "This report does not belong to the current runtime");
+            }
+            const reason = payload.reason ?? "blocked";
+            const delivered = await this.contactParent(childId, reason, payload.message, record);
+            if ("reason" in delivered)
+                throw new BridgeError("delivery_failed", delivered.reason);
+            if (reason === "success") {
+                const projector = this.#projectors.get(childId);
+                if (projector !== undefined) {
+                    projector.syncState("done");
+                }
+                await this.#update(childId, (current) => ({
+                    ...current,
+                    state: "done",
+                }));
+            }
+            else if (reason === "blocked") {
+                const projector = this.#projectors.get(childId);
+                if (projector !== undefined) {
+                    projector.syncState("blocked");
+                }
+                await this.#update(childId, (current) => ({
+                    ...current,
+                    state: "blocked",
+                }));
+            }
+            else {
+                const projector = this.#projectors.get(childId);
+                if (projector !== undefined) {
+                    projector.syncState("error");
+                }
+                await this.#update(childId, (current) => ({
+                    ...current,
+                    intent: "stopped",
+                    state: "error",
+                }));
+            }
+            return { delivered: true };
         }
+        throw new BridgeError("unsupported_operation", `The parent does not accept ${operation} from a child`);
     }
-    async #releaseHost(id) {
-        this.#stopHostWatch(id);
-        const attachment = this.#hostAttachments.get(id);
-        if (attachment === undefined)
-            return;
-        const result = await attachment.cleanup();
-        if (hostCleanupFailed(result)) {
-            throw new Error(result.stderr || result.stdout || "Host cleanup failed");
-        }
-        const observed = await attachment.observe();
-        if (!observed.known || observed.alive) {
-            throw new Error(observed.known
-                ? `TUI writer still alive after cleanup: ${observed.detail}`
-                : `TUI writer state unknown after cleanup: ${observed.detail}`);
+    /** Applies a bridge event to this child's record and notifies the raw child-event listeners. */
+    handleEvent(childId, event) {
+        if (isRecord(event) && event.type === "agent_start") {
+            this.#workVersions.set(childId, (this.#workVersions.get(childId) ?? 0) + 1);
+            this.#working.add(childId);
+            this.#notify();
         }
-        this.#hostAttachments.delete(id);
-    }
-    #stopHostWatch(id) {
-        const watch = this.#hostWatches.get(id);
-        if (watch === undefined)
-            return;
-        watch.abort();
-        this.#hostWatches.delete(id);
+        // 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);
+        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)}`);
+        });
     }
-    #watchHost(id) {
-        this.#stopHostWatch(id);
-        const attachment = this.#hostAttachments.get(id);
-        if (attachment === undefined)
-            return;
-        const stop = new AbortController();
-        this.#hostWatches.set(id, stop);
-        const intervalMs = this.#deps.watchIntervalMs ?? 1_000;
-        const tick = () => {
-            if (stop.signal.aborted)
-                return;
-            if (this.#hostAttachments.get(id) !== attachment)
+    handleConnectionChange(childId, connected) {
+        this.#bumpActivity(childId);
+        void this.#mutate(childId, async () => {
+            const record = await this.#deps.registry.get(childId);
+            if (record === undefined)
                 return;
-            void attachment.observe().then((observed) => {
-                if (stop.signal.aborted)
-                    return;
-                if (this.#hostAttachments.get(id) !== attachment)
+            if (connected) {
+                if (record.intent === "stopped")
                     return;
-                if (!observed.known || observed.alive)
+                // A process that left the delegated session is not this child: adopting it would rewrite
+                // the child's transcript from the session the human switched to.
+                if (this.#leftSessions.has(childId))
                     return;
-                const origin = this.#tuiQuitExpected.has(id) ? "tui_exit" : "tui_crash";
-                this.#tuiQuitExpected.delete(id);
-                void this.detach(id, { origin, closeHost: true }).catch((error) => {
-                    console.error(`pi-subagents: detach after TUI exit failed for ${id}: ${error instanceof Error ? error.message : String(error)}`);
-                });
-            });
-        };
-        const timer = setInterval(tick, intervalMs);
-        stop.signal.addEventListener("abort", () => {
-            clearInterval(timer);
-        }, { once: true });
-        tick();
-    }
-    async #runDetach(id, options) {
-        const operation = options.operation ?? "detach";
-        const record = await this.#deps.registry.get(id);
-        if (record === undefined)
-            return failure(operation, "Unknown child", id);
-        if (record.intent === "stopped" || record.state === "stopped") {
-            this.#stopHostWatch(id);
-            return failure(operation, "Stopped child is not restored", id, "stopped", [], false);
-        }
-        if (record.mode !== "tui") {
-            return publicChild(record, this.#runners.get(id)?.connected === true);
-        }
-        this.#stopHostWatch(id);
-        if (options.closeHost === false) {
-            this.#hostAttachments.delete(id);
-        }
-        else {
+                // 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));
+                }
+                await this.#adopt(childId);
+                return;
+            }
+            // No bridge any more: the runtime is gone when nothing of it is left here, which is also
+            // what releases a panel whose child the host no longer runs.
+            await this.#runtimeEnded(childId);
+        });
+    }
+    #dispatch(childId, event) {
+        for (const listener of this.#childEventListeners) {
             try {
-                await this.#releaseHost(id);
+                listener(childId, event);
             }
             catch (error) {
-                this.#frozen.delete(id);
-                return failure(operation, error instanceof Error ? error.message : String(error), id, record.state, ["TUI writer was not confirmed gone"], false);
+                diagnose(`child event listener failed for ${childId}: ${errorMessage(error)}`);
             }
         }
-        const runner = this.#runners.get(id);
-        if (runner === undefined || !runner.connected) {
-            this.#frozen.delete(id);
-            return failure(operation, "Child runtime is not live", id);
-        }
-        const restored = await this.#restoreRpc(id, runner);
-        this.#frozen.delete(id);
-        const next = await this.#deps.registry.get(id);
-        if (next === undefined)
-            return failure(operation, "Unknown child", id);
-        if (restored.startsWith("RPC restore failed")) {
-            return failure(operation, restored, id, next.state, [restored], false);
-        }
-        if (options.origin === "tui_crash") {
-            await this.#update(id, (current) => ({
-                ...current,
-                interrupted: "TUI exited abnormally; RPC restored waiting for input",
-            }));
-            await this.contactParent(id, "tui_crash", "Child TUI exited abnormally. RPC was restored and is waiting for input. Pending work was not replayed.");
-        }
-        return publicChild((await this.#deps.registry.get(id)) ?? next, true);
-    }
-    async contactParent(id, reason, message) {
-        const record = await this.#deps.registry.get(id);
-        if (record === undefined)
-            return failure("contact_parent", "Unknown child", id);
-        if (this.#deps.channel === undefined)
-            return failure("contact_parent", "Parent channel unavailable", id, record.state, [], true);
-        try {
-            await this.#deps.channel.deliver({
-                parentSessionId: record.parentSessionId,
-                childId: id,
-                agent: record.launchConfig.agent.displayName ?? record.launchConfig.agent.name,
-                task: record.initialTask,
-                status: record.state,
-                reason,
-                message,
-            });
-            return { delivered: true };
-        }
-        catch (error) {
-            return failure("contact_parent", error instanceof Error ? error.message : String(error), id, record.state, [], true);
-        }
     }
-    closeLocalConnections() {
-        for (const id of [...this.#hostWatches.keys()])
-            this.#stopHostWatch(id);
-        for (const runner of this.#runners.values())
-            runner.close();
-        this.#runners.clear();
-        this.#deps.tokens?.clear();
-        this.#notify();
-    }
-    async #observe(id, event, runner) {
-        if (this.#runners.get(id) !== runner)
-            return;
+    async #observe(id, event, workVersion) {
+        this.#dispatch(id, event);
         const value = isRecord(event) ? event : undefined;
         if (value === undefined)
             return;
-        if (value.type === "subagent_report") {
-            const report = isRecord(value.report) ? value.report : undefined;
-            if (report?.type === "pi_subagent_report" &&
-                typeof report.parentSessionId === "string" &&
-                typeof report.childId === "string" &&
-                typeof report.runtimeIdentity === "string" &&
-                typeof report.reason === "string" &&
-                typeof report.message === "string") {
-                const record = await this.#deps.registry.get(id);
-                if (record === undefined ||
-                    record.intent === "stopped" ||
-                    report.parentSessionId !== record.parentSessionId ||
-                    report.childId !== id ||
-                    report.runtimeIdentity !== record.runtime?.runtimeIdentity)
-                    return;
-                await this.contactParent(id, report.reason, report.message);
-            }
-            return;
-        }
-        if (value.type === "child_lifecycle") {
+        if (value.type === "child_lifecycle" && isChildLifecyclePayload(value)) {
             const record = await this.#deps.registry.get(id);
             if (record === undefined ||
                 record.intent === "stopped" ||
-                typeof value.kind !== "string" ||
-                typeof value.parentSessionId !== "string" ||
-                typeof value.childId !== "string" ||
-                typeof value.runtimeIdentity !== "string" ||
                 value.parentSessionId !== record.parentSessionId ||
                 value.childId !== id ||
                 value.runtimeIdentity !== record.runtime?.runtimeIdentity)
                 return;
-            if (value.kind === "tui_quit") {
-                this.#tuiQuitExpected.add(id);
-                return;
-            }
             if (value.kind === "user_interrupt") {
-                const message = typeof value.message === "string" && value.message !== ""
-                    ? value.message
-                    : "Task is unfinished and waiting for user intent.";
-                await this.#update(id, (current) => ({
+                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);
+                await this.contactParent(id, "user_interrupt", message, updated);
                 return;
             }
             if (value.kind === "left_session") {
-                await this.#runDetach(id, { origin: "session_switch", closeHost: false });
+                this.#working.delete(id);
+                // The process now serves another session, so it is no longer this child's runtime. Its
+                // credential is revoked and its runtime evidence dropped, so neither a reconnect nor a
+                // later adopt can mistake the new session for this child; the panel belongs to that other
+                // session from now on, which is why it is forgotten here and never closed.
+                const retired = record.runtime?.runtimeIdentity;
+                this.#clearSettledPanelClose(id);
+                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",
+                    };
+                });
+                if (retired !== undefined)
+                    this.#deps.tokens?.forget(retired);
+                return;
             }
+            // A child's own quit is a lifecycle notice, not state: the disconnect that follows says
+            // whether the runtime is gone.
+            return;
+        }
+        if (value.type === "child_input" && isChildInputPayload(value)) {
+            // Someone typed into the panel, so the child is not idle any more. Only human input counts:
+            // a message this parent sent over the bridge arrives as `rpc` and says nothing about the
+            // panel. The turn that follows re-arms the countdown when it ends with nothing pending.
+            if (value.source === "interactive")
+                this.#clearSettledPanelClose(id);
             return;
         }
+        const record = await this.#deps.registry.get(id);
+        if (record === undefined || record.intent === "stopped")
+            return;
         const projector = this.#projectors.get(id);
         if (projector === undefined)
             return;
         projector.applyEvent(event);
         let confirmedInput;
-        if (value.type === "agent_end" || value.type === "runner_events_dropped") {
-            const response = await runner.request("get_entries").catch(() => undefined);
-            const entries = isRecord(response) && Array.isArray(response.entries) ? response.entries : [];
-            projector.rebuild(entries);
-            if (value.type === "agent_end") {
-                const record = await this.#deps.registry.get(id);
-                if (record?.unacknowledgedInput !== undefined &&
-                    sessionContainsUserInput(entries, record.unacknowledgedInput))
+        if (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)) {
                     confirmedInput = record.unacknowledgedInput;
-            }
-            else {
-                const piState = await runner.request("get_state").catch(() => undefined);
-                if (isIdlePiState(piState))
-                    projector.applyEvent({ type: "agent_settled" });
-                else if (isRecord(piState) &&
-                    (piState.isStreaming === true || piState.isCompacting === true)) {
-                    projector.applyEvent({ type: "agent_start" });
                 }
             }
         }
-        if (value.type === "runner_exit") {
-            this.#runners.delete(id);
-            runner.close();
-        }
         const current = await this.#deps.registry.get(id);
         if (current === undefined || current.intent === "stopped")
             return;
         const snapshot = projector.snapshot();
-        await this.#update(id, (record) => {
+        await this.#update(id, (entry) => {
+            const { interrupted: _prevInterrupted, activeTool: _prevActiveTool, ...cleanEntry } = entry;
             const base = confirmedInput === undefined
-                ? record
-                : (({ unacknowledgedInput: _input, interrupted: _interrupted, ...rest }) => rest)(record);
+                ? 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);
+        if (snapshot.state === "done" || snapshot.state === "blocked" || snapshot.state === "error") {
+            this.#scheduleSettledPanelClose(id);
+        }
+        else {
+            this.#clearSettledPanelClose(id);
+        }
+        if (value.type === "agent_settled" && (this.#workVersions.get(id) ?? 0) === workVersion) {
+            this.#working.delete(id);
+            this.#notify();
+            const latestRecord = (await this.#deps.registry.get(id)) ?? current;
+            this.#scheduleAutoReport(id, latestRecord);
+        }
     }
-    #attach(record, runner) {
-        this.#runners.get(record.subagentId)?.close();
-        this.#runners.set(record.subagentId, runner);
-        this.#projectors.set(record.subagentId, createStateProjector(record.state));
-        runner.onEvent((event) => {
-            void this.#mutate(record.subagentId, () => this.#observe(record.subagentId, event, runner)).catch((error) => {
-                console.error(`pi-subagents: failed to project event for ${record.subagentId}: ${error instanceof Error ? error.message : String(error)}`);
-            });
-        });
+    /** Runs an update inside the per-child chain used by the mutating operations. */
+    #mutateUpdate(id, updater) {
+        return this.#mutate(id, () => this.#update(id, updater));
     }
-    async #update(id, updater) {
-        const current = await this.#deps.registry.get(id);
-        if (current === undefined)
-            throw new Error("Child disappeared");
-        const next = await this.#deps.registry.update(id, current.revision, updater);
+    async #update(id, updater, workVersion) {
+        // The store re-reads the record inside its own write, so an undefined revision cannot
+        // lose a concurrent field update and no stale_revision retry is needed.
+        const next = await this.#deps.registry.update(id, undefined, updater);
+        if (workVersion === undefined || workVersion === (this.#workVersions.get(id) ?? 0)) {
+            if (next.state === "running")
+                this.#working.add(id);
+            else if (next.state !== "error")
+                this.#working.delete(id);
+        }
         this.#notify();
         return next;
     }
@@ -793,10 +1438,12 @@ export class SubagentManager {
         const previous = this.#chains.get(id) ?? Promise.resolve();
         const next = previous.catch(() => undefined).then(action);
         this.#chains.set(id, next);
-        void next.finally(() => {
+        void next
+            .finally(() => {
             if (this.#chains.get(id) === next)
                 this.#chains.delete(id);
-        });
+        })
+            .catch(() => undefined);
         return next;
     }
 }