@evandu/super-pi 0.1.145 → 0.1.147

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

@@ -4,11 +4,13 @@ import { newSubagentRunId } from "../subagents.js";
 import { readAgents } from "../agents.js";
 import { verifyCapability } from "../capability.js";
 import { capText, validateWorkflowPlan, workflowSummary } from "../workflow.js";
-import { ensureNameIndex } from "../file-name-index.js";
-import { formatTurnFailure } from "../turn-failure.js";
+import { ensureNameIndex, recordWorkspacePath } from "../file-name-index.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";
+import { resolveSessionCwd } from "../session-cwd.js";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { randomUUID } from "node:crypto";
@@ -56,10 +58,38 @@ async function expandAtReferences(store, workspace, content) {
  * The envelope and the prose are NOT redundant: the envelope is what the reader sees in the transcript
  * column, what they cancel or reorder; the prose is what leaves the server for Pi.
  */
+/**
+ * THE TEXT THE MODEL IS HANDED WHEN A 后台回传 BECOMES ITS TURN.
+ *
+ * Pi's SDK has ONE entry point for a new turn - `session.prompt(text)` - and every text sent
+ * through it is a USER MESSAGE in Pi's transcript. There is no "the agent said this" channel to
+ * use. So a delivered result has to travel as prose, and the only question left is what that prose
+ * SAYS.
+ *
+ * IT USED TO SAY `[后台任务「...」已完成]`, which reads as a thing the PERSON said - a bracketed
+ * label, then the body, with nothing saying who is speaking. The model therefore answered it as a
+ * user would be answered ("已收到：[后台任务「...」]"), and the reader saw their own result coming
+ * back in the user's voice, inside the user's own turn. The delivery had become a quotation.
+ *
+ * So the prose now says WHO IS SPEAKING and that this is information, not an instruction:
+ * 「子会话「...」已完成，结果如下」. The model is told what happened and what it received, and it
+ * answers about THAT - which is what a primary agent should do with a child's result.
+ */
 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)) {
+        return `上级智能体下发的任务：\n\n${content}`;
+    }
     const summaryMatch = /<summary>([\s\S]*?)<\/summary>/.exec(content);
     const summary = summaryMatch ? summaryMatch[1].trim() : "后台任务";
     const stateMatch = /<task id="[^"]+" state="([^"]+)"/.exec(content);
@@ -74,7 +104,10 @@ function composePrompt(message) {
     const bodyMatch = /<task_(?:result|error)>\n?([\s\S]*)\n?<\/(?:task_result|task_error)>/.exec(content);
     const body = bodyMatch ? bodyMatch[1] : content;
     const stateLabel = state === "completed" ? "已完成" : state === "error" ? "失败" : state;
-    return `[后台任务「${summary}」${stateLabel}]\n\n${body}`;
+    // THE SPEAKER IS NAMED, AND IT IS NOT THE READER. A line that starts 「[」 looks like a note the
+    // person pasted in; a line that starts 「子会话」 or 「后台任务」 says the SYSTEM is reporting.
+    const speaker = /kind="session"/.test(content) ? "子会话" : "后台任务";
+    return `${speaker}「${summary}」${stateLabel}，结果如下：\n\n${body}`;
 }
 /**
  * Service managing execution of conversation turns, message queueing,
@@ -286,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();
             }
         })());
@@ -345,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.
      *
@@ -382,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();
@@ -563,9 +672,9 @@ export class RunService {
     /**
      * Resolves conversation and workspace working directory for subagent dispatch.
      */
-    dispatchContext(conversationId) {
+    async dispatchContext(conversationId) {
         const { conversation, workspace } = this.turnContext(conversationId);
-        return { conversation, cwd: workspace.path };
+        return { conversation, cwd: await resolveSessionCwd(workspace.path, conversation.cwd) };
     }
     /**
      * Checks whether a conversation has an active turn running.
@@ -663,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.
@@ -1205,13 +1325,15 @@ export class RunService {
             // does not exist.
             const relative = toWorkspaceRelative(workspace.path, path);
             tracker.record(workspace.id, relative, { root: workspace.path, conversationId: conversation.id });
-            refreshWorkspaceIndex(this.fileIndexes, workspace.id, relative);
+            refreshWorkspaceIndex(this.fileIndexes, workspace.id, relative, workspace.path);
             // The name index learns about the write as well, so the file the agent just created is
             // findable by name straight away rather than after the next background scan. It goes through
             // the SAME `ensureNameIndex` the HTTP layer uses, so there is one index per workspace rather
             // than one per layer.
-            if (this.nameIndexes)
-                ensureNameIndex(this.nameIndexes, workspace.id, workspace.path).upsert(relative);
+            if (this.nameIndexes) {
+                ensureNameIndex(this.nameIndexes, workspace.id, workspace.path);
+                recordWorkspacePath(this.nameIndexes, workspace.id, workspace.path, relative);
+            }
             if (toolCallId)
                 fileWritePaths.set(toolCallId, relative);
             this.broadcastFileChanges(workspace.id);
@@ -1294,9 +1416,11 @@ export class RunService {
             const writtenPath = call.id ? fileWritePaths.get(call.id) : undefined;
             if (writtenPath) {
                 this.fileChanges?.confirm(workspace.id, writtenPath, workspace.path);
-                refreshWorkspaceIndex(this.fileIndexes, workspace.id, writtenPath);
-                if (this.nameIndexes)
-                    ensureNameIndex(this.nameIndexes, workspace.id, workspace.path).upsert(writtenPath);
+                refreshWorkspaceIndex(this.fileIndexes, workspace.id, writtenPath, workspace.path);
+                if (this.nameIndexes) {
+                    ensureNameIndex(this.nameIndexes, workspace.id, workspace.path);
+                    recordWorkspacePath(this.nameIndexes, workspace.id, workspace.path, writtenPath);
+                }
                 if (call.id)
                     fileWritePaths.delete(call.id);
                 this.broadcastFileChanges(workspace.id);
@@ -1377,7 +1501,7 @@ export class RunService {
                 conversation,
                 prompt,
                 signal: controller.signal,
-                cwd: workspace.path,
+                cwd: await resolveSessionCwd(workspace.path, conversation.cwd),
                 host: {
                     notify: (request) => { if (acceptsEvent("ui.notify"))
                         uiHost.notify(request); },
@@ -1394,6 +1518,10 @@ export class RunService {
                     if (acceptsEvent("transcript.file", true))
                         await this.store.setConversationPiSessionFile(conversation.id, path);
                 },
+                onUsage: async (readout) => {
+                    if (acceptsEvent("usage", true))
+                        await this.store.recordConversationUsage(conversation.id, readout);
+                },
                 onToolCall,
                 onFileWrite,
                 onToolPreparing,
@@ -1551,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 (;;) {
@@ -1563,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
@@ -1570,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.
@@ -1608,6 +1763,90 @@ export class RunService {
     /**
      * Enqueues or starts execution for a user message.
      */
+    /**
+     * STARTS A TURN FROM A SENDER THAT IS NOT THE READER.
+     *
+     * `enqueueAndRun` below is the person's path: it writes the words under the reader's own name, in
+     * the reader's bubble, so the reader can see that they said it. The orchestrator's path is the
+     * same machinery with a different speaker - a primary agent handing a task to a child session -
+     * and writing THAT under the reader's name was the bug the reader reported: the child's
+     * transcript showed an instruction they never typed, wearing their avatar.
+     *
+     * So the write goes through `addAgentMessage` instead, which records the words as the system's,
+     * and the turn runs on them exactly as before. `composePrompt` is what tells the model who is
+     * speaking, so the model is addressed in the same words.
+     */
+    async enqueueAndRunAsAgent(conversationId, content) {
+        this.assertHistoryAvailable(conversationId);
+        this.memory?.cancel(conversationId);
+        const trimmed = content.trim();
+        if (!trimmed)
+            return;
+        const { conversation, workspace } = this.turnContext(conversationId);
+        const active = this.activeRuns.get(conversation.id);
+        if (active?.signal.aborted)
+            await this.awaitRunSlotReleased(conversation.id, false);
+        this.assertHistoryAvailable(conversationId);
+        const busy = this.activeRuns.has(conversation.id) || this.interruptTargets.has(conversation.id);
+        const reservedController = busy ? undefined : new AbortController();
+        if (reservedController) {
+            this.cancelledQuestionConversations.delete(conversation.id);
+            this.claimRunSlot(conversation.id, reservedController);
+        }
+        let message;
+        try {
+            message = await this.store.addAgentMessage(conversationId, trimmed, { ...(busy ? { delivery: "waiting" } : {}) });
+        }
+        catch (error) {
+            if (reservedController)
+                this.releaseRunSlot(conversation.id, reservedController);
+            throw error;
+        }
+        this.broadcaster.broadcastState();
+        if (!reservedController) {
+            const waiting = this.store.listWaitingMessages(conversationId).find((item) => item.id === message.id && item.delivery === "waiting");
+            if (!waiting)
+                return;
+            if (!this.activeRuns.has(conversationId) && !this.interruptTargets.has(conversationId))
+                await this.processWaitingMessage(conversationId, message.id);
+            else
+                await this.submitToPiQueue(conversationId, message);
+            return;
+        }
+        const controller = reservedController;
+        try {
+            if (controller.signal.aborted) {
+                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;
+            await this.store.setFailureReason(conversationId, formatTurnFailure(error));
+            console.error("Super Pi agent-dispatched turn failed:", describeThrownWithStack(error));
+            throw error;
+        }
+        finally {
+            this.releaseRunSlot(conversation.id, controller);
+            if (!this.activeRuns.has(conversation.id))
+                this.extensionUiService.cancelPendingUi(conversation.id, "expired");
+            this.broadcaster.broadcastState();
+        }
+    }
     async enqueueAndRun(conversationId, content, images, attachments, clientId) {
         this.assertHistoryAvailable(conversationId);
         /**
@@ -1696,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) {
@@ -1770,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;
@@ -1907,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);
         }
@@ -2004,7 +2257,7 @@ export class RunService {
         const task = params.task.trim();
         if (!task)
             throw new Error("子 agent 的任务不能为空");
-        const { conversation, cwd } = this.dispatchContext(params.conversationId);
+        const { conversation, cwd } = await this.dispatchContext(params.conversationId);
         void this.trackDetached(this.subagents.dispatch({
             conversationId: conversation.id,
             agentId: params.agentId,
@@ -2039,7 +2292,7 @@ export class RunService {
         if (body.depth !== undefined)
             checkSubagentDepth(body.depth);
         const signal = this.activeRuns.get(conversationId)?.signal;
-        const { conversation, cwd } = this.dispatchContext(conversationId);
+        const { conversation, cwd } = await this.dispatchContext(conversationId);
         const parent = body.parentRunId ? this.store.snapshot().subagentRuns.find((run) => run.id === body.parentRunId) : undefined;
         if (body.parentRunId && (!parent || parent.conversationId !== conversation.id)) {
             throw new Error("Invalid parentRunId: dispatch ancestry is not recorded for this conversation");
@@ -2100,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);
                         });
                     }
                 }
@@ -2109,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>`;
@@ -2126,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"}`);
             }));
@@ -2173,7 +2429,7 @@ export class RunService {
         const capability = this.verifyPrimaryCapability(conversationId, body.capability);
         if (!capability.ok)
             throw new Error(capability.message);
-        const { conversation, cwd } = this.dispatchContext(conversationId);
+        const { conversation, cwd } = await this.dispatchContext(conversationId);
         const signal = this.activeRuns.get(conversationId)?.signal;
         // Validated against the roster THIS CALL reads from disk, for the same freshness reason the task tool
         // builds its roster per turn: a sub-agent added while the server is running is dispatchable on the next

package/dist/server/application/scheduled-task-service.d.ts

@@ -98,7 +98,20 @@ export declare class ScheduledTaskService {
     update(id: string, input: ScheduledTaskInput): Promise<ScheduledTask>;
     /** Turns a task on or off. */
     setEnabled(id: string, enabled: boolean): Promise<ScheduledTask>;
-    /** Removes a task. Its conversation stays: it holds the answers the task produced. */
+    /**
+     * Removes a task. Its conversation is ARCHIVED, not deleted.
+     *
+     * THE ANSWERS ARE WORTH KEEPING, so the session is not thrown away - and archiving is the keeping
+     * that can be undone: the session moves into the sidebar's 已归档 group and can be restored from
+     * there. The old behaviour was to leave it in the LIVE list, and that was the defect: a 「定时：xxx」
+     * session with no task behind it is an orphan the reader cannot explain (there is no delete-session
+     * control at all) and cannot get rid of.
+     *
+     * THE DELETE ITSELF IS NEVER REFUSED. The task is removed first and the archive is best-effort: a
+     * conversation that is still running cannot be archived, and a reader who deletes a task must not be
+     * told "no" because a session happens to be busy. The session simply stays where it is, and the
+     * reason is in the server log rather than in the reader's face.
+     */
     remove(id: string): Promise<void>;
     /**
      * Runs a task NOW, once.

package/dist/server/application/scheduled-task-service.js

@@ -186,10 +186,35 @@ export class ScheduledTaskService {
             return task;
         return this.update(id, { enabled });
     }
-    /** Removes a task. Its conversation stays: it holds the answers the task produced. */
+    /**
+     * Removes a task. Its conversation is ARCHIVED, not deleted.
+     *
+     * THE ANSWERS ARE WORTH KEEPING, so the session is not thrown away - and archiving is the keeping
+     * that can be undone: the session moves into the sidebar's 已归档 group and can be restored from
+     * there. The old behaviour was to leave it in the LIVE list, and that was the defect: a 「定时：xxx」
+     * session with no task behind it is an orphan the reader cannot explain (there is no delete-session
+     * control at all) and cannot get rid of.
+     *
+     * THE DELETE ITSELF IS NEVER REFUSED. The task is removed first and the archive is best-effort: a
+     * conversation that is still running cannot be archived, and a reader who deletes a task must not be
+     * told "no" because a session happens to be busy. The session simply stays where it is, and the
+     * reason is in the server log rather than in the reader's face.
+     */
     async remove(id) {
-        this.require(id);
+        const task = this.require(id);
         await this.store.removeScheduledTask(id);
+        const conversationId = task.conversationId;
+        if (conversationId) {
+            const conversation = this.store.conversation(conversationId);
+            if (conversation && !conversation.archivedAt) {
+                try {
+                    await this.conversationService.archiveConversation(conversationId);
+                }
+                catch (error) {
+                    console.warn(`Super Pi: the deleted task's conversation ${conversationId} could not be archived:`, error instanceof Error ? error.message : String(error));
+                }
+            }
+        }
         this.broadcaster.broadcastState();
     }
     /**