@hheei/pi-subagents 0.2.3 → 0.3.0

package/dist/manager.js

@@ -1,12 +1,29 @@
+import { readFile } from "node:fs/promises";
 import { errorMessage, isRecord } from "@hheei/pi-ext-core";
+import { isOperationError } from "./domain.js";
 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";
+async function readSessionJsonlEntries(filePath) {
+    const content = await readFile(filePath, "utf8");
+    const entries = [];
+    for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed.length > 0) {
+            try {
+                entries.push(JSON.parse(trimmed));
+            }
+            catch {
+                // Ignore corrupted line
+            }
+        }
+    }
+    return entries;
+}
 import { createStateProjector } from "./state.js";
 /**
  * How long an idle child keeps its runtime. A background child holds a whole Pi process and its
- * session lock, so an idle one is reclaimed after this window and a later `send_agent` starts it
+ * session lock, so an idle one is reclaimed after this window and a later `agent_send` starts it
  * again from the same session.
  */
 export const SUBAGENT_IDLE_TIMEOUT_MS = 15_000;
@@ -29,9 +46,19 @@ function failure(operation, reason, childId, state, sideEffects = [], safeToRetr
         safeToRetry,
     };
 }
-function publicChild(record, live) {
+function acknowledgedPath(response) {
+    if (!isRecord(response) ||
+        response.accepted !== true ||
+        typeof response.path !== "string" ||
+        response.path === "") {
+        throw new BridgeError("invalid_state", "Child did not confirm its session path");
+    }
+    return response.path;
+}
+function publicChild(record, live, path = record.sessionPath) {
     return {
         id: record.subagentId,
+        ...(path === undefined ? {} : { path }),
         agent: record.launchConfig.agent.name,
         ...(record.launchConfig.agent.displayName === undefined
             ? {}
@@ -40,12 +67,12 @@ function publicChild(record, live) {
         presentation: record.presentation,
         cwd: record.cwd,
         sessionId: record.sessionId,
+        ...(record.initialTask === undefined ? {} : { task: record.initialTask }),
         ...(record.latestSummary === undefined ? {} : { summary: record.latestSummary }),
         ...(record.activeTool === undefined ? {} : { activeTool: record.activeTool }),
         ...(record.usage === undefined ? {} : { usage: record.usage }),
         ...(record.interrupted === undefined ? {} : { interrupted: record.interrupted }),
         freshness: live ? "live" : "last_known",
-        interactive: record.launchConfig.interactive,
         model: record.launchConfig.model,
         thinking: record.launchConfig.thinking,
         createdAt: record.createdAt,
@@ -131,12 +158,15 @@ export class SubagentManager {
     /** Bumped by every inbound bridge signal, so a reclaim in flight can tell the child moved. */
     #activity = new Map();
     #projectors = new Map();
+    /** Display paths do not imply that a session has been flushed to disk. */
+    #paths = new Map();
     /** Known child work in flight, separate from failures recorded before Pi finally settles. */
     #working = new Set();
     /** A settled event from an older run cannot clear a newer synchronous start signal. */
     #workVersions = new Map();
     #settledPanelCloseTimers = new Map();
-    #autoReportTimers = new Map();
+    #pendingAutoReports = new Map();
+    #autoReportBatchTimer;
     #lastDeliveredTurn = new Map();
     #stopping = new Set();
     #listeners = new Set();
@@ -168,7 +198,7 @@ export class SubagentManager {
             this.#childEventListeners.delete(listener);
         };
     }
-    /** Presentation-only: widget and similar projections re-read list() after this. */
+    /** Presentation-only: status and similar projections re-read list() after this. */
     onChange(listener) {
         this.#listeners.add(listener);
         return () => {
@@ -176,6 +206,11 @@ export class SubagentManager {
         };
     }
     dispose() {
+        if (this.#autoReportBatchTimer !== undefined) {
+            clearTimeout(this.#autoReportBatchTimer);
+            this.#autoReportBatchTimer = undefined;
+        }
+        this.#pendingAutoReports.clear();
         for (const timer of this.#settledPanelCloseTimers.values()) {
             clearTimeout(timer);
         }
@@ -190,12 +225,18 @@ export class SubagentManager {
      */
     closeLocalConnections() {
         this.dispose();
+        if (this.#autoReportBatchTimer !== undefined) {
+            clearTimeout(this.#autoReportBatchTimer);
+            this.#autoReportBatchTimer = undefined;
+        }
+        this.#pendingAutoReports.clear();
         this.#processes.clear();
         this.#attachments.clear();
         this.#leftSessions.clear();
         this.#unresolvedRuntimes.clear();
         this.#activity.clear();
         this.#projectors.clear();
+        this.#paths.clear();
         this.#working.clear();
         this.#workVersions.clear();
         this.#notify();
@@ -299,13 +340,15 @@ export class SubagentManager {
             // 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.#attachments.has(id)) {
+            if ((await this.#deps.registry.get(id))?.intent === "stopped") {
+                return STOPPED_SEND_REASON;
+            }
+        }
         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";
         }
@@ -346,7 +389,7 @@ export class SubagentManager {
                 ...withoutRuntime,
                 intent: "stopped",
                 state: "error",
-                interrupted: "The child panel was closed while running; spawn a new child for more work",
+                interrupted: "The host reports that the child process exited while running; the cause is unknown. Spawn a new child for more work",
             };
         });
         if (retired !== undefined)
@@ -397,19 +440,29 @@ export class SubagentManager {
      * only ever closed on a judgement, never on a guess.
      */
     #scheduleAutoReport(id, record) {
-        this.#clearAutoReport(id);
-        const timer = setTimeout(() => {
-            this.#autoReportTimers.delete(id);
-            void this.#performAutoReport(id, record);
-        }, 5_000);
-        timer.unref?.();
-        this.#autoReportTimers.set(id, timer);
+        this.#pendingAutoReports.set(id, record);
+        if (this.#autoReportBatchTimer !== undefined) {
+            clearTimeout(this.#autoReportBatchTimer);
+        }
+        // Batch reports: if all children settled, flush in 500ms; otherwise wait up to 10000ms for others
+        const delayMs = this.#working.size > 0 ? 10_000 : 500;
+        this.#autoReportBatchTimer = setTimeout(async () => {
+            this.#autoReportBatchTimer = undefined;
+            const batch = [...this.#pendingAutoReports.entries()];
+            this.#pendingAutoReports.clear();
+            for (const [childId, childRecord] of batch) {
+                await this.#performAutoReport(childId, childRecord).catch((error) => {
+                    diagnose(`failed to report child ${childId}: ${errorMessage(error)}`);
+                });
+            }
+        }, delayMs);
+        this.#autoReportBatchTimer.unref?.();
     }
     #clearAutoReport(id) {
-        const timer = this.#autoReportTimers.get(id);
-        if (timer !== undefined) {
-            clearTimeout(timer);
-            this.#autoReportTimers.delete(id);
+        this.#pendingAutoReports.delete(id);
+        if (this.#pendingAutoReports.size === 0 && this.#autoReportBatchTimer !== undefined) {
+            clearTimeout(this.#autoReportBatchTimer);
+            this.#autoReportBatchTimer = undefined;
         }
     }
     #scheduleSettledPanelClose(id) {
@@ -443,7 +496,10 @@ export class SubagentManager {
     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") {
+            if (record === undefined ||
+                record.state === "running" ||
+                record.intent === "stopped" ||
+                this.#working.has(id)) {
                 return;
             }
             const attachment = this.#attachments.get(id);
@@ -516,83 +572,113 @@ export class SubagentManager {
         const record = (await this.#deps.registry.get(id)) ?? _record;
         if (record.intent === "stopped" || record.state === "running")
             return;
+        const activity = this.#activity.get(id) ?? 0;
+        const workVersion = this.#workVersions.get(id) ?? 0;
         const entries = await this.#entries(id);
         const text = entries !== undefined ? extractLastAssistantText(entries) : undefined;
-        const hasError = record.state === "error" ||
-            (record.interrupted !== undefined && record.interrupted.trim() !== "");
-        const isBlocked = hasError;
-        if (!isBlocked && (text === undefined || text.trim() === "")) {
+        await this.#mutate(id, async () => {
+            const current = await this.#deps.registry.get(id);
+            if (current === undefined ||
+                current.intent === "stopped" ||
+                current.state === "running" ||
+                this.#working.has(id) ||
+                (this.#activity.get(id) ?? 0) !== activity ||
+                (this.#workVersions.get(id) ?? 0) !== workVersion)
+                return;
+            const isError = current.state === "error" || record.state === "error";
+            const isBlocked = !isError &&
+                (current.state === "blocked" ||
+                    record.state === "blocked" ||
+                    (current.interrupted !== undefined && current.interrupted.trim() !== "") ||
+                    (record.interrupted !== undefined && record.interrupted.trim() !== ""));
+            const failed = isError || isBlocked;
+            if (!failed && (text === undefined || text.trim() === "")) {
+                const projector = this.#projectors.get(id);
+                if (projector !== undefined) {
+                    projector.syncState("done");
+                }
+                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;
+            const interruptedText = current.interrupted?.trim() || record.interrupted?.trim();
+            if (isError) {
+                message = interruptedText || "Subagent failed without error details.";
+            }
+            else if (isBlocked) {
+                if (interruptedText !== undefined && interruptedText !== "") {
+                    message =
+                        text !== undefined && text.trim() !== ""
+                            ? `${interruptedText}\n\n${text}`
+                            : interruptedText;
+                }
+                else if (text !== undefined && text.trim() !== "") {
+                    message = text;
+                }
+                else {
+                    message = "Subagent became idle without completing its task (interrupted or failed).";
+                }
+            }
+            else {
+                message = text ?? "";
+            }
+            const lastDelivered = this.#lastDeliveredTurn.get(id);
+            if (lastDelivered !== undefined &&
+                lastDelivered.workVersion === workVersion &&
+                lastDelivered.message === message) {
+                return;
+            }
+            const reason = isError ? "error" : isBlocked ? "blocked" : "success";
+            const taskStatus = failed ? "failed" : "completed";
             const projector = this.#projectors.get(id);
+            const updatedRecord = !failed
+                ? await this.#update(id, (current) => {
+                    const { interrupted: _interrupted, ...clean } = current;
+                    return {
+                        ...clean,
+                        state: "done",
+                    };
+                })
+                : await this.#update(id, (current) => ({
+                    ...current,
+                    state: isError ? "error" : "blocked",
+                    interrupted: current.interrupted ?? message,
+                }));
             if (projector !== undefined) {
-                projector.syncState("done");
+                projector.syncState(isError ? "error" : isBlocked ? "blocked" : "done");
             }
-            await this.#update(id, (current) => {
-                const { interrupted: _interrupted, ...clean } = current;
-                return {
-                    ...clean,
-                    state: "done",
-                };
-            });
+            this.#scheduleSettledPanelClose(id);
             if (this.#taskRegistry !== undefined) {
                 this.#taskRegistry.settle(id, {
-                    status: "completed",
-                    output: "",
+                    status: taskStatus,
+                    output: message,
                     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;
+            let deliveryOk = true;
+            if (this.#deps.channel !== undefined) {
+                const contactResult = await this.contactParent(id, reason, message, updatedRecord);
+                if (isOperationError(contactResult)) {
+                    deliveryOk = false;
+                }
             }
-            else {
-                message = "Subagent became idle without completing its task (interrupted or failed).";
+            if (deliveryOk) {
+                this.#lastDeliveredTurn.set(id, { workVersion, message });
             }
-        }
-        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) {
@@ -728,11 +814,37 @@ export class SubagentManager {
      */
     async #settleUnrecovered(record) {
         this.#working.delete(record.subagentId);
+        this.#projectors.delete(record.subagentId);
         const retired = record.runtime;
-        if (retired === undefined)
-            return;
         if (record.presentation === "panel") {
-            this.#unresolvedRuntimes.add(record.subagentId);
+            if (retired !== undefined) {
+                this.#unresolvedRuntimes.add(record.subagentId);
+            }
+            await this.#update(record.subagentId, (current) => {
+                if (current.intent === "stopped")
+                    return current;
+                if (current.state !== "running")
+                    return current;
+                return {
+                    ...current,
+                    state: "blocked",
+                    interrupted: "The child panel runtime did not reconnect; its process exit is not confirmed",
+                };
+            });
+            return;
+        }
+        if (retired === undefined) {
+            await this.#update(record.subagentId, (current) => {
+                if (current.intent === "stopped")
+                    return current;
+                if (current.state !== "running")
+                    return current;
+                return {
+                    ...current,
+                    state: "done",
+                    interrupted: "The child runtime ended with the parent process; a later send starts it again from the same session",
+                };
+            });
             return;
         }
         await this.#update(record.subagentId, (current) => {
@@ -762,6 +874,9 @@ export class SubagentManager {
             throw new BridgeError("invalid_state", `Child ${id} did not confirm its current work state`);
         }
         const idle = state.idle && !state.pendingMessages;
+        if (typeof state.path === "string" && state.path !== "") {
+            this.#paths.set(id, state.path);
+        }
         if ((this.#workVersions.get(id) ?? 0) === workVersion) {
             if (idle)
                 this.#working.delete(id);
@@ -786,8 +901,9 @@ export class SubagentManager {
                 ? current
                 : (({ unacknowledgedInput: _input, ...rest }) => rest)(current);
             const hasError = snapshot.state === "error";
+            const { interrupted: _interrupted, ...withoutInterrupted } = base;
             return {
-                ...base,
+                ...withoutInterrupted,
                 state: hasError ? "error" : idle ? "done" : "running",
                 ...(snapshot.summary === undefined ? {} : { latestSummary: snapshot.summary }),
                 usage: snapshot.usage,
@@ -848,9 +964,11 @@ export class SubagentManager {
             childId = record.subagentId;
             this.#working.add(childId);
             this.#notify();
-            await withDeadline(this.#start(record), this.#deps.deadlineMs ?? 30_000);
+            await withDeadline(this.#start(record), this.#deps.deadlineMs ?? 60_000);
+            let path;
             try {
-                await this.#request(record.subagentId, "prompt", { message: cleanTask });
+                path = acknowledgedPath(await this.#request(record.subagentId, "prompt", { message: cleanTask }));
+                this.#paths.set(record.subagentId, path);
             }
             catch (error) {
                 let failureState = "error";
@@ -891,6 +1009,9 @@ export class SubagentManager {
                                 output: `Subagent ${record.subagentId} (${input.agent}) is running`,
                                 truncated: false,
                             }),
+                            consume: () => {
+                                this.#deps.channel?.dismiss?.(record.subagentId);
+                            },
                         }),
                     });
                 }
@@ -899,31 +1020,52 @@ export class SubagentManager {
                 }
             }
             return {
-                child: publicChild((await this.#deps.registry.get(record.subagentId)) ?? record, true),
+                child: publicChild((await this.#deps.registry.get(record.subagentId)) ?? record, true, path),
+                path,
                 ...(placement.note === undefined ? {} : { note: placement.note }),
             };
         }
         catch (error) {
-            if (childId !== undefined &&
-                !this.#runtimeStarted(childId) &&
-                !this.#unresolvedRuntimes.has(childId)) {
-                this.#working.delete(childId);
-            }
-            this.#notify();
-            return failure("spawn", errorMessage(error), undefined, undefined, [], true);
+            if (childId === undefined)
+                return failure("spawn", errorMessage(error));
+            const failedId = childId;
+            const reason = errorMessage(error);
+            const failed = await this.#mutate(failedId, async () => {
+                const record = await this.#deps.registry.get(failedId);
+                const uncertain = this.#runtimeStarted(failedId) ||
+                    this.#unresolvedRuntimes.has(failedId) ||
+                    record?.runtime !== undefined;
+                if (uncertain)
+                    this.#unresolvedRuntimes.add(failedId);
+                if (!this.#isLive(failedId))
+                    this.#working.delete(failedId);
+                await this.#update(failedId, (current) => ({
+                    ...current,
+                    state: "error",
+                    interrupted: reason,
+                }));
+                this.#projectors.get(failedId)?.syncState("error");
+                return failure("spawn", reason, failedId, "error", [
+                    "registry record persisted",
+                    ...(uncertain ? ["runtime start or cleanup unconfirmed"] : ["no runtime remains"]),
+                ], !uncertain);
+            });
+            return failed;
         }
     }
     send(id, rawMessage, mode = "auto", signal) {
         const message = stripHindsightContent(rawMessage);
+        this.#bumpActivity(id);
         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 (record.intent === "stopped" || record.state === "error") {
+            if (record.intent === "stopped") {
                 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);
+                if (doubt !== undefined) {
+                    return failure("send", doubt, id, record.state, ["runtime metadata retained"], false);
+                }
             }
             let isResumed = false;
             // Deliverability is the bridge connection, minus a process that left the delegated session:
@@ -948,6 +1090,7 @@ export class SubagentManager {
                 const resumedRecord = await this.#update(id, (current) => ({
                     ...current,
                     state: "running",
+                    intent: "active",
                     persistence,
                     ...(sessionPath === undefined ? {} : { sessionPath }),
                     launchConfig: sessionPath === undefined
@@ -958,8 +1101,33 @@ export class SubagentManager {
                     this.#projectors.set(id, createStateProjector(resumedRecord.state));
                 }
                 try {
-                    await withDeadline(this.#start(resumedRecord), this.#deps.deadlineMs ?? 30_000);
+                    await withDeadline(this.#start(resumedRecord), this.#deps.deadlineMs ?? 60_000);
                     isResumed = true;
+                    if (this.#taskRegistry !== undefined) {
+                        try {
+                            this.#taskRegistry.create({
+                                id: resumedRecord.subagentId,
+                                type: "agent",
+                                purpose: `${resumedRecord.launchConfig.agent}: resumed task`,
+                                inlineResult: true,
+                                begin: () => ({
+                                    stop: () => {
+                                        void this.stop(resumedRecord.subagentId);
+                                    },
+                                    describe: () => ({
+                                        output: `Subagent ${resumedRecord.subagentId} (${resumedRecord.launchConfig.agent}) is running`,
+                                        truncated: false,
+                                    }),
+                                    consume: () => {
+                                        this.#deps.channel?.dismiss?.(resumedRecord.subagentId);
+                                    },
+                                }),
+                            });
+                        }
+                        catch (regError) {
+                            diagnose(`failed to renew background task for subagent ${resumedRecord.subagentId}: ${errorMessage(regError)}`);
+                        }
+                    }
                 }
                 catch (error) {
                     const reason = errorMessage(error);
@@ -1006,23 +1174,38 @@ export class SubagentManager {
                 return {
                     ...clean,
                     state: "running",
+                    intent: "active",
                     unacknowledgedInput: message,
                 };
             });
             try {
-                await this.#request(id, operation, { message });
+                const path = acknowledgedPath(await this.#request(id, operation, { message }));
+                this.#paths.set(id, path);
             }
             catch (error) {
                 return failure("send", errorMessage(error), id, pending.state, ["input persisted as unacknowledged before dispatch"], false);
             }
-            return publicChild((await this.#deps.registry.get(id)) ?? record, true);
+            return publicChild((await this.#deps.registry.get(id)) ?? pending, true, this.#paths.get(id));
         });
     }
     async get(id) {
         const record = await this.#deps.registry.get(id);
-        return record === undefined
-            ? failure("get", "Unknown child", id)
-            : publicChild(record, this.#isLive(id));
+        if (record === undefined)
+            return failure("get", "Unknown child", id);
+        const live = this.#isLive(id);
+        const projector = this.#projectors.get(id);
+        if (projector !== undefined) {
+            const snap = projector.snapshot();
+            const mergedRecord = {
+                ...record,
+                ...(snap.activeTool !== undefined ? { activeTool: snap.activeTool } : {}),
+                ...(snap.summary !== undefined ? { latestSummary: snap.summary } : {}),
+                ...(snap.interrupted !== undefined ? { interrupted: snap.interrupted } : {}),
+                usage: snap.usage ?? record.usage,
+            };
+            return publicChild(mergedRecord, live, this.#paths.get(id));
+        }
+        return publicChild(record, live, this.#paths.get(id));
     }
     async list() {
         const records = await this.#deps.registry.list();
@@ -1056,7 +1239,6 @@ export class SubagentManager {
                 stopped = await this.#update(id, (current) => ({
                     ...current,
                     intent: "stopped",
-                    state: "error",
                 }));
             }
             catch (error) {
@@ -1086,6 +1268,7 @@ export class SubagentManager {
                     // bridge-only stop.
                     const cleanup = await attachment.cleanup();
                     if (!(await this.#panelGone(attachment))) {
+                        await this.#update(id, (current) => ({ ...current, state: "error" })).catch(() => undefined);
                         return failure("stop", `The child's ${attachment.identity.host} panel is not confirmed gone (${cleanup.stderr || "its state could not be observed"}): the child process may still be running`, id, "error", ["stopped intent persisted", "runtime metadata retained"], true);
                     }
                     this.#attachments.delete(id);
@@ -1112,7 +1295,10 @@ export class SubagentManager {
                 if (current !== undefined) {
                     stopped = await this.#deps.registry.update(id, current.revision, (value) => {
                         const { runtime: _runtime, ...withoutRuntime } = value;
-                        return withoutRuntime;
+                        return {
+                            ...withoutRuntime,
+                            state: "done",
+                        };
                     });
                 }
                 if (this.#taskRegistry !== undefined) {
@@ -1176,7 +1362,6 @@ export class SubagentManager {
                 }
                 await this.#update(id, (current) => ({
                     ...current,
-                    intent: "stopped",
                     state: "error",
                     interrupted: message,
                 }));
@@ -1374,7 +1559,7 @@ export class SubagentManager {
             return;
         projector.applyEvent(event);
         let confirmedInput;
-        if (value.type === "agent_end") {
+        if (value.type === "turn_end" || value.type === "agent_end") {
             // A finished turn is exactly when the session file has the message, so this is where
             // unacknowledged input becomes part of the child's conversation.
             const entries = await this.#entries(id);