@evandu/super-pi 0.1.138 → 0.1.140

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

@@ -7,6 +7,8 @@ import { validateWorkflowPlan, workflowSummary } from "../workflow.js";
 import { ensureNameIndex } from "../file-name-index.js";
 import { formatTurnFailure } from "../turn-failure.js";
 import { describeThrownWithStack } from "../failure-text.js";
+import { toWorkspaceRelative } from "../files.js";
+import { refreshWorkspaceIndex } from "../file-index.js";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 const execFileAsync = promisify(execFile);
@@ -86,6 +88,8 @@ export class RunService {
     agentsDir;
     workflows;
     questionWaiters = new Map();
+    /** A stop can race a late question callback; remember the stopped turn so it cannot park forever. */
+    cancelledQuestionConversations = new Set();
     memory;
     setMemory(memory) { this.memory = memory; }
     /**
@@ -111,6 +115,21 @@ export class RunService {
             this.memory?.review(conversation);
     }
     activeRuns = new Map();
+    historyCutClaims = new Map();
+    holdHistoryCut(conversationId) {
+        this.historyCutClaims.set(conversationId, (this.historyCutClaims.get(conversationId) ?? 0) + 1);
+    }
+    releaseHistoryCut(conversationId) {
+        const count = this.historyCutClaims.get(conversationId) ?? 0;
+        if (count <= 1)
+            this.historyCutClaims.delete(conversationId);
+        else
+            this.historyCutClaims.set(conversationId, count - 1);
+    }
+    assertHistoryAvailable(conversationId) {
+        if (this.historyCutClaims.has(conversationId))
+            throw new Error("正在撤回上一条消息，Pi 的历史还没截断完成，请等撤回结束后再发送。");
+    }
     /**
      * The completion of the run currently holding a conversation's slot.
      *
@@ -130,7 +149,14 @@ export class RunService {
         this.activeRuns.set(conversationId, controller);
     }
     /** Releases the run slot and settles its completion promise, so a waiter wakes on the SAME instruction. */
-    releaseRunSlot(conversationId) {
+    releaseRunSlot(conversationId, expectedController) {
+        // Ownership matters even on cleanup: a delayed finally MUST NOT delete a newer turn's slot or
+        // resolve its completion promise. Only the run that claimed the slot may release it.
+        const current = this.activeRuns.get(conversationId);
+        if (expectedController && current !== expectedController)
+            return;
+        if (!current)
+            return;
         this.activeRuns.delete(conversationId);
         this.runCompletions.get(conversationId)?.resolve();
         this.runCompletions.delete(conversationId);
@@ -294,6 +320,7 @@ export class RunService {
             }
             catch { /* ignore if already exited */ }
         }
+        this.subagents.stop(taskId);
         if (task && task.originMessageId !== undefined && task.originCallRow !== undefined) {
             const conv = this.store.snapshot().conversations.find((c) => c.id === task.conversationId);
             const msg = conv?.messages.find((m) => m.id === task.originMessageId);
@@ -367,6 +394,7 @@ export class RunService {
             },
         });
         this.broadcaster.broadcast({ type: "message.tools", conversationId: command.conversationId, messageId: command.messageId, toolCalls: calls });
+        this.broadcaster.broadcastState();
         this.settleQuestion(command.conversationId, command.messageId, command.callIndex, calls[command.callIndex]?.question);
     }
     questionKey(conversationId, messageId, index) {
@@ -392,6 +420,15 @@ export class RunService {
         else
             waiter.reject(new Error("用户没有回答这个问题"));
     }
+    cancelQuestionWaiters(conversationId) {
+        const reason = new Error("用户已停止当前回合，问题未回答");
+        for (const [key, waiter] of [...this.questionWaiters]) {
+            if (!key.startsWith(`${conversationId}\0`))
+                continue;
+            this.questionWaiters.delete(key);
+            waiter.reject(reason);
+        }
+    }
     /**
      * THE `question` TOOL BLOCKS HERE, ON THE CALL THAT ASKED IT.
      *
@@ -409,6 +446,11 @@ export class RunService {
      * backfilled with `options[0]`.
      */
     async askQuestion(conversationId) {
+        // The HTTP callback belongs to the run that admitted it. A stop followed by a new turn clears
+        // the conversation's cancellation marker, but must never let an old polling ask bind its row.
+        const owner = this.activeRuns.get(conversationId);
+        const cancelled = () => this.cancelledQuestionConversations.has(conversationId)
+            || owner?.signal.aborted === true || this.activeRuns.get(conversationId) !== owner;
         // THE ROW ARRIVES AFTER THE REQUEST, AND THAT IS A RACE, NOT A BUG IN THE CALLER.
         //
         // The extension lives INSIDE the Pi process. When Pi starts running the tool it writes
@@ -422,6 +464,8 @@ export class RunService {
         // genuinely has no pending call still fails - just not instantly.
         let found;
         for (let attempt = 0; attempt < 50 && !found; attempt += 1) {
+            if (cancelled())
+                throw new Error("用户已停止当前回合，问题未回答");
             found = this.store.pendingQuestion(conversationId);
             if (found)
                 break;
@@ -429,6 +473,8 @@ export class RunService {
         }
         if (!found)
             throw new Error("这个会话里没有正在等待回答的 question 工具调用");
+        if (cancelled())
+            throw new Error("用户已停止当前回合，问题未回答");
         const { messageId, index } = found;
         return new Promise((resolve, reject) => {
             // No timeout. The promise resolves when the question is answered, rejects when it is cancelled
@@ -436,6 +482,10 @@ export class RunService {
             // continuing from a question that was never decided). The run-level teardown (stop / abort /
             // shutdown) clears the underlying ask and the client settles it as cancelled, which lands here
             // and rejects. A question that is simply unanswered waits indefinitely.
+            if (cancelled()) {
+                reject(new Error("用户已停止当前回合，问题未回答"));
+                return;
+            }
             this.questionWaiters.set(this.questionKey(conversationId, messageId, index), { resolve, reject });
         });
     }
@@ -473,6 +523,11 @@ export class RunService {
     isRunning(conversationId) {
         return this.activeRuns.has(conversationId);
     }
+    /** Returns true while a stop has been requested and the old producer is still unwinding. */
+    isStopping(conversationId) {
+        // Use the same identity as the slot; a separate conversation-keyed flag can leak across owners.
+        return this.activeRuns.get(conversationId)?.signal.aborted === true;
+    }
     /**
      * Checks the session credential together with the application-level turn truth.
      *
@@ -482,7 +537,8 @@ export class RunService {
      * left HTTP-only paths with no owner at all.
      */
     verifyPrimaryCapability(conversationId, capability) {
-        return verifyCapability(conversationId, capability, { running: this.isRunning(conversationId) });
+        const controller = this.activeRuns.get(conversationId);
+        return verifyCapability(conversationId, capability, { running: Boolean(controller && !controller.signal.aborted) });
     }
     /**
      * Aborts all active conversation runs and sub-agents.
@@ -539,50 +595,85 @@ export class RunService {
     async stopRun(conversationId) {
         // Abort immediately before waiting for the conversation lane; otherwise a stop queued behind a
         // long streaming command could never reach the controller that it is meant to cancel.
-        this.activeRuns.get(conversationId)?.abort();
+        const controller = this.activeRuns.get(conversationId);
+        controller?.abort();
         this.broadcaster.broadcast({ type: "run.stopping", conversationId });
-        await this.runtime.stop?.(conversationId);
-        return this.serializeConversation(conversationId, () => this.stopRunUnsafe(conversationId));
+        // A synchronous task tool can be waiting for its child HTTP response. Stop children and plans
+        // before awaiting the parent's idle promise, otherwise parent and child wait on each other until
+        // 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);
+        // 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.
+        await this.cancelPendingRunInteractions(conversationId);
+        // Persisting cancelled question rows yields to other commands. The old turn can finish and a
+        // new one can claim its slot during that await; runtime.stop looks up the CURRENT SDK turn by id,
+        // so calling it unconditionally here would abort the new turn on behalf of the old stop click.
+        if (this.activeRuns.get(conversationId) === controller)
+            await this.runtime.stop?.(conversationId);
+        return this.serializeConversation(conversationId, () => this.stopRunUnsafe(conversationId, controller));
     }
-    async stopRunUnsafe(conversationId) {
+    /** Releases waits that can prevent Pi's abort from reaching its idle state. Idempotent by design. */
+    async cancelPendingRunInteractions(conversationId) {
+        this.cancelledQuestionConversations.add(conversationId);
+        this.cancelQuestionWaiters(conversationId);
         this.memory?.cancel(conversationId);
         this.extensionUiService.cancelPendingUi(conversationId, "aborted");
+        // Read only this conversation. The old full-state snapshot cloned every historical transcript before
+        // the stop could even settle its pending questions.
+        await Promise.all(this.store.pendingQuestions(conversationId).map(async (pending) => {
+            try {
+                const calls = await this.store.updateToolCall(conversationId, pending.messageId, pending.index, { question: { items: pending.question.items, status: "cancelled" } });
+                this.broadcaster.broadcast({ type: "message.tools", conversationId, messageId: pending.messageId, toolCalls: calls });
+                this.broadcaster.broadcastState();
+                this.settleQuestion(conversationId, pending.messageId, pending.index, calls[pending.index]?.question);
+            }
+            catch (error) {
+                console.warn(`Super Pi: could not cancel pending question for ${conversationId}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }));
+    }
+    async stopRunUnsafe(conversationId, expectedController) {
+        // A newer turn may have claimed this conversation while the old SDK session was draining. Its
+        // pending question belongs to the new turn and must never be cancelled by the stale stop.
+        // The first cancellation happens at stop arrival, before waiting for Pi idle. Keep this call here
+        // as an idempotent safety net for callers that enter the serialized cleanup directly. If a new run
+        // has claimed the slot while the old stop was waiting, this cleanup belongs to the old controller and
+        // must not cancel the new run's questions or stamp its conversation stopped.
+        const currentAtEntry = this.activeRuns.get(conversationId);
+        // A stop captured no controller (for example, the old run released just before the click) must
+        // never cancel a newer run that appeared while its command was in flight. The no-active case is
+        // still allowed through for cleanup of a pending question fixture/HTTP ask with no slot owner.
+        if (!expectedController && currentAtEntry)
+            return;
+        if (expectedController && currentAtEntry && currentAtEntry !== expectedController)
+            return;
+        await this.cancelPendingRunInteractions(conversationId);
         // THE `question` TOOL IS A PENDING ASK THE STOP MUST SETTLE, not a client-only state. Its row only
         // ever leaves `pending` through the user's `question.answer` command, so a stop used to leave the
         // ask waiting forever: the extension's HTTP handler never returned, the ask's 250ms full-snapshot
         // poll never cleared, and the card stayed interactive on a dead turn (measured by
         // scripts/question-stop.test.mjs). The same settlement the Extension UI channel gets from
         // `cancelPendingUi` above - answered `cancelled`, never a default - applied to the question rows.
-        const stopped = this.store.snapshot().conversations.find((item) => item.id === conversationId);
-        for (const message of stopped?.messages ?? []) {
-            for (let index = 0; index < (message.toolCalls?.length ?? 0); index += 1) {
-                const question = message.toolCalls?.[index]?.question;
-                if (question?.status !== "pending")
-                    continue;
-                const calls = await this.store.updateToolCall(conversationId, message.id, index, { question: { items: question.items, status: "cancelled" } });
-                this.broadcaster.broadcast({ type: "message.tools", conversationId, messageId: message.id, toolCalls: calls });
-                this.settleQuestion(conversationId, message.id, index, calls[index]?.question);
-            }
-        }
-        if (this.subagents.stopConversation(conversationId)) {
-            console.log(`Super Pi: stopped the sub-agent runs of conversation ${conversationId}.`);
-        }
-        // Plans too, and separately: a plan's own loop holds the signal that reaches its current child, so
-        // stopping only the runs would let it dispatch the NEXT step a moment later. Reported on its own line
-        // because a person who pressed stop wants to know a plan was still marching, not just a card.
-        if (this.workflows.stopConversation(conversationId)) {
-            console.log(`Super Pi: stopped the running orchestration plans of conversation ${conversationId}.`);
-        }
         // AWAIT RUN SLOT RELEASE BEFORE CLAIMING "STOPPED".
         // A stop previously called setStatus("stopped") immediately, while activeRuns still held the
         // conversation slot and the streaming lane was still draining. This produced the contradiction:
         // the UI displayed 「已停止」 and offered 「发送」, but sending a new message hit an active
         // run slot and was falsely placed into 「排队中」, while the previous turn might still produce text.
         await this.awaitRunSlotReleased(conversationId, false, 3_000);
-        if (this.activeRuns.has(conversationId)) {
-            console.warn(`Super Pi: run slot for conversation ${conversationId} not released after stop deadline; force-releasing.`);
-            this.releaseRunSlot(conversationId);
+        const current = this.activeRuns.get(conversationId);
+        if (current && expectedController && current === expectedController) {
+            // The deadline is a bound on this command, not proof that Pi stopped. Force-releasing here lets
+            // a new prompt reuse an SDK session that is still running and lets the old turn's final writes
+            // race the new one. Keep the slot until its owner's finally releases it; a later completion will
+            // broadcast the truthful stopped state.
+            throw new Error("停止超时：上一轮仍未退出，当前回合尚未退出。可以重试停止或检查运行时状态。");
         }
+        // A newer turn may have started after the aborted turn released its slot but before this cleanup
+        // acquired the conversation lane. Never stamp that new turn as stopped.
+        if (this.activeRuns.get(conversationId) && this.activeRuns.get(conversationId) !== expectedController)
+            return;
         await this.store.setStatus(conversationId, "stopped");
         this.broadcaster.broadcastState();
     }
@@ -650,11 +741,20 @@ export class RunService {
         // which is a later answer than the one the message is waiting for.
         if (!this.activeRuns.has(conversationId))
             return;
+        // A stop has already been requested.  The old producer still owns the slot until its `finally`,
+        // but handing a follow-up to Pi here would let the dying turn consume it after the user pressed
+        // stop.  Keep the row in Super Pi's waiting queue; the next turn will pick it up once the slot is
+        // genuinely released.
+        if (this.isStopping(conversationId))
+            return;
         // AN INTERRUPT IS ALREADY STARTING. It aborts the run and empties Pi's queues, so a message handed
         // to Pi now would be taken back a moment later. It waits in the list for the next run, exactly as it
         // did before.
         if (this.interruptTargets.has(conversationId))
             return;
+        // The previous run may have taken this row while its persistence promise was still resolving.
+        if (!this.store.listWaitingMessages(conversationId).some(item => item.id === message.id && item.delivery === "waiting"))
+            return;
         // A MESSAGE THAT IS A COMMAND IS NOT QUEUED. Pi expands a skill command or a prompt template before
         // it queues the text (`agent-session.ts:2221-2222`), and it REFUSES an extension command outright.
         // An expanded text is not the text Super Pi has, so the delivery could not be resolved back to its
@@ -816,8 +916,11 @@ export class RunService {
                 // honest - a client that saw the new tool row in the same frame also saw the running
                 // status, instead of flashing back to a still-spinning waiting mark for the next paint.
                 await promoteToRunning();
+                const hadPendingQuestion = toolCalls.some(call => call.question?.status === "pending");
                 toolCalls = await work();
                 this.broadcaster.broadcast({ type: "message.tools", conversationId: conversation.id, messageId: assistant.id, toolCalls });
+                if (hadPendingQuestion !== toolCalls.some(call => call.question?.status === "pending"))
+                    this.broadcaster.broadcastState();
             }).catch((error) => {
                 console.warn(`Super Pi: recording ${what} failed: ${error instanceof Error ? error.message : "unknown error"}`);
             });
@@ -842,6 +945,7 @@ export class RunService {
         let thinkingBlock = -1;
         let thinkingAnswerAt = -1;
         let thinkingInterrupted = false;
+        let answerAfterThinking = false;
         const currentThinkingBlock = () => {
             if (thinkingActive)
                 return thinkingBlock;
@@ -922,7 +1026,6 @@ export class RunService {
             // this one was not, and the JSON persistence backend's slower writes widen the window enough for
             // the browser test to catch the difference between capturing and reading.
             const thinkingAt = thought;
-            const callThinkingBlock = currentThinkingBlock();
             // The block says WHICH TOOL and WHAT IT IS AIMED AT as soon as either is known. 「工具」 as the name
             // and 「正在生成参数…」 as the only line below it told a reader nothing for the seconds a large `edit`
             // spends writing its replacement text - and by the time the file path was on screen, the block looked
@@ -934,9 +1037,16 @@ export class RunService {
                 preparing: true,
                 at,
                 thinkingAt,
-                thinkingBlock: callThinkingBlock,
             }));
-            preparingRows.set(call.contentIndex, { row, name: call.name });
+            // `thinkingAt` GOES WITH THE PLACEHOLDER. It is how much reasoning had been written when the
+            // model announced this call, and the real call needs it to work out whether the reasoning kept
+            // going afterwards - which is the fact that says whether the call belongs inside the reasoning
+            // fold or in the answer (see `onToolCall`).
+            // THE BLOCK INDEX GOES WITH THE PLACEHOLDER TOO, and it is captured HERE - at the moment the
+            // model announced the call - because that is the only moment the block it belongs to is the
+            // OPEN one. By the time the call runs, the reasoning may have ended and a LATER block may have
+            // opened, and the index of the block the call belongs to is no longer the current one.
+            preparingRows.set(call.contentIndex, { row, name: call.name, thinkingAt, thinkingActive, thinkingBlock: thinkingActive ? thinkingBlock : null });
         };
         /**
          * THE AGENT IS ABOUT TO WRITE A FILE.
@@ -962,16 +1072,29 @@ export class RunService {
             const tracker = this.fileChanges;
             if (!tracker)
                 return;
-            tracker.record(workspace.id, path, { root: workspace.path, conversationId: conversation.id });
-            void this.fileIndexes?.get(workspace.id)?.refresh(path);
+            // THE PATH AS THE WORKSPACE SPELLS IT, TRANSLATED ONCE.
+            //
+            // This path comes from the MODEL - it is the `path` argument of `write`/`edit` - and a model
+            // that has been told where the workspace is writes an ABSOLUTE path: `/home/me/project/src/a.ts`
+            // is the same file as `src/a.ts`. Every consumer below keys its rows by the workspace's own
+            // spelling - the change tracker, the file index and the name index - so the translation happens
+            // once, here, and all three get the same answer.
+            //
+            // WITHOUT IT the three disagreed: the tracker resolved the path against the workspace and got
+            // it right, while the name index stored the absolute path with its leading slash stripped
+            // (`home/me/project/src/a.ts`) - an entry that matched by name and then pointed at a file that
+            // 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);
             // 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(path);
+                ensureNameIndex(this.nameIndexes, workspace.id, workspace.path).upsert(relative);
             if (toolCallId)
-                fileWritePaths.set(toolCallId, path);
+                fileWritePaths.set(toolCallId, relative);
             this.broadcastFileChanges(workspace.id);
         };
         const onToolCall = (call) => {
@@ -1006,7 +1129,13 @@ export class RunService {
                     rowByToolCallId.set(call.id, row);
                     this.noteToolCallSite(conversation.id, call.id, assistant.id, row);
                 }
-                enqueueTools("a tool call", () => this.store.updateToolCall(conversation.id, assistant.id, row, { label: call.name, detail: call.detail, args: call.args, live: "", preparing: false, ...(call.question ? { question: call.question } : {}) }));
+                // The offset says whether the reasoning grew after this call was initiated. The captured
+                // `thinkingActive` flag covers the final-moment case, unless answer text later appeared after
+                // thinking_end. That exclusion keeps after-body questions out of the previous reasoning fold.
+                const callThinkingBlock = prepared[1].thinkingAt < thought || (prepared[1].thinkingActive && !answerAfterThinking) ? prepared[1].thinkingBlock : null;
+                // `at` is corrected to the execution position; `thinkingAt` stays at initiation so calls
+                // inside one reasoning block do not all collapse onto the final reasoning offset.
+                enqueueTools("a tool call", () => this.store.updateToolCall(conversation.id, assistant.id, row, { label: call.name, detail: call.detail, args: call.args, live: "", preparing: false, at, thinkingBlock: callThinkingBlock, ...(call.question ? { question: call.question } : {}) }));
                 return;
             }
             const row = rows++;
@@ -1016,6 +1145,12 @@ export class RunService {
             }
             // Captured for the same reason as the preparing path above: the queued append must anchor the call
             // where it was MADE, not where the queue happened to be when it drained.
+            //
+            // THIS IS THE PATH WITH NO PLACEHOLDER - Pi never announced a `toolcall_start` for this call,
+            // so there is no earlier moment to compare offsets against, and the reasoning offset is taken
+            // here, at the announcement. The block is decided by the same question as everywhere else: was
+            // the reasoning still growing after the call was announced? Here the answer is read from
+            // `thinkingActive`, because a call with no placeholder carries no earlier offset to compare.
             const thinkingAt = thought;
             const callThinkingBlock = currentThinkingBlock();
             enqueueTools("a tool call", () => this.store.appendToolCall(conversation.id, assistant.id, { label: call.name, detail: call.detail, args: call.args, at, thinkingAt, thinkingBlock: callThinkingBlock, ...(call.question ? { question: call.question } : {}) }));
@@ -1034,7 +1169,7 @@ export class RunService {
             const writtenPath = call.id ? fileWritePaths.get(call.id) : undefined;
             if (writtenPath) {
                 this.fileChanges?.confirm(workspace.id, writtenPath, workspace.path);
-                void this.fileIndexes?.get(workspace.id)?.refresh(writtenPath);
+                refreshWorkspaceIndex(this.fileIndexes, workspace.id, writtenPath);
                 if (this.nameIndexes)
                     ensureNameIndex(this.nameIndexes, workspace.id, workspace.path).upsert(writtenPath);
                 if (call.id)
@@ -1097,6 +1232,7 @@ export class RunService {
                 thought = 0;
                 thinkingActive = false;
                 thinkingInterrupted = true;
+                answerAfterThinking = false;
                 rows = 0;
                 rowByToolCallId.clear();
                 preparingRows.clear();
@@ -1143,6 +1279,7 @@ export class RunService {
                     if (newBlock) {
                         thinkingBlock++;
                         thinkingAnswerAt = spoken;
+                        answerAfterThinking = false;
                     }
                     thinkingInterrupted = false;
                     thinkingActive = true;
@@ -1197,6 +1334,8 @@ export class RunService {
                 // answering rather than hanging on auth / quota / network. `promoteToRunning` is a no-op
                 // after the first signal so this stays a one-shot status write, not a per-token one.
                 await promoteToRunning();
+                if (!thinkingActive && thinkingBlock >= 0)
+                    answerAfterThinking = true;
                 this.store.appendAssistantDeltaLive(conversation.id, assistant.id, delta);
                 spoken += delta.length;
                 // Tool events are structural transcript boundaries. Publish any boundary Pi announced before
@@ -1284,10 +1423,34 @@ export class RunService {
             await this.store.releaseSendingMessages(conversation.id);
         }
     }
+    /** 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");
+            if (controller.signal.aborted)
+                return;
+            // No await between the last empty observation and releasing the slot.
+            // A send admitted during setStatus must be answered here, even though Pi's previous turn ended.
+            const next = this.store.listWaitingMessages(conversation.id).find(item => item.delivery === "waiting");
+            if (!next) {
+                // Release on the same instruction turn as the empty observation. Returning to an awaiting
+                // caller first would create another microtask window for a send to enter the old run's queue.
+                this.releaseRunSlot(conversation.id, controller);
+                return;
+            }
+            conversation = this.turnContext(conversation.id).conversation;
+            prompt = composePrompt(next);
+            messageId = next.id;
+            images = next.images;
+        }
+    }
     /**
      * Enqueues or starts execution for a user message.
      */
     async enqueueAndRun(conversationId, content, images, attachments, clientId) {
+        this.assertHistoryAvailable(conversationId);
         /**
          * A CLIENT ID THIS CONVERSATION ALREADY HAS IS A RESEND, NOT A SECOND MESSAGE.
          *
@@ -1327,40 +1490,51 @@ export class RunService {
         // for a turn that had already begun. The state a message is born into is a claim about it, and a claim
         // retracted in the next frame is worse than never making it.
         //
-        // Reading the slot here and claiming it below leaves a window between them, and the window is real:
-        // `message.send` runs outside the socket's command queue precisely so a follow-up can overtake a
-        // command already in flight, so two sends CAN be inside this method at the same time. The loser wrote
-        // itself as an ordinary message and now finds the slot taken - its words are on screen with nobody
-        // going to answer them. Repairing that is what the guard below is for; it is not a rare path, it is
-        // what two fast sends looks like from the inside.
         // An aborted run is unwinding its slot. Wait out that brief cleanup rather than falsely
         // treating it as an active turn and sending this message to a dying follow-up queue.
         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 message = await this.store.addUserMessage(conversationId, trimmed, validImages, attachments, { clientId, ...(busy ? { delivery: "waiting" } : {}) });
+        // Reserve BEFORE the first persistence await. Revert/stop must see this admitted send even while
+        // its message write is pending; otherwise a cut can start while this send goes on to launch Pi.
+        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.addUserMessage(conversationId, trimmed, validImages, attachments, { clientId, ...(busy ? { delivery: "waiting" } : {}) });
+        }
+        catch (error) {
+            if (reservedController)
+                this.releaseRunSlot(conversation.id, reservedController);
+            throw error;
+        }
         this.broadcaster.broadcastState();
-        // Claim the run slot synchronously (no await between has() and set()) so two
-        // rapid sends can never both pass the guard and start concurrent turns.
-        if (this.activeRuns.has(conversation.id) || this.interruptTargets.has(conversation.id)) {
-            if (!busy) {
-                // Lost the race described above. No turn has opened on this message and no model has seen it, so
-                // calling it waiting is a statement of fact - and it puts the words exactly where a message born
-                // waiting would have put them, which is the only place a person can find them.
-                await this.store.markMessageWaiting(conversationId, message.id);
-                this.broadcaster.broadcastState();
-            }
+        if (!reservedController) {
             // The turn that is running answers this message itself, through Pi's own follow-up queue, rather
             // than by a turn of its own once the running one is over. The message stays in the waiting list
             // either way, so it is still the user's to withdraw - Pi is holding a copy, not the only copy.
-            await this.submitToPiQueue(conversationId, message);
+            const waiting = this.store.listWaitingMessages(conversationId).find(item => item.id === message.id && item.delivery === "waiting");
+            if (!waiting)
+                return; // The owner already opened/delivered it while this write was pending.
+            if (!this.activeRuns.has(conversationId) && !this.interruptTargets.has(conversationId)) {
+                await this.processWaitingMessage(conversationId, message.id);
+            }
+            else
+                await this.submitToPiQueue(conversationId, message);
             return;
         }
-        const controller = new AbortController();
-        this.claimRunSlot(conversation.id, controller);
+        const controller = reservedController;
         try {
+            if (controller.signal.aborted) {
+                await this.store.setStatus(conversation.id, "stopped");
+                return;
+            }
             let expanded;
             try {
                 if (validImages?.length) {
@@ -1406,8 +1580,7 @@ export class RunService {
                 this.broadcaster.broadcastState();
                 throw error;
             }
-            await this.runConversationTurns(conversation, workspace, expanded, controller, message.id, validImages);
-            await this.store.setStatus(conversation.id, controller.signal.aborted ? "stopped" : "completed");
+            await this.runUntilDrained(conversation, workspace, expanded, controller, message.id, validImages);
         }
         catch (error) {
             // A failing turn needs to be READ AS A FAILING TURN, not just stamped "failed" in a corner no one
@@ -1448,8 +1621,11 @@ export class RunService {
             throw error;
         }
         finally {
-            this.releaseRunSlot(conversation.id);
-            this.extensionUiService.cancelPendingUi(conversation.id, "expired");
+            this.releaseRunSlot(conversation.id, controller);
+            // An old turn can unwind after stop has admitted a new one. Do not cancel the new turn's
+            // extension dialog merely because this turn's finally block ran late.
+            if (!this.activeRuns.has(conversation.id))
+                this.extensionUiService.cancelPendingUi(conversation.id, "expired");
             this.broadcaster.broadcastState();
         }
     }
@@ -1484,7 +1660,7 @@ export class RunService {
     async awaitRunSlotReleased(conversationId, onlyWhileStopped = false, timeoutMs = 15_000) {
         const deadline = Date.now() + timeoutMs;
         while (this.activeRuns.has(conversationId) && Date.now() < deadline) {
-            if (onlyWhileStopped && this.store.snapshot().conversations.find((item) => item.id === conversationId)?.status !== "stopped")
+            if (onlyWhileStopped && this.store.conversationStatus(conversationId) !== "stopped")
                 return;
             const completion = this.runCompletions.get(conversationId)?.promise;
             if (!completion)
@@ -1507,6 +1683,7 @@ export class RunService {
      * not changed, so no process is spawned and no history is replayed.
      */
     async interruptQueued(conversationId, messageId) {
+        this.assertHistoryAvailable(conversationId);
         if (this.interruptTargets.has(conversationId))
             throw new Error("已有一条打断回复正在启动，请稍候");
         const selected = this.store.listWaitingMessages(conversationId).find((item) => item.id === messageId);
@@ -1552,6 +1729,7 @@ export class RunService {
         // steer/reorder/cancel wait until that turn ends, which is especially visible after a background
         // result auto-starts a long follow-up. The activeRuns slot protects the turn after this lane exits.
         const controller = await this.serializeConversation(conversationId, async () => {
+            this.assertHistoryAvailable(conversationId);
             const reserved = this.interruptTargets.get(conversationId);
             if (reserved && reserved !== messageId)
                 throw new Error("打断回复正在启动，请等待所选消息开始回答");
@@ -1561,6 +1739,7 @@ export class RunService {
             if (!message || message.delivery !== "waiting")
                 throw new Error("等待中的消息不存在或已被处理");
             const controller = new AbortController();
+            this.cancelledQuestionConversations.delete(conversationId);
             this.claimRunSlot(conversationId, controller);
             return controller;
         });
@@ -1570,8 +1749,7 @@ export class RunService {
             if (!message)
                 throw new Error("消息不存在或已被撤回");
             // runConversationTurns opens this first message; do not create a second assistant placeholder.
-            await this.runConversationTurns(conversation, workspace, composePrompt(message), controller, message.id, message.images);
-            await this.store.setStatus(conversationId, controller.signal.aborted ? "stopped" : "completed");
+            await this.runUntilDrained(conversation, workspace, composePrompt(message), controller, message.id, message.images);
         }
         catch (error) {
             await this.store.setStatus(conversationId, controller.signal.aborted ? "stopped" : "failed");
@@ -1581,8 +1759,9 @@ export class RunService {
             throw error;
         }
         finally {
-            this.releaseRunSlot(conversationId);
-            this.extensionUiService.cancelPendingUi(conversationId, "expired");
+            this.releaseRunSlot(conversationId, controller);
+            if (!this.activeRuns.has(conversationId))
+                this.extensionUiService.cancelPendingUi(conversationId, "expired");
             this.broadcaster.broadcastState();
         }
     }
@@ -1642,6 +1821,7 @@ export class RunService {
         return this.serializeConversation(conversationId, async () => {
             if (this.interruptTargets.get(conversationId) === messageId)
                 throw new Error("这条消息正在打断并回答，无法修改");
+            await this.clearPiQueues(conversationId);
             await this.store.editWaitingMessage(conversationId, messageId, content);
             this.broadcaster.broadcastState();
         });
@@ -1653,6 +1833,7 @@ export class RunService {
         return this.serializeConversation(conversationId, async () => {
             if (this.interruptTargets.get(conversationId) === messageId)
                 throw new Error("这条消息正在打断并回答，无法移动");
+            await this.clearPiQueues(conversationId);
             await this.store.reorderWaitingMessage(conversationId, messageId, toIndex);
             this.broadcaster.broadcastState();
         });
@@ -1698,6 +1879,7 @@ export class RunService {
             throw new Error(capability.message);
         if (body.depth !== undefined)
             checkSubagentDepth(body.depth);
+        const signal = this.activeRuns.get(conversationId)?.signal;
         const { conversation, cwd } = 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)) {
@@ -1725,6 +1907,9 @@ export class RunService {
             ...(body.loopId ? { loopId: body.loopId } : {}),
             ...(body.role ? { role: body.role } : {}),
             denyTools: parentDeniedTools(await this.runtime.agentFor?.(conversation)),
+            // Bind work that arrives during teardown to its original turn, including aborts that happen
+            // while tool anchoring, agent lookup or the recorder's initial persistence is still pending.
+            signal,
         });
         if (body.background === true) {
             await this.store.setBackgroundTask({
@@ -1755,7 +1940,7 @@ export class RunService {
                         this.broadcaster.broadcastState();
                         return row;
                     });
-                    if (!this.activeRuns.has(conversation.id) && !this.interruptTargets.has(conversation.id)) {
+                    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) => {
                             console.warn(`Super Pi: auto-trigger for background sub-agent result failed: ${error instanceof Error ? error.message : "unknown error"}`);
                         });
@@ -1830,6 +2015,7 @@ export class RunService {
         if (!capability.ok)
             throw new Error(capability.message);
         const { conversation, cwd } = 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
         // message with no restart, because a person edits `agents/*.md` while the server runs.
@@ -1841,7 +2027,7 @@ export class RunService {
             conversationId: conversation.id,
             cwd,
             plan: validated.plan,
-            signal: this.activeRuns.get(conversation.id)?.signal,
+            signal,
             ...(conversation.model ? { model: conversation.model } : {}),
             // The same inheritance a single dispatch applies: a parent's DENY reaches its children, its
             // allowlist does not. Every step gets the primary's denials, exactly as one dispatch would.