@evandu/super-pi 0.1.133 → 0.1.136

package/dist/server/active-memory.js

@@ -9,6 +9,13 @@ export class ActiveMemory {
     inverted = new Map();
     indexedWorkspaces = new Set();
     indexedMessages = new Set();
+    /**
+     * messageId -> which workspace's index holds it and under which terms. This is the reverse side of
+     * `inverted`, and it is what makes removal surgical: a revert knows exactly which messages it cut
+     * (the store's `plan.removedMessageIds`), so exactly those postings can be dropped - the rest of the
+     * workspace stays indexed instead of paying a full rebuild on the next search.
+     */
+    termsByMessage = new Map();
     notes;
     capabilities = new Map();
     reviews = new Map();
@@ -109,10 +116,14 @@ export class ActiveMemory {
     release(token) { this.capabilities.delete(token); }
     identity(token) {
         const identity = this.capabilities.get(token);
-        if (!identity || !this.store.snapshot().workspaces.some(w => w.id === identity.workspaceId))
+        if (!identity || !this.hasWorkspace(identity.workspaceId))
             throw new Error("记忆授权已失效");
         return identity;
     }
+    hasWorkspace(workspaceId) {
+        const store = this.store;
+        return store.hasWorkspace ? store.hasWorkspace(workspaceId) : store.snapshot().workspaces.some(w => w.id === workspaceId);
+    }
     search(workspaceId, query, sessionId) {
         const words = query.toLocaleLowerCase().match(/[\p{L}\p{N}_-]{2,}/gu)?.slice(0, 12) ?? [];
         if (!words.length)
@@ -134,7 +145,9 @@ export class ActiveMemory {
                     continue;
                 const value = { conversationId: conversation.id, title: conversation.title, messageId: message.id, role: message.role, content: message.content };
                 this.indexedMessages.add(message.id);
-                for (const word of message.content.toLocaleLowerCase().match(/[\p{L}\p{N}_-]{2,}/gu) ?? []) {
+                const terms = message.content.toLocaleLowerCase().match(/[\p{L}\p{N}_-]{2,}/gu) ?? [];
+                this.termsByMessage.set(message.id, { workspaceId, terms });
+                for (const word of terms) {
                     let bucket = index.get(word);
                     if (!bucket)
                         index.set(word, bucket = new Map());
@@ -145,7 +158,7 @@ export class ActiveMemory {
         this.indexedWorkspaces.add(workspaceId);
     }
     /**
-     * Drops a workspace's search index so the next search rebuilds it from the store.
+     * Drops exactly the given messages from the search index, leaving the rest of the workspace indexed.
      *
      * WHY THIS EXISTS. `ensureIndex` builds once per workspace and `addToIndex` only ever adds, so the
      * index outlives the messages it indexed: a revert removes messages from the store while the index
@@ -154,17 +167,54 @@ export class ActiveMemory {
      * history" after a revert every file-level assertion proved had really truncated. The store is the
      * source of truth; the index is a cache of it, and a cache that survives an event that invalidated
      * its source is wrong by definition.
+     *
+     * WHY SURGICAL. The caller (revert) knows precisely which message ids the store dropped, and this
+     * method trusts that list rather than re-deriving it: the ids not in `termsByMessage` were never
+     * indexed (no search had built the index, or a role the index skips), so a no-op for them is
+     * correct, and the next search - if the index was never built - builds from the post-revert store
+     * anyway. Dropping the whole workspace index instead would force the next search to rebuild every
+     * surviving conversation's entries for no reason, and the recall gap in between would answer
+     * searches with nothing at all.
      */
-    invalidateSearchIndex(workspaceId) {
-        this.indexedWorkspaces.delete(workspaceId);
-        this.inverted.delete(workspaceId);
+    removeFromIndex(messageIds) {
+        for (const messageId of messageIds) {
+            const entry = this.termsByMessage.get(messageId);
+            if (!entry)
+                continue;
+            const terms = this.inverted.get(entry.workspaceId);
+            if (terms) {
+                for (const term of entry.terms) {
+                    const bucket = terms.get(term);
+                    if (!bucket)
+                        continue;
+                    bucket.delete(messageId);
+                    if (!bucket.size)
+                        terms.delete(term);
+                }
+            }
+            this.termsByMessage.delete(messageId);
+            this.indexedMessages.delete(messageId);
+        }
     }
     addToIndex(conversation, message) {
         if (!this.indexedWorkspaces.has(conversation.workspaceId) || (message.role !== "user" && message.role !== "assistant"))
             return;
         let terms = this.inverted.get(conversation.workspaceId);
         const value = { conversationId: conversation.id, title: conversation.title, messageId: message.id, role: message.role, content: message.content };
-        for (const term of message.content.toLocaleLowerCase().match(/[\p{L}\p{N}_-]{2,}/gu) ?? []) {
+        const messageTerms = message.content.toLocaleLowerCase().match(/[\p{L}\p{N}_-]{2,}/gu) ?? [];
+        // A REFRESH MUST ALSO FORGET THE OLD TERMS. The buckets map a term to the message that contains
+        // it, and a term that only the OLD content had would keep pointing at this message with a stale
+        // copy - so a search for a word the model has since dropped would still hand the reader the old
+        // text. The terms this message had are remembered exactly so they can be dropped here.
+        const previous = this.termsByMessage.get(message.id);
+        if (previous)
+            for (const term of previous.terms) {
+                const bucket = terms.get(term);
+                if (bucket)
+                    bucket.delete(message.id);
+            }
+        this.termsByMessage.set(message.id, { workspaceId: conversation.workspaceId, terms: messageTerms });
+        for (const term of messageTerms) {
             let bucket = terms.get(term);
             if (!bucket)
                 terms.set(term, bucket = new Map());
@@ -232,7 +282,7 @@ export class ActiveMemory {
         return alreadyLocked ? work() : this.locked(work);
     }
     async manage(workspaceId, body) {
-        if (!this.store.snapshot().workspaces.some(w => w.id === workspaceId))
+        if (!this.hasWorkspace(workspaceId))
             throw new Error("工作区不存在");
         if (body.action === "configure") {
             await this.configure(body.settings);
@@ -266,6 +316,21 @@ export class ActiveMemory {
         this.cancel(id); }
     async waitForIdle() { await Promise.allSettled([...this.workspaceReviews.values()]); await this.serial; }
     async completed(conversation) {
+        // REFRESH THIS TURN'S MESSAGES, DO NOT JUST FILL IN THE UNSEEN ONES.
+        //
+        // The index is a CACHE of the store's content, and an assistant message's content changes while
+        // the model is still writing it: the entry was built from the empty placeholder the turn opened
+        // with, so it holds the answer BEFORE the answer. "I have seen this message" is not "I have seen
+        // its final content" - treating the two as the same froze this turn's answer in the index, and a
+        // frozen answer is an answer that can never be recalled (measured by
+        // scripts/active-memory-index-content.test.mjs: the recall came back `undefined`).
+        //
+        // Only THIS TURN's messages are refreshed - the ones after the last user message. The rest of the
+        // transcript was indexed when it was final, and re-tokenizing a whole conversation on every turn
+        // end is exactly the cost this file is about.
+        const lastUserIndex = conversation.messages.map((message) => message.role).lastIndexOf("user");
+        for (const message of lastUserIndex >= 0 ? conversation.messages.slice(lastUserIndex + 1) : conversation.messages)
+            this.addToIndex(conversation, message);
         for (const message of conversation.messages)
             if (!this.indexedMessages.has(message.id))
                 this.addToIndex(conversation, message);

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

@@ -359,8 +359,10 @@ export class ConversationService {
         // The recall index is a cache of the store's messages, and the store just lost several: left alone it
         // keeps answering the memory extension's searches with the withdrawn turns, so the model is told about
         // history the person reverted away even though the transcript, Pi's file and the memory store all
-        // agree it is gone. Invalidate it and the next search rebuilds from what actually survived.
-        this.memory?.invalidateSearchIndex(workspaceId);
+        // agree it is gone. The store's plan says exactly which message ids were dropped, so exactly those
+        // postings leave the index - the surviving conversations of this workspace stay indexed and the next
+        // search pays no rebuild.
+        this.memory?.removeFromIndex(applied.removedMessageIds);
         console.log(`Super Pi: reverted conversation ${conversationId} to ${applied.boundaryIndex + 1} message(s): ` +
             `${plan.removedMessageIds.length} message(s) and ${applied.doomedRunIds.length} sub-agent run(s) dropped from state.json; ` +
             `Pi's file ${outcome.sessionFile} kept ${outcome.linesKept} line(s) and lost ${outcome.entriesDropped}; ` +

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

@@ -61,6 +61,7 @@ export declare class RunService {
     private readonly extensionUiService;
     private agentsDir;
     private readonly workflows;
+    private readonly questionWaiters;
     private memory?;
     setMemory(memory: import("../active-memory.js").ActiveMemory): void;
     /**
@@ -178,6 +179,9 @@ export declare class RunService {
         answers?: QuestionAnswer[];
         cancelled?: boolean;
     }): Promise<void>;
+    private questionKey;
+    private answerPayload;
+    private settleQuestion;
     /**
      * THE `question` TOOL BLOCKS HERE, ON THE CALL THAT ASKED IT.
      *

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

@@ -6,6 +6,7 @@ import { verifyCapability } from "../capability.js";
 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 { execFile } from "node:child_process";
 import { promisify } from "node:util";
 const execFileAsync = promisify(execFile);
@@ -84,6 +85,7 @@ export class RunService {
     extensionUiService;
     agentsDir;
     workflows;
+    questionWaiters = new Map();
     memory;
     setMemory(memory) { this.memory = memory; }
     /**
@@ -238,52 +240,32 @@ export class RunService {
                     this.broadcaster.broadcastState();
                     return row;
                 });
-                // AUTO-TRIGGER WHEN IDLE. The conversation may already be busy (running turn, taking the next
-                // waiting message in its own follow-up loop); if so, the existing loop picks this one up and
-                // this branch is a no-op. If idle, kick off a fresh turn so the model processes the result
-                // without the user having to send anything - the failure case is intentionally included: the
-                // model seeing "[后台任务 X 失败]" is part of the same "after current AI finishes, automatically
-                // processes the result" contract, and the auto-triggered turn goes through the same
-                // `composePrompt` path the success case does (so a helper failure surfaces as `state="error"`
-                // prose the agent can react to).
-                // EXACTLY ONE DELIVERY PER RESULT. The custom channel hands the result straight to Pi's own
-                // follow-up queue, but it knows nothing about the `waiting` row queued above, and
-                // `takeNextWaitingMessage` knows nothing about Pi's queue - so delivering through the channel
-                // while leaving the row waiting gave the model the SAME result twice (once as the custom
-                // message, once as the row's own prose turn). Measured by
-                // scripts/background-result-delivery.test.mjs. So a successful custom delivery CONSUMES the row,
-                // and a failed one - `SteerUnavailableError`, which is what oneshot mode and a not-yet-created
-                // session throw - falls back to the queue path, the same semantics the sub-agent result path
-                // (processWaitingMessage only) has always had.
-                let deliveredViaCustom = false;
-                const custom = this.runtime.sendCustomMessage;
-                if (custom) {
-                    try {
-                        await custom.call(this.runtime, task.conversationId, {
-                            customType: "super-pi-task-result",
-                            content: body,
-                            display: "后台任务结果",
-                            details: { taskId: sessionId, source: "exec", state: exitCode === 0 ? "completed" : "error", summary: task.title },
-                        });
-                        deliveredViaCustom = true;
-                    }
-                    catch (error) {
-                        console.warn(`Super Pi: custom delivery of the exec result failed, the queue path takes over: ${error instanceof Error ? error.message : "unknown error"}`);
-                    }
-                }
-                if (deliveredViaCustom) {
-                    await this.store.takeWaitingMessage(task.conversationId, queued.id);
-                }
-                else if (!this.activeRuns.has(task.conversationId) && !this.interruptTargets.has(task.conversationId)) {
+                // THE RESULT WAITS IN SUPER PI'S OWN QUEUE, AND THE QUEUE IS DRAINED ONE TURN AT A TIME.
+                //
+                // It used to go to Pi's own follow-up queue, and Pi DRAINS that queue all at once when a turn
+                // ends - the pending messages are collected into one array and fed to the model as a single
+                // turn. So two background results that finished close together were handed over TOGETHER, and
+                // the agent answered both at once (ledger TEST-033). That path also had a second defect of its
+                // own: Pi's queue knows nothing about the `waiting` row queued above, so delivering through it
+                // while leaving the row waiting gave the model the SAME result twice (ledger TEST-011).
+                //
+                // So the result is not delivered through that channel at all. It stays a `waiting` row, and
+                // Super Pi's own loop takes waiting messages ONE PER TURN - which is what that loop was built
+                // for, and what the sub-agent result path has always done.
+                //
+                // IDLE: a turn of its own starts now, so the model processes the result without the user
+                // having to send anything. The failure case is included on purpose: the model seeing
+                // "[后台任务 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"}`);
                     });
                 }
-                else {
-                    // THE CONVERSATION IS BUSY, so the run that is going answers this result itself - through
-                    // Pi's own follow-up queue, so the result does not have to wait for a turn of its own.
-                    await this.submitToPiQueue(task.conversationId, queued);
-                }
+                // 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.
             }
             catch (error) {
                 console.warn(`Super Pi: exec result could not be appended as a tool message: ${error instanceof Error ? error.message : "unknown error"}`);
@@ -374,7 +356,7 @@ export class RunService {
      * other tool update uses - and the client can only get that index from the row it is already rendering.
      */
     async answerQuestion(command) {
-        const existing = this.store.snapshot().conversations.find((item) => item.id === command.conversationId)?.messages.find((item) => item.id === command.messageId)?.toolCalls?.[command.callIndex]?.question;
+        const existing = this.store.question(command.conversationId, command.messageId, command.callIndex);
         if (!existing)
             throw new Error("这个工具调用不是一个问题");
         const calls = await this.store.updateToolCall(command.conversationId, command.messageId, command.callIndex, {
@@ -385,6 +367,30 @@ export class RunService {
             },
         });
         this.broadcaster.broadcast({ type: "message.tools", conversationId: command.conversationId, messageId: command.messageId, toolCalls: calls });
+        this.settleQuestion(command.conversationId, command.messageId, command.callIndex, calls[command.callIndex]?.question);
+    }
+    questionKey(conversationId, messageId, index) {
+        return `${conversationId}\0${messageId}\0${index}`;
+    }
+    answerPayload(current) {
+        const answers = (current.answers ?? []).map((answer) => {
+            const asked = current.items.find((item) => item.id === answer.id);
+            return { question: asked?.question, selected: answer.selected, ...(answer.note ? { note: answer.note } : {}) };
+        });
+        return { answers, summary: `用户回答：${answers.map((answer) => answer.selected.join("、")).join("；")}` };
+    }
+    settleQuestion(conversationId, messageId, index, question) {
+        if (!question || question.status === "pending")
+            return;
+        const key = this.questionKey(conversationId, messageId, index);
+        const waiter = this.questionWaiters.get(key);
+        if (!waiter)
+            return;
+        this.questionWaiters.delete(key);
+        if (question.status === "answered")
+            waiter.resolve(this.answerPayload(question));
+        else
+            waiter.reject(new Error("用户没有回答这个问题"));
     }
     /**
      * THE `question` TOOL BLOCKS HERE, ON THE CALL THAT ASKED IT.
@@ -414,28 +420,13 @@ export class RunService {
         //
         // So the lookup WAITS. A few hundred milliseconds of polling covers the drain, and a question that
         // genuinely has no pending call still fails - just not instantly.
-        const findCall = () => {
-            const conversation = this.store.snapshot().conversations.find((item) => item.id === conversationId);
-            const message = conversation?.messages.slice().reverse().find((item) => item.role === "assistant");
-            if (!message)
-                return undefined;
-            for (let i = (message.toolCalls?.length ?? 0) - 1; i >= 0; i -= 1) {
-                const call = message.toolCalls?.[i];
-                if (call?.label === "question" && call.question?.status === "pending")
-                    return { messageId: message.id, index: i };
-            }
-            return undefined;
-        };
         let found;
         for (let attempt = 0; attempt < 50 && !found; attempt += 1) {
-            found = findCall();
+            found = this.store.pendingQuestion(conversationId);
             if (found)
                 break;
             await new Promise((resolve) => setTimeout(resolve, 100));
         }
-        const conversation = this.store.snapshot().conversations.find((item) => item.id === conversationId);
-        if (!conversation?.messages.length)
-            throw new Error("No active assistant message");
         if (!found)
             throw new Error("这个会话里没有正在等待回答的 question 工具调用");
         const { messageId, index } = found;
@@ -445,29 +436,7 @@ 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.
-            const poll = setInterval(() => {
-                const current = this.store.snapshot().conversations.find((item) => item.id === conversationId)?.messages.find((item) => item.id === messageId)?.toolCalls?.[index]?.question;
-                if (current?.status === "answered") {
-                    clearInterval(poll);
-                    resolve(answerPayload(current));
-                }
-                else if (current?.status === "cancelled") {
-                    clearInterval(poll);
-                    reject(new Error("用户没有回答这个问题"));
-                }
-            }, 250);
-            // WHAT GOES BACK TO THE MODEL IS WRITTEN FOR THE MODEL. The answers pair to their questions by id,
-            // which is what stops a person answering the second of two being recorded against the first - but an
-            // id is a UUID, and a model handed `{answers:[{id:"671b0f0b-…", selected:["发"]}]}` has to guess at
-            // what that means. It guessed, and reported a real answer as a cancellation. So the answer goes back
-            // as its questions and its choices, with a sentence naming the outcome.
-            const answerPayload = (current) => {
-                const answers = (current.answers ?? []).map((answer) => {
-                    const asked = current.items.find((item) => item.id === answer.id);
-                    return { question: asked?.question, selected: answer.selected, ...(answer.note ? { note: answer.note } : {}) };
-                });
-                return { answers, summary: `用户回答：${answers.map((answer) => answer.selected.join("、")).join("；")}` };
-            };
+            this.questionWaiters.set(this.questionKey(conversationId, messageId, index), { resolve, reject });
         });
     }
     /**
@@ -571,6 +540,7 @@ export class RunService {
         // 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();
+        this.broadcaster.broadcast({ type: "run.stopping", conversationId });
         await this.runtime.stop?.(conversationId);
         return this.serializeConversation(conversationId, () => this.stopRunUnsafe(conversationId));
     }
@@ -591,9 +561,9 @@ export class RunService {
                     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);
             }
         }
-        await this.store.setStatus(conversationId, "stopped");
         if (this.subagents.stopConversation(conversationId)) {
             console.log(`Super Pi: stopped the sub-agent runs of conversation ${conversationId}.`);
         }
@@ -603,6 +573,17 @@ export class RunService {
         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);
+        }
+        await this.store.setStatus(conversationId, "stopped");
         this.broadcaster.broadcastState();
     }
     /**
@@ -777,14 +758,29 @@ export class RunService {
         // long tool execution. The flag is the only way to make the flip one-shot: calling `setStatus` on
         // every delta would be a per-token status write.
         let firstSignal = true;
+        /**
+         * Promotes the turn to `running`, and ANSWERS WHETHER IT PUBLISHED A STATE SNAPSHOT.
+         *
+         * The answer matters because a state snapshot and a live event are two carriers of the same
+         * information: the snapshot is the whole truth (it carries the text, the thinking and the block
+         * boundaries), and a live `message.delta` / `message.thinking` event is an increment on top of it.
+         * A caller that has ALREADY put a delta into the store must therefore not also publish it as a
+         * live event, or the browser receives it twice and counts it twice - the reasoning the reader
+         * sees is longer than the reasoning the model wrote.
+         *
+         * So the rule is: WHOEVER PUTS THE DELTA IN THE STORE OWNS THE DELIVERY. The promotion publishes
+         * a snapshot only when it actually flips the status, and the caller asks.
+         */
         const promoteToRunning = async () => {
             if (!firstSignal)
-                return;
+                return false;
             firstSignal = false;
             if (this.store.snapshot().conversations.find((item) => item.id === conversation.id)?.status === "waiting") {
                 await this.store.setStatus(conversation.id, "running");
                 this.broadcaster.broadcastState();
+                return true;
             }
+            return false;
         };
         // Live events are independent from durable checkpoints. Persisting every token made the stdout
         // reader wait for one disk transaction per token; over a remote browser connection that backlog
@@ -1152,14 +1148,27 @@ export class RunService {
                     thinkingActive = true;
                     this.store.setThinkingActiveLive(conversation.id, assistant.id, true);
                     thought += delta.length;
+                    // THE DELTA GOES INTO THE STORE FIRST, and the promotion that follows broadcasts a state
+                    // snapshot that therefore CARRIES it - the text, the thinking and the block boundary the
+                    // browser needs to put this fragment in the right fold. That snapshot is the delta's
+                    // delivery, so the live event is not sent as well: sent twice, the browser appends the
+                    // first fragment to a copy that already has it, and the reasoning the reader sees is longer
+                    // than the reasoning the model wrote.
+                    //
+                    // THE OTHER ORDER HAD ITS OWN FAILURE, and it is why the snapshot is not simply left to
+                    // carry everything: promoting BEFORE the append publishes a snapshot WITHOUT this delta,
+                    // and the browser - which rebuilds its fold blocks from the snapshot's boundaries - then
+                    // starts a second block for the same stretch of reasoning, so one continuous train of
+                    // thought arrives as two fold bars and the tool call inside it falls out of the block it
+                    // belonged to.
+                    //
+                    // So: the snapshot carries the delta, and only the deltas the snapshot did not carry are
+                    // published live. `promoteToRunning` answers whether it published one.
                     this.store.appendThinkingDeltaLive(conversation.id, assistant.id, delta, spoken, newBlock);
-                    // THE PROMOTION COMES AFTER THE DELTA IS IN THE STORE, so the state snapshot it broadcasts
-                    // carries the same thinking the client is about to receive as a live event. Promoting first
-                    // broadcast a snapshot WITHOUT this delta, and the client - which prefers the live body only
-                    // while the conversation is running - took that stale snapshot, lost the thinking block's
-                    // boundary, and dropped a tool call out of the block it belonged to.
-                    await promoteToRunning();
-                    this.broadcaster.broadcast({ type: "message.thinking", conversationId: conversation.id, messageId: assistant.id, delta, active: true, at: spoken, blockIndex: thinkingBlock });
+                    const promoted = await promoteToRunning();
+                    if (!promoted) {
+                        this.broadcaster.broadcast({ type: "message.thinking", conversationId: conversation.id, messageId: assistant.id, delta, active: true, at: spoken, blockIndex: thinkingBlock });
+                    }
                     scheduleCheckpoint();
                 },
                 // AN EMPTY DELTA THAT ONLY CARRIES THE FLAG. `thinking_end` is a fact the browser needs and not
@@ -1324,6 +1333,12 @@ export class RunService {
         // 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);
+        }
         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" } : {}) });
         this.broadcaster.broadcastState();
@@ -1375,6 +1390,9 @@ export class RunService {
                 // waiting". The banner is cleared by the next `addUserMessage` so a stale reason cannot
                 // survive a retry into the same conversation.
                 await this.store.setFailureReason(conversationId, formatTurnFailure(error));
+                // The refusal is written for the reader, but the reader is not the only one who needs to know
+                // why a turn never started: the server log is where the stack survives.
+                console.warn("Super Pi turn refused before it started:", describeThrownWithStack(error));
                 // Status is restored here, not relied on the outer catch to handle: a preflight failure never
                 // opened a turn, so the right state is the one the conversation had a moment ago (idle). The
                 // outer catch would otherwise flip it to `failed`, which the reader would render as a turn
@@ -1424,6 +1442,9 @@ export class RunService {
             if (controller.signal.aborted)
                 return;
             await this.store.setFailureReason(conversation.id, formatTurnFailure(error));
+            // A turn that broke is the failure the reader will complain about, and the banner only carries
+            // the sentence. The stack goes to the server log, where it can still be found.
+            console.error("Super Pi turn failed:", describeThrownWithStack(error));
             throw error;
         }
         finally {
@@ -1460,8 +1481,8 @@ export class RunService {
      * and nothing more. Waiting out an arbitrarily long RUNNING turn would turn "send now" into "send
      * whenever the current answer finishes", which is what the queue is for.
      */
-    async awaitRunSlotReleased(conversationId, onlyWhileStopped = false) {
-        const deadline = Date.now() + 15_000;
+    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")
                 return;

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

@@ -147,6 +147,13 @@ export declare class ScheduledTaskService {
      * one that has to use it. A failure here is the task's failure - a model that Pi no longer offers
      * cannot be silently ignored, because the run would then happen on some other model and the panel
      * would say it succeeded.
+     *
+     * AND WHEN THERE IS NO OVERRIDE, THE DEFAULTS BEHIND IT GO ON THE CONVERSATION TOO. Clearing the
+     * override in the panel means 「跟着工作区默认走」, and the only way to honour that on a conversation
+     * that already ran with the override is to PUT THE DEFAULT BACK. The conversation's model is a
+     * copy-at-birth value (AGENTS.md: 建会话时把默认值盖到会话字段上，之后永不回查工作区), so "do
+     * nothing when there is no override" keeps the WITHDRAWN override pinned for good - and the panel
+     * says the run succeeded on a model the user just took away.
      */
     private applyConfiguration;
     /** Writes down how the run went, and tells the panel. */

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

@@ -302,14 +302,23 @@ export class ScheduledTaskService {
      * one that has to use it. A failure here is the task's failure - a model that Pi no longer offers
      * cannot be silently ignored, because the run would then happen on some other model and the panel
      * would say it succeeded.
+     *
+     * AND WHEN THERE IS NO OVERRIDE, THE DEFAULTS BEHIND IT GO ON THE CONVERSATION TOO. Clearing the
+     * override in the panel means 「跟着工作区默认走」, and the only way to honour that on a conversation
+     * that already ran with the override is to PUT THE DEFAULT BACK. The conversation's model is a
+     * copy-at-birth value (AGENTS.md: 建会话时把默认值盖到会话字段上，之后永不回查工作区), so "do
+     * nothing when there is no override" keeps the WITHDRAWN override pinned for good - and the panel
+     * says the run succeeded on a model the user just took away.
      */
     async applyConfiguration(task, conversationId) {
-        if (task.model) {
-            await this.conversationService.setModel(conversationId, task.model.provider, task.model.modelId);
-        }
-        if (task.agentId) {
-            await this.conversationService.setAgent(conversationId, task.agentId);
+        const state = this.store.snapshot();
+        const workspace = state.workspaces.find((item) => item.id === task.workspaceId);
+        const model = task.model ?? workspace?.defaultModel ?? state.defaultModel;
+        if (model) {
+            await this.conversationService.setModel(conversationId, model.provider, model.modelId);
         }
+        const agentId = task.agentId ?? workspace?.defaultAgentId ?? null;
+        await this.conversationService.setAgent(conversationId, agentId);
     }
     /** Writes down how the run went, and tells the panel. */
     async record(task, outcome) {

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

@@ -22,9 +22,8 @@ export declare class WorkspaceService {
     private readonly catalogService;
     private readonly runService;
     private readonly extensionUiService;
-    private readonly uploadsDir;
     private agentsDir;
-    constructor(store: Store, runtime: AgentRuntime, broadcaster: EventBroadcaster, catalogService: CatalogService, runService: RunService, extensionUiService: ExtensionUiService, uploadsDir: string, agentsDir: string | string[]);
+    constructor(store: Store, runtime: AgentRuntime, broadcaster: EventBroadcaster, catalogService: CatalogService, runService: RunService, extensionUiService: ExtensionUiService, agentsDir: string | string[]);
     setAgentsDir(dir: string | string[]): void;
     /**
      * Creates a new workspace.
@@ -35,8 +34,13 @@ export declare class WorkspaceService {
      */
     renameWorkspace(workspaceId: string, name: string): Promise<void>;
     /**
-     * Deletes a workspace and cascades cleanup to active runs, subagent runs,
-     * uploaded files, and stored conversations.
+     * Takes a workspace out of the sidebar. NOTHING IS DELETED.
+     *
+     * The conversations under it, the uploads attached to them and the workspace's own defaults all
+     * stay on disk: removing a workspace from the list is a soft unmount, and adding the same
+     * folder back brings the whole history with it. What does stop is the WORK: a turn that was still
+     * running cannot keep a model session alive behind a workspace the user can no longer see, and a
+     * pending question would wait for an answer the sidebar can no longer reach.
      */
     deleteWorkspace(workspaceId: string): Promise<void>;
     /**