@evandu/super-pi 0.1.146 → 0.1.147

package/dist/client/index.html

@@ -8,8 +8,8 @@
     <link rel="alternate icon" href="/favicon.ico" />
     <link rel="apple-touch-icon" href="/favicon.svg" />
     <title>Super Pi</title>
-    <script type="module" crossorigin src="/assets/index-E7yaLa2C.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-D-OxlUxN.css">
+    <script type="module" crossorigin src="/assets/index-Dzyp_7sf.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BMpqviwU.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/server/active-memory.d.ts

@@ -77,6 +77,23 @@ export declare class ActiveMemory {
         score: number;
         content: string;
     }[];
+    /**
+     * Rebuilds one conversation's postings after a rare destructive transcript mutation (revert/delete).
+     *
+     * WHY THIS EXISTS. The index is a CACHE of the store, and `removeFromIndex` is the surgical half of
+     * that contract: the caller tells it which ids LEFT, and exactly those postings go. This is the other
+     * half - it rebuilds what is there NOW. A destructive mutation can also change a message's CONTENT
+     * (a withdrawn turn replaced by a rewritten one), and a posting that still carries the old text
+     * answers a search with a turn the transcript no longer holds. So the rare path pays a full
+     * re-tokenize of ONE conversation, and the rest of the workspace stays indexed.
+     *
+     * THE REMOVAL LOOP WALKS EVERY WORKSPACE, because a posting remembers the conversation it came from:
+     * the conversation's terms must stop answering searches wherever they were indexed, not only in the
+     * workspace it lives in. The reverse index (`termsByMessage`) is pruned in the same loop, so the two
+     * halves of the index cannot disagree about which messages are indexed - a stale entry would point
+     * the surgical removal at terms that are no longer there.
+     */
+    syncConversation(conversation: Conversation): void;
     private ensureIndex;
     /**
      * Drops exactly the given messages from the search index, leaving the rest of the workspace indexed.

package/dist/server/active-memory.js

@@ -135,6 +135,41 @@ export class ActiveMemory {
                 void id, candidates.set(value.messageId, value);
         return [...candidates.values()].filter(m => !sessionId || m.conversationId === sessionId).map(m => ({ ...m, score: words.reduce((n, word) => n + (m.content.toLocaleLowerCase().includes(word) ? 1 : 0), 0) })).filter(m => m.score > 0).sort((a, b) => b.score - a.score).slice(0, 6).map(m => ({ ...m, content: m.content.slice(0, 1200) }));
     }
+    /**
+     * Rebuilds one conversation's postings after a rare destructive transcript mutation (revert/delete).
+     *
+     * WHY THIS EXISTS. The index is a CACHE of the store, and `removeFromIndex` is the surgical half of
+     * that contract: the caller tells it which ids LEFT, and exactly those postings go. This is the other
+     * half - it rebuilds what is there NOW. A destructive mutation can also change a message's CONTENT
+     * (a withdrawn turn replaced by a rewritten one), and a posting that still carries the old text
+     * answers a search with a turn the transcript no longer holds. So the rare path pays a full
+     * re-tokenize of ONE conversation, and the rest of the workspace stays indexed.
+     *
+     * THE REMOVAL LOOP WALKS EVERY WORKSPACE, because a posting remembers the conversation it came from:
+     * the conversation's terms must stop answering searches wherever they were indexed, not only in the
+     * workspace it lives in. The reverse index (`termsByMessage`) is pruned in the same loop, so the two
+     * halves of the index cannot disagree about which messages are indexed - a stale entry would point
+     * the surgical removal at terms that are no longer there.
+     */
+    syncConversation(conversation) {
+        for (const [, terms] of this.inverted) {
+            for (const [term, postings] of terms) {
+                for (const [messageId, value] of postings) {
+                    if (value.conversationId === conversation.id) {
+                        postings.delete(messageId);
+                        this.indexedMessages.delete(messageId);
+                        this.termsByMessage.delete(messageId);
+                    }
+                }
+                if (!postings.size)
+                    terms.delete(term);
+            }
+        }
+        if (!this.indexedWorkspaces.has(conversation.workspaceId))
+            return;
+        for (const message of conversation.messages)
+            this.addToIndex(conversation, message);
+    }
     ensureIndex(workspaceId) {
         if (this.indexedWorkspaces.has(workspaceId))
             return;
@@ -224,6 +259,10 @@ export class ActiveMemory {
                 terms.set(term, bucket = new Map());
             bucket.set(message.id, value);
         }
+        // THE MESSAGE IS IN THE INDEX NOW, SO THE SET MUST SAY SO. `completed()` walks this set to find
+        // the messages it has never indexed, and a message that is indexed without being marked here is
+        // re-tokenized on EVERY turn end - the whole-conversation cost this file exists to avoid.
+        this.indexedMessages.add(message.id);
     }
     async tool(token, body) {
         const identity = this.identity(token);

package/dist/server/application/conversation-service.js

@@ -435,6 +435,12 @@ export class ConversationService {
         const withdrawn = conversation.messages.find(item => item.id === messageId);
         const withdrawnContent = withdrawn ? { content: withdrawn.content, images: withdrawn.images } : undefined;
         const applied = await this.store.revertMessages(conversationId, messageId, withdraw);
+        // THE RECALL INDEX MUST SEE THE TRUNCATED TRANSCRIPT. `conversation` above is the DETACHED COPY
+        // that `turnContext` took BEFORE the store spliced its live array, so it still holds the withdrawn
+        // turns - re-syncing from it would put the text the person just withdrew straight back into the
+        // index, which is the exact leak this path exists to close. The store's post-revert conversation is
+        // the truth, and this rare destructive path is where one clone of it is the right price.
+        this.memory?.syncConversation(this.store.conversation(conversationId) ?? conversation);
         // THE MEMORY HALF OF THE REWIND, and the half that used to be missing. Everything above removes the
         // turn from Pi's file and from state.json; the memory store is a second durable copy of what the turn
         // said, and it is spliced into every later prompt. So the model kept being told about a turn the person

package/dist/server/application/run-service.d.ts

@@ -161,6 +161,15 @@ export declare class RunService {
         resultPath: string;
         error?: string;
     }): Promise<void>;
+    /**
+     * Dispatches a background result (exec or child session) into the conversation.
+     *
+     * IDLE: starts a fresh turn via `processWaitingMessage`.
+     * BUSY: attempts to steer the message into the running turn so it is delivered at the
+     *       very next tool batch boundary rather than waiting for the entire turn to complete.
+     * INTERRUPTING: quietly leaves the message waiting; the interrupted or next turn will pick it up.
+     */
+    private dispatchBackgroundResult;
     /**
      * Stops an active background task (spawned process or detached subagent) on user request.
      *
@@ -171,6 +180,8 @@ export declare class RunService {
      *    updates immediately.
      */
     stopBackgroundTask(taskId: string): Promise<void>;
+    hasActiveBackgroundTasks(conversationId: string): boolean;
+    settleBackgroundStatus(conversationId: string): Promise<void>;
     /** Per-conversation command lane.  All queue mutations and run claims use the same lane, so
      * two browser tabs cannot both observe an idle conversation and start duplicate turns. */
     private readonly conversationOps;
@@ -379,6 +390,11 @@ export declare class RunService {
      * stream it - which is why the two cases are expressed identically and cannot drift apart.
      */
     runConversationTurns(conversation: Conversation, workspace: Workspace, prompt: string, controller: AbortController, firstMessageId: string, initialImages?: MessageImage[]): Promise<void>;
+    /**
+     * Refuses a turn when the selected model cannot accept image input, either because the incoming
+     * message carries images or because previous messages in the conversation contain images.
+     */
+    private assertModelSupportsImages;
     /** Keep admission owned through final persistence and recheck the durable queue before releasing. */
     private runUntilDrained;
     /**

package/dist/server/application/run-service.js

@@ -5,7 +5,8 @@ import { readAgents } from "../agents.js";
 import { verifyCapability } from "../capability.js";
 import { capText, validateWorkflowPlan, workflowSummary } from "../workflow.js";
 import { ensureNameIndex, recordWorkspacePath } from "../file-name-index.js";
-import { formatTurnFailure } from "../turn-failure.js";
+import { formatTurnFailure, isLengthExceededError } from "../turn-failure.js";
+import { isLengthContinuation, lengthContinuationText } from "../length-continuation.js";
 import { describeThrownWithStack } from "../failure-text.js";
 import { toWorkspaceRelative } from "../files.js";
 import { refreshWorkspaceIndex } from "../file-index.js";
@@ -78,6 +79,12 @@ function composePrompt(message) {
     if (message.role !== "tool")
         return message.content;
     const content = message.content;
+    // A CONTINUATION ORDER IS NOT AN ORDER FROM A PARENT AGENT. It is the system telling the session
+    // to finish an answer that was cut short, and the model has to hear THAT - "here is a task you
+    // were given" would make it start the work over rather than finish what it had already said.
+    if (isLengthContinuation(content)) {
+        return `（上一条回答因达到输出长度上限被截断，请接着写完）\n\n${lengthContinuationText(content)}`;
+    }
     // A DISPATCHED ORDER IS NOT A DELIVERED RESULT. The two both travel as a `tool` message, and the
     // envelope tells them apart: a result carries `<task ...>`, an order does not.
     if (!/<task id="[^"]+" state="[^"]+"/.test(content)) {
@@ -312,20 +319,20 @@ export class RunService {
                 // "[后台任务 X 失败]" is part of the same "after the current answer finishes, the result is
                 // processed automatically" contract, and the auto-triggered turn goes through the same
                 // `composePrompt` path the success case does.
-                if (!this.activeRuns.has(task.conversationId) && !this.interruptTargets.has(task.conversationId)) {
-                    void this.processWaitingMessage(task.conversationId, queued.id).catch((error) => {
-                        console.warn(`Super Pi: auto-trigger for background exec result failed: ${error instanceof Error ? error.message : "unknown error"}`);
-                    });
-                }
-                // BUSY: the row stays in the waiting queue, and the turn that is running takes it when that
-                // turn ends - one message per turn, in the queue's own order. Nothing of a background result
-                // goes into Pi's follow-up queue any more.
+                //
+                // BUSY: steer the result into the running turn so Pi drains it at the very next tool batch
+                // boundary instead of waiting for the whole turn to complete.
+                void this.dispatchBackgroundResult(task.conversationId, queued.id).catch(async (error) => {
+                    console.warn(`Super Pi: dispatch background exec result failed: ${error instanceof Error ? error.message : "unknown error"}`);
+                    await this.settleBackgroundStatus(task.conversationId);
+                });
             }
             catch (error) {
                 console.warn(`Super Pi: exec result could not be appended as a tool message: ${error instanceof Error ? error.message : "unknown error"}`);
             }
             finally {
                 await this.store.removeBackgroundTask(sessionId);
+                await this.settleBackgroundStatus(task.conversationId);
                 this.broadcaster.broadcastState();
             }
         })());
@@ -371,13 +378,68 @@ export class RunService {
             });
             if (!queued)
                 return;
-            if (!this.activeRuns.has(parentId) && !this.interruptTargets.has(parentId)) {
-                void this.processWaitingMessage(parentId, queued.id).catch((error) => {
-                    console.warn(`Super Pi: auto-trigger for child session result failed: ${error instanceof Error ? error.message : "unknown error"}`);
-                });
-            }
+            void this.dispatchBackgroundResult(parentId, queued.id).catch((error) => {
+                console.warn(`Super Pi: dispatch child session result failed: ${error instanceof Error ? error.message : "unknown error"}`);
+            });
         })());
     }
+    /**
+     * Dispatches a background result (exec or child session) into the conversation.
+     *
+     * IDLE: starts a fresh turn via `processWaitingMessage`.
+     * BUSY: attempts to steer the message into the running turn so it is delivered at the
+     *       very next tool batch boundary rather than waiting for the entire turn to complete.
+     * INTERRUPTING: quietly leaves the message waiting; the interrupted or next turn will pick it up.
+     */
+    async dispatchBackgroundResult(conversationId, messageId) {
+        if (this.interruptTargets.has(conversationId))
+            return;
+        if (!this.activeRuns.has(conversationId)) {
+            await this.processWaitingMessage(conversationId, messageId);
+            return;
+        }
+        // Conversation is busy. Attempt to steer the background result directly into the active turn.
+        try {
+            // THE LANE IS RELEASED BEFORE THE FALLBACK. `processWaitingMessage` acquires this same lane,
+            // so calling it from inside the serialized callback re-enters the lane and deadlocks: the
+            // outer work waits for the inner one, and the inner one waits for the outer one.
+            const startWaiting = await this.serializeConversation(conversationId, async () => {
+                if (this.interruptTargets.has(conversationId))
+                    return false;
+                // `processWaitingMessage` acquires this lane, so the fallback must run after serialization exits.
+                if (!this.activeRuns.has(conversationId))
+                    return true;
+                if (!this.runtime.steer)
+                    return false;
+                if (this.runtime.canSteer && !this.runtime.canSteer(conversationId))
+                    return false;
+                const waiting = this.store.listWaitingMessages(conversationId);
+                const item = waiting.find((m) => m.id === messageId && m.delivery === "waiting");
+                if (!item)
+                    return false;
+                await this.moveAheadOfUnclaimed(conversationId, messageId);
+                this.broadcaster.broadcastState();
+                const claimed = await this.store.claimWaitingMessage(conversationId, messageId);
+                this.broadcaster.broadcastState();
+                try {
+                    await this.runtime.steer(conversationId, composePrompt(claimed), claimed.images);
+                }
+                catch (error) {
+                    await this.store.releaseWaitingMessage(conversationId, claimed.id);
+                    this.broadcaster.broadcastState();
+                    if (!(error instanceof SteerUnavailableError)) {
+                        console.warn(`Super Pi: steer background result failed: ${error instanceof Error ? error.message : "unknown error"}`);
+                    }
+                }
+                return false;
+            });
+            if (startWaiting)
+                await this.processWaitingMessage(conversationId, messageId);
+        }
+        catch (error) {
+            console.warn(`Super Pi: steer background result failed: ${error instanceof Error ? error.message : "unknown error"}`);
+        }
+    }
     /**
      * Stops an active background task (spawned process or detached subagent) on user request.
      *
@@ -408,8 +470,29 @@ export class RunService {
             }
         }
         await this.store.removeBackgroundTask(taskId);
+        if (task?.conversationId) {
+            await this.settleBackgroundStatus(task.conversationId);
+        }
         this.broadcaster.broadcastState();
     }
+    hasActiveBackgroundTasks(conversationId) {
+        const tasks = this.store.snapshot().backgroundTasks ?? [];
+        return tasks.some((t) => t.conversationId === conversationId && (t.status === "running" || !t.status));
+    }
+    async settleBackgroundStatus(conversationId) {
+        const conv = this.store.conversation(conversationId);
+        if (!conv || conv.status !== "awaiting_background")
+            return;
+        if (this.activeRuns.has(conversationId))
+            return;
+        if (this.hasActiveBackgroundTasks(conversationId))
+            return;
+        const hasWaiting = this.store.listWaitingMessages(conversationId).some(m => m.delivery === "waiting");
+        if (!hasWaiting) {
+            await this.store.setStatus(conversationId, "completed");
+            this.broadcaster.broadcastState();
+        }
+    }
     /** Per-conversation command lane.  All queue mutations and run claims use the same lane, so
      * two browser tabs cannot both observe an idle conversation and start duplicate turns. */
     conversationOps = new Map();
@@ -689,6 +772,17 @@ export class RunService {
         // the SDK's five-second backstop. Do this before any await so a stale stop cannot reach new work.
         this.subagents.stopConversation(conversationId);
         this.workflows.stopConversation(conversationId);
+        const bgTasks = (this.store.snapshot().backgroundTasks ?? []).filter(t => t.conversationId === conversationId);
+        for (const task of bgTasks) {
+            if (this.execService) {
+                try {
+                    this.execService.kill(task.id);
+                }
+                catch { /* ignore if already exited */ }
+            }
+            this.subagents.stop(task.id);
+            await this.store.removeBackgroundTask(task.id);
+        }
         // Cancel human-facing waits BEFORE asking Pi to become idle. A session can be blocked inside an
         // extension UI bridge or the question tool; Pi's idle promise cannot settle until that wait is
         // released, so cancelling after `runtime.stop()` turns a click into the full idle backstop.
@@ -1585,6 +1679,7 @@ export class RunService {
         try {
             const agent = await this.runtime.agentFor?.(conversation);
             const identity = agent ? { id: agent.id, name: agent.name } : { name: "Pi" };
+            await this.assertModelSupportsImages(conversation, Boolean(initialImages?.length), firstMessageId);
             const opened = await this.openTurn(conversation.id, firstMessageId);
             await this.streamTurn(conversation, workspace, prompt, opened.assistant, controller, opened.user.id, initialImages, identity);
             for (;;) {
@@ -1597,6 +1692,7 @@ export class RunService {
                 // answers them with a turn of their own, which is the behaviour there was before Pi's queue was
                 // used at all. Nothing is lost, and nothing is delivered twice.
                 await this.clearPiQueues(conversation.id);
+                await this.store.releaseSendingMessages(conversation.id);
                 // Taken AND opened, in that order, by two separate writes. The take is what bounds this loop -
                 // every pass strictly shrinks the waiting set - and it is what makes a crash honest, because a
                 // server that dies between the two has a message that is neither waiting nor answered, and the
@@ -1604,24 +1700,49 @@ export class RunService {
                 const next = await this.store.takeNextWaitingMessage(conversation.id);
                 if (!next)
                     break;
+                const current = this.turnContext(conversation.id).conversation;
+                await this.assertModelSupportsImages(current, Boolean(next.images?.length), next.id);
                 const followUp = await this.store.openTurnOnMessage(conversation.id, next.id, identity);
                 this.broadcaster.broadcastState();
-                const current = this.turnContext(conversation.id).conversation;
+                const activeConversation = this.turnContext(conversation.id).conversation;
                 // `composePrompt` synthesises the prose for a 后台回传 (the `<task>` envelope is what the transcript
                 // column reads from; the prose is what leaves the server for Pi). For user messages it is a no-op.
-                await this.streamTurn(current, workspace, composePrompt(next), followUp.assistant, controller, followUp.user.id, next.images, identity);
+                await this.streamTurn(activeConversation, workspace, composePrompt(next), followUp.assistant, controller, followUp.user.id, next.images, identity);
             }
         }
         finally {
             await this.store.releaseSendingMessages(conversation.id);
         }
     }
+    /**
+     * Refuses a turn when the selected model cannot accept image input, either because the incoming
+     * message carries images or because previous messages in the conversation contain images.
+     */
+    async assertModelSupportsImages(conversation, currentTurnHasImages, excludingMessageId) {
+        const hasHistoryImages = conversation.messages.some((m) => m.id !== excludingMessageId && Boolean(m.images && m.images.length > 0));
+        if (!currentTurnHasImages && !hasHistoryImages)
+            return;
+        const catalog = await this.runtime.catalog(conversation.model);
+        const currentModel = catalog.models.find((model) => model.provider === conversation.model?.provider && model.modelId === conversation.model?.modelId)
+            ?? catalog.models.find((m) => m.provider === catalog.defaultModel?.provider && m.modelId === catalog.defaultModel?.modelId);
+        if (currentModel && !currentModel.imageInput) {
+            if (currentTurnHasImages) {
+                throw new Error(`当前选择的模型「${currentModel.label || currentModel.modelId}」不支持图片输入`);
+            }
+            throw new Error(`会话历史包含图片，当前模型「${currentModel.label || currentModel.modelId}」不支持图片输入；请切回支持图文的模型继续对话`);
+        }
+    }
     /** Keep admission owned through final persistence and recheck the durable queue before releasing. */
     async runUntilDrained(conversation, workspace, prompt, controller, messageId, images) {
         for (;;) {
             if (!controller.signal.aborted)
                 await this.runConversationTurns(conversation, workspace, prompt, controller, messageId, images);
-            await this.store.setStatus(conversation.id, controller.signal.aborted ? "stopped" : "completed");
+            // The `runConversationTurns` loop above drains every waiting message before returning, so a
+            // turn that ends with `hasBg` true really is idle - it is waiting on a background task, not
+            // about to start another turn.
+            const hasBg = this.hasActiveBackgroundTasks(conversation.id);
+            const finalStatus = controller.signal.aborted ? "stopped" : hasBg ? "awaiting_background" : "completed";
+            await this.store.setStatus(conversation.id, finalStatus);
             if (controller.signal.aborted)
                 return;
             // No await between the last empty observation and releasing the slot.
@@ -1698,9 +1819,20 @@ export class RunService {
                 await this.store.setStatus(conversation.id, "stopped");
                 return;
             }
+            await this.assertModelSupportsImages(conversation, false, message.id);
             await this.runUntilDrained(conversation, workspace, composePrompt(message), controller, message.id);
         }
         catch (error) {
+            // A TRUNCATED ANSWER IS NOT A DEAD CHILD. The model filled its single-response output budget
+            // and stopped mid-sentence; the work it was doing is not over. The conversation goes back to
+            // `idle` - usable, not failed - and the truncation is recorded as a WARNING, so the orchestrator
+            // above can see that the child needs to be told to carry on rather than reported as broken.
+            if (isLengthExceededError(error)) {
+                await this.store.setStatus(conversation.id, "idle");
+                await this.store.setWarningReason(conversationId, formatTurnFailure(error));
+                console.warn("Super Pi agent-dispatched turn was truncated by the output limit:", describeThrownWithStack(error));
+                throw error;
+            }
             await this.store.setStatus(conversation.id, controller.signal.aborted ? "stopped" : "failed");
             if (controller.signal.aborted)
                 return;
@@ -1803,14 +1935,8 @@ export class RunService {
             }
             let expanded;
             try {
-                if (validImages?.length) {
-                    const catalog = await this.runtime.catalog(conversation.model);
-                    const currentModel = catalog.models.find((model) => model.provider === conversation.model?.provider && model.modelId === conversation.model?.modelId)
-                        ?? catalog.models.find((m) => m.provider === catalog.defaultModel?.provider && m.modelId === catalog.defaultModel?.modelId);
-                    if (currentModel && !currentModel.imageInput) {
-                        throw new Error(`当前选择的模型「${currentModel.label || currentModel.modelId}」不支持图片输入`);
-                    }
-                }
+                const currentConv = this.turnContext(conversationId).conversation;
+                await this.assertModelSupportsImages(currentConv, Boolean(validImages?.length), message.id);
                 expanded = await expandAtReferences(this.store, workspace, trimmed);
             }
             catch (error) {
@@ -1877,6 +2003,25 @@ export class RunService {
             if (error?.__superPiPreflight) {
                 throw error;
             }
+            // A TRUNCATED ANSWER IS NOT A FAILED TURN. The model filled its single-response output budget
+            // and stopped mid-sentence: everything it said is on screen, and the conversation is still
+            // usable - the reader's next move is to let it carry on, not to retry from scratch.
+            //
+            // So the conversation goes back to `idle` rather than `failed`, and the fact that the answer
+            // was cut short is recorded as a WARNING. Marking it `failed` is what made an orchestrated
+            // child session die: the orchestrator read the status, told the parent the task had failed,
+            // and a task that was one turn from done was thrown away.
+            //
+            // AND THE TURN DOES NOT THROW. The reader's message WAS accepted and WAS answered - partially.
+            // Throwing here would tell the browser the send failed, and the browser's response to a failed
+            // send is to offer a retry, which is the wrong move: retrying asks for the same answer again
+            // instead of asking for the rest of this one.
+            if (isLengthExceededError(error)) {
+                await this.store.setStatus(conversation.id, "idle");
+                await this.store.setWarningReason(conversation.id, formatTurnFailure(error));
+                console.warn("Super Pi turn was truncated by the output limit:", describeThrownWithStack(error));
+                return;
+            }
             await this.store.setStatus(conversation.id, controller.signal.aborted ? "stopped" : "failed");
             if (controller.signal.aborted)
                 return;
@@ -2014,6 +2159,7 @@ export class RunService {
             const message = conversation.messages.find((item) => item.id === messageId);
             if (!message)
                 throw new Error("消息不存在或已被撤回");
+            await this.assertModelSupportsImages(conversation, Boolean(message.images?.length), message.id);
             // runConversationTurns opens this first message; do not create a second assistant placeholder.
             await this.runUntilDrained(conversation, workspace, composePrompt(message), controller, message.id, message.images);
         }
@@ -2207,8 +2353,9 @@ export class RunService {
                         return row;
                     });
                     if (!signal?.aborted && run.status !== "stopped" && !this.activeRuns.has(conversation.id) && !this.interruptTargets.has(conversation.id)) {
-                        void this.processWaitingMessage(conversation.id, queued.id).catch((error) => {
+                        void this.processWaitingMessage(conversation.id, queued.id).catch(async (error) => {
                             console.warn(`Super Pi: auto-trigger for background sub-agent result failed: ${error instanceof Error ? error.message : "unknown error"}`);
+                            await this.settleBackgroundStatus(conversation.id);
                         });
                     }
                 }
@@ -2216,6 +2363,7 @@ export class RunService {
                     console.warn(`Super Pi: sub-agent result could not be appended as a tool message: ${error instanceof Error ? error.message : "unknown error"}`);
                 }
                 await this.store.removeBackgroundTask(run.id);
+                await this.settleBackgroundStatus(conversation.id);
                 this.broadcaster.broadcastState();
             }).catch(async (error) => {
                 const message = `<task id="${backgroundId}" state="error" kind="subagent">\n<summary>Background task failed: ${body.description?.trim() || subagentType}</summary>\n<task_error>Background task failed before completion: ${error instanceof Error ? error.message : "unknown error"}</task_error>\n</task>`;
@@ -2233,6 +2381,7 @@ export class RunService {
                     console.warn(`Super Pi: sub-agent failure could not be appended as a tool message: ${innerError instanceof Error ? innerError.message : "unknown error"}`);
                 }
                 await this.store.removeBackgroundTask(backgroundId);
+                await this.settleBackgroundStatus(conversationId);
                 this.broadcaster.broadcastState();
                 console.warn(`Super Pi: background sub-agent dispatch failed: ${error instanceof Error ? error.message : "unknown error"}`);
             }));

package/dist/server/application/session-orchestrator-service.d.ts

@@ -4,8 +4,18 @@ import type { RunService } from "./run-service.js";
 import type { SessionLedger } from "../session-ledger.js";
 import type { EventBroadcaster } from "../server-context.js";
 import type { RunStatus } from "../types.js";
+import { SessionWatchdog } from "./session-watchdog.js";
 export declare const SESSION_OUTPUT_CHAR_LIMIT: number;
 export declare const sessionResultRelativePath: (conversationId: string) => string;
+/**
+ * HOW MANY TIMES A CHILD MAY BE TOLD TO CONTINUE AFTER ITS OUTPUT WAS TRUNCATED.
+ *
+ * The bound is not about tokens - it is about a model that truncates on EVERY response. Three
+ * continuations cover the ordinary case (a long answer split across a few responses) and stop the
+ * pathological one. Past the bound the child is reported as unfinished, which is a true sentence
+ * about what happened, instead of a loop that never ends.
+ */
+export declare const MAX_LENGTH_CONTINUATIONS = 3;
 export interface SpawnSessionOptions {
     /** The high-level task to be performed by the sibling session. */
     task: string;
@@ -33,6 +43,18 @@ export interface SpawnSessionOptions {
     initialPrompt?: string;
     /** Whether to await turn completion before returning (default: false, asynchronous dispatch). */
     wait?: boolean;
+    /** Optional silence watchdog timeout in seconds. If set, parent is reminded if child goes quiet for this duration. */
+    watchdogTimeoutSeconds?: number;
+}
+export interface ReportSessionOptions {
+    /** The report content (milestone, findings, roadblock, or final output). */
+    content: string;
+    /**
+     * The status of the child session when reporting.
+     * "in_progress" (default): interim update; resets the watchdog timer.
+     * "completed" | "failed": terminal update; cancels the watchdog timer.
+     */
+    status?: "in_progress" | "completed" | "failed";
 }
 export interface StopSessionOptions {
     /** Stop mode: "active" (active turn), "queued" (waiting messages in queue), or "all" (both, default). */
@@ -77,7 +99,35 @@ export declare class SessionOrchestratorService {
     private readonly runService;
     private readonly ledger;
     private readonly broadcaster?;
-    constructor(store: Store, conversationService: ConversationService, runService: RunService, ledger: SessionLedger, broadcaster?: EventBroadcaster | undefined);
+    readonly watchdog: SessionWatchdog;
+    /**
+     * HOW MANY TIMES EACH CHILD HAS BEEN TOLD TO CONTINUE AFTER A TRUNCATION.
+     *
+     * Per child rather than per dispatch, so a child that is given several tasks cannot extend itself
+     * indefinitely by being handed a new task each time it runs out of output budget. The entry is
+     * dropped as soon as the child finishes, so a child that continues successfully starts fresh on
+     * its next task.
+     */
+    private readonly lengthContinuations;
+    /**
+     * THE CHILDREN THAT HAVE ALREADY REPORTED THEIR OWN RESULT TO THEIR PARENT.
+     *
+     * A child can report explicitly - the `report` action - and that report is the child's own
+     * statement of what it did. When the child's turn then ends, the automatic completion report
+     * would deliver the same thing a second time, so the automatic path steps aside for a child that
+     * is in this set.
+     *
+     * The entry is added only by a TERMINAL report (`completed` / `failed`), because an interim
+     * update is not the child's final word: the task is still running, and the parent will want to
+     * hear how it ended.
+     */
+    private readonly reportedChildren;
+    constructor(store: Store, conversationService: ConversationService, runService: RunService, ledger: SessionLedger, broadcaster?: EventBroadcaster | undefined, watchdog?: SessionWatchdog);
+    /**
+     * The watchdog timer fired: the child has been silent for longer than the parent declared.
+     * Delivers a reminder message to the parent session. Does NOT interrupt or abort the child session.
+     */
+    private handleWatchdogTimeout;
     /**
      * Spawns a new sibling conversation and immediately dispatches its initial task.
      */
@@ -93,6 +143,58 @@ export declare class SessionOrchestratorService {
     }): Promise<{
         conversationId: string;
     }>;
+    /**
+     * THE CHILD'S OUTPUT WAS CUT OFF. TELL IT TO CARRY ON, AND LET IT.
+     *
+     * This is the recovery for a length stop, and it exists because a truncated answer is not a
+     * finished one. The child has already said most of what it had to say - that text is on its
+     * transcript - so the work left to do is the tail of the answer, not the whole of it.
+     *
+     * WHY THE CONTINUATION IS A NEW TURN RATHER THAN A RESUME OF THE SAME ONE. Pi has already settled
+     * the turn that was truncated: the model stopped, the message was written, the run ended. There is
+     * no live turn to resume, so the only way to get more output is to ask again - and asking again in
+     * the SAME conversation is what makes the continuation work, because the child's own partial
+     * answer is in its context and the model can see exactly where it stopped.
+     *
+     * WHY IT IS AN AGENT-SENT ORDER RATHER THAN A USER MESSAGE. The person never typed this, and the
+     * child's transcript must not show words under their name that they never said - the same reason
+     * `dispatch` uses `enqueueAndRunAsAgent` in the first place.
+     *
+     * Returns true when the child was continued (and the caller must NOT report a failure), and false
+     * when the continuation could not be made or the bound was reached - in which case the caller
+     * reports the original failure, which is then the honest description of what happened.
+     */
+    private continueAfterLengthStop;
+    /**
+     * Explicit report from a child session to its direct parent.
+     * Can be called multiple times at any point during execution.
+     */
+    report(childConversationId: string, options: ReportSessionOptions): Promise<{
+        delivered: boolean;
+        parentConversationId: string;
+    }>;
+    /**
+     * Sets or updates a silence watchdog timer on a child session.
+     */
+    setWatchdog(options: {
+        childConversationId: string;
+        parentConversationId: string;
+        timeoutSeconds: number;
+    }): Promise<{
+        ok: boolean;
+        childConversationId: string;
+        timeoutSeconds: number;
+    }>;
+    /**
+     * Cancels a silence watchdog timer on a child session.
+     */
+    cancelWatchdog(childConversationId: string): Promise<{
+        ok: boolean;
+    }>;
+    /**
+     * Re-arms persisted watchdogs from disk.
+     */
+    restoreWatchdogs(): Promise<void>;
     private persistSessionResult;
     /**
      * Returns a high-level summary of a session's progress without returning full transcripts.