@evandu/super-pi 0.1.133 → 0.1.136

package/dist/server/providers.js

@@ -741,6 +741,7 @@ export async function fetchRemoteModels(input) {
         candidates.push(`${cleanBase}/v1/models`, `${cleanBase}/models`);
     }
     let lastError = "";
+    let lastCause;
     let payload = null;
     for (const candidate of candidates) {
         try {
@@ -758,11 +759,35 @@ export async function fetchRemoteModels(input) {
         }
         catch (error) {
             lastError = error instanceof Error ? error.message : String(error);
+            lastCause = error;
         }
     }
     if (!payload) {
-        throw new Error(`无法从远程服务获取模型列表 (${lastError || "请求超时或无法连接"})`);
-    }
+        // THE CAUSE, NOT JUST "fetch failed". `fetch` reports every transport-level problem - a refused
+        // connection, a reset, an aborted timeout - as the same one-word "fetch failed", so a user staring
+        // at 「无法从远程服务获取模型列表 (fetch failed)」 learns nothing and neither does the log. The
+        // cause is where the truth is: "The operation was aborted due to timeout" and "connect
+        // ECONNREFUSED" are two different problems with two different fixes.
+        const cause = lastCause instanceof Error
+            ? (lastCause.cause instanceof Error ? lastCause.cause.message : lastCause.cause instanceof Object && lastCause.cause !== null ? String(lastCause.cause.code ?? "") : undefined)
+            : undefined;
+        throw new Error(`无法从远程服务获取模型列表 (${lastError || "请求超时或无法连接"}${cause ? `：${cause}` : ""})`);
+    }
+    return parseRemoteModels(payload);
+}
+/**
+ * THE ANSWER, READ.
+ *
+ * Split out of `fetchRemoteModels` so that the part worth asserting - what a provider's answer MEANS -
+ * can be tested without a network in between. A remote provider answers in three shapes (a bare array,
+ * `{data: [...]}` for OpenAI, `{models: [...]}` for Ollama), and each entry names itself with `id`,
+ * `name` or `model`; what the panel shows next to it - whether the model reasons, whether it takes
+ * images - is inferred from the name, because that is all most providers tell us.
+ *
+ * `fetchRemoteModels` is the transport; this is the reading. Keeping them apart means the reading can
+ * be pinned exactly, and a slow machine can never turn a parsing question into a timeout.
+ */
+export function parseRemoteModels(payload) {
     const rawList = Array.isArray(payload)
         ? payload
         : Array.isArray(payload.data)

package/dist/server/runtime.js

@@ -941,7 +941,46 @@ export class PiRpcRuntime {
                 const promptOptions = images?.length
                     ? { images: images, preflightResult: () => traceLatency(conversation.id, "session.prompt.accepted", latencyStartedAt, promptSize()) }
                     : { preflightResult: () => traceLatency(conversation.id, "session.prompt.accepted", latencyStartedAt, promptSize()) };
+                // A STOP THAT ARRIVED WHILE THIS SESSION WAS BEING BUILT MUST NOT SEND THE PROMPT.
+                //
+                // The window between "the person pressed stop" and "the prompt goes out" is the whole session
+                // build: Pi's resource loader, the extensions, the transcript, the model lookup - seconds, on a
+                // cold session. The abort listener above already noticed the cancellation, but `session.abort()`
+                // on a session that has not started running is a no-op, so nothing stopped the prompt that was
+                // about to be sent: the model was asked a question the person had already cancelled, and it
+                // answered it - which is why pressing stop looked like it "took effect" only once the reply was
+                // over.
+                //
+                // So the cancellation is checked HERE, at the last moment before the prompt goes out, and a
+                // cancelled turn ends with no question asked at all.
+                //
+                // `turnController.signal.aborted` is the OTHER half of the same fact: the turn's own controller
+                // is what `abortTurn()` trips, and it is tripped by the very same cancellation. Both are checked
+                // because they are tripped by different readers - one by the person, one by Pi's abort.
+                if (signal.aborted || turnController.signal.aborted) {
+                    queue.push({ kind: "end" });
+                    return;
+                }
                 await session.prompt(prompt, promptOptions);
+                // THE CANCELLATION MAY HAVE ARRIVED WHILE PI WAS PREPARING THE PROMPT.
+                //
+                // `session.prompt()` is not one step: it runs Pi's input handlers (the extensions' hooks -
+                // Super Pi's own memory search is one of them), the compaction check and the auth check before
+                // the agent's run starts. An abort that lands in that window finds a session that has NOT
+                // started running, so Pi's abort has nothing to abort - and the prompt goes on to the model,
+                // which answers a question the person cancelled.
+                //
+                // The run IS started by the time `prompt()` resolves, so the abort is said AGAIN here. The
+                // second one is the one that lands.
+                if (signal.aborted) {
+                    // The same 5s backstop `runtime.stop` uses: a wedged session must not hang the turn forever.
+                    await Promise.race([
+                        session.abort().catch((error) => {
+                            console.warn(`PiRpcRuntime: aborting the session of ${conversation.id} after a late cancellation threw: ${error instanceof Error ? error.message : "unknown error"}`);
+                        }),
+                        new Promise((resolvePromise) => setTimeout(resolvePromise, 5_000)),
+                    ]);
+                }
                 // `prompt()` RETURNING IS NOT THE TURN ENDING. Pi's `prompt` resolves when the message has
                 // been ACCEPTED and the run has been started; the agent is still streaming, still executing
                 // tools, still settling. A turn that ended here would release the reader while the model was
@@ -1437,6 +1476,13 @@ export class PiRpcRuntime {
             const imagePayloads = this.options.uploadsDir && images?.length
                 ? await loadConversationImages(this.options.uploadsDir, conversation.id, images)
                 : undefined;
+            // A STOP THAT ARRIVED WHILE THE CHILD WAS STARTING MUST NOT SEND THE PROMPT.
+            //
+            // The same gap the session path has, and the same reason: `abort` above writes an `abort`
+            // command to a child that has not been given anything yet, so it does nothing - and the prompt
+            // went out anyway, and the model answered a question the person had already cancelled.
+            if (signal.aborted)
+                return;
             channel.write({ id: "prompt", type: "prompt", message: prompt, ...(imagePayloads?.length ? { images: imagePayloads } : {}) });
             traceLatency(conversation.id, "prompt.sent", latencyStartedAt);
             let settled = false;

package/dist/server/store.d.ts

@@ -11,6 +11,16 @@ import type { AppState, Conversation, Message, MessageDelivery, MessageImage, Mo
  *  disk, or a failed write would leave a conversation whose model context is silently empty. The runtime is
  *  therefore handed the id and the store is handed the same one back. See `ForkRequest.forkedConversationId`. */
 export declare function newConversationId(): string;
+/**
+ * ONE FOLDER, ONE KEY.
+ *
+ * The same directory reaches the app spelled several ways - `F:\code\app` and `F:/code/app/` and
+ * `f:\code\app` are one folder - and two workspaces for one folder are one project split in half.
+ * The key folds the separators and the trailing slash away, and folds case away only where the
+ * filesystem folds it too: Windows and macOS treat `F:\Code` and `f:\code` as one directory, Linux
+ * does not, and pretending otherwise would merge two real projects into one.
+ */
+export declare function workspacePathKey(path: string): string;
 /**
  * How many SETTLED sub-agent runs `state.json` keeps, so the file cannot grow without bound.
  *
@@ -86,6 +96,28 @@ export declare class Store {
     static open(filePath: string): Promise<Store>;
     /** Opens an injected repository, retaining domain reconciliation here. */
     static openRepository(repository: AppStateRepository): Promise<Store>;
+    /**
+     * THE MODEL FILTER RULES, WITHOUT CLONING THE STATE TO READ THEM.
+     *
+     * `snapshot()` deep-clones the WHOLE application - every workspace, every conversation, every
+     * message of every conversation - and the model filter check needs ONE small array. Reading that
+     * array through a full clone is the difference between a few hundred bytes and the entire
+     * transcript of the app, on the path that runs every time a message is sent.
+     *
+     * So the rules get their own narrow reader. It returns a COPY of the array (the caller may keep
+     * it, and the store's own state must not change under it), and the individual rules are treated
+     * as read-only - which is what the filter does with them.
+     */
+    modelFilterRules(): import("./types.js").ModelFilterRule[];
+    /**
+     * THE WORKSPACE A CONVERSATION BELONGS TO, WITHOUT CLONING THE STATE TO FIND ONE ROW.
+     *
+     * The same argument as the rules above: the filter needs to know WHICH workspace the conversation
+     * is in (the rules are per workspace), and the only way to know that today is to clone everything
+     * and look. This returns a shallow copy of the one workspace - cheap, and detached enough that a
+     * caller cannot reach into the store's state through it.
+     */
+    workspaceForConversation(conversationId: string): Workspace | undefined;
     setModelFilterRules(rules: import("./types.js").ModelFilterRule[]): Promise<void>;
     /**
      * Sets (or clears) the app-wide default model.
@@ -101,6 +133,15 @@ export declare class Store {
     setDefaultModel(model?: ModelSelection): Promise<void>;
     setTerminalShell(shell?: import("./types.js").TerminalShell): Promise<void>;
     snapshot(): AppState;
+    /** Cheap scalar/entity reads for hot paths. Never expose the live mutable state object. */
+    hasWorkspace(workspaceId: string): boolean;
+    conversationStatus(conversationId: string): Conversation["status"] | undefined;
+    question(conversationId: string, messageId: string, index: number): ToolCallQuestion | undefined;
+    pendingQuestion(conversationId: string): {
+        messageId: string;
+        index: number;
+        question: ToolCallQuestion;
+    } | undefined;
     /**
      * Whether a conversation already holds a message with this id.
      *
@@ -126,6 +167,17 @@ export declare class Store {
         conversation: Conversation;
         workspace: Workspace;
     } | undefined;
+    /**
+     * THE PHYSICAL DIRECTORY IS THE WORKSPACE'S IDENTITY.
+     *
+     * A workspace is a folder, not a row in a table: two workspaces pointing at the same directory are
+     * the same project, and the app used to mint a fresh UUID for each one. That is what broke
+     * re-adding a workspace - the new id matched none of the conversations that belonged to that
+     * directory, so the history was unreachable (and, before the soft unmount, actually deleted).
+     *
+     * So the same folder always means the same workspace id, and the id is what the conversations
+     * point at.
+     */
     createWorkspace(name: string, path?: string): Promise<Workspace>;
     renameWorkspace(workspaceId: string, name: string): Promise<Workspace>;
     /**
@@ -151,7 +203,38 @@ export declare class Store {
         thinkingLevel?: string;
         agentId?: string | null;
     }): Promise<Workspace>;
+    /**
+     * TAKES A WORKSPACE OUT OF THE SIDEBAR. IT DOES NOT DELETE ANYTHING.
+     *
+     * This used to cascade: the workspace row AND every conversation that pointed at it were erased
+     * from the state, in one persist. That made the most natural thing a user could do - remove a
+     * workspace to tidy the sidebar, then add the same folder back - silently destroy the history of
+     * that project, and there was no way to get it back.
+     *
+     * So the removal is a SOFT UNMOUNT, the same shape as a session's archive: the workspace row
+     * stays (with `closedAt` on it), the conversations stay, the uploads stay, and nothing is
+     * broadcast for either (see `clientState`). Adding the same folder again re-opens the very same
+     * workspace - same id, same conversations - which is the whole point of the physical path being
+     * the workspace's identity.
+     *
+     * The returned list is the conversations that were STOPPED, not deleted: a turn that was still
+     * running under a workspace that just left the sidebar cannot keep burning a model session
+     * behind the user's back, and a pending question would otherwise wait for an answer that the
+     * sidebar can no longer reach.
+     */
     deleteWorkspace(workspaceId: string): Promise<string[]>;
+    /**
+     * THE STATE THE CLIENT IS ALLOWED TO SEE.
+     *
+     * `snapshot()` is the truth of what the store HOLDS; this is the truth of what is ON SCREEN. The
+     * difference is the closed workspaces: one that was removed from the sidebar is still in the store
+     * - that is exactly why re-adding the folder brings its history back - but it is not part of the
+     * app any more, so neither it nor its conversations are broadcast.
+     *
+     * Filtering HERE, in one place, rather than in every reader, is what keeps the client dumb: the
+     * sidebar renders `state.workspaces` and never has to know that a closed workspace exists.
+     */
+    clientState(): AppState;
     createConversation(workspaceId: string, configuration?: {
         agentId?: string;
         model?: ModelSelection | null;

package/dist/server/store.js

@@ -11,6 +11,19 @@ function id(prefix) { return `${prefix}_${crypto.randomUUID()}`; }
  *  disk, or a failed write would leave a conversation whose model context is silently empty. The runtime is
  *  therefore handed the id and the store is handed the same one back. See `ForkRequest.forkedConversationId`. */
 export function newConversationId() { return id("conversation"); }
+/**
+ * ONE FOLDER, ONE KEY.
+ *
+ * The same directory reaches the app spelled several ways - `F:\code\app` and `F:/code/app/` and
+ * `f:\code\app` are one folder - and two workspaces for one folder are one project split in half.
+ * The key folds the separators and the trailing slash away, and folds case away only where the
+ * filesystem folds it too: Windows and macOS treat `F:\Code` and `f:\code` as one directory, Linux
+ * does not, and pretending otherwise would merge two real projects into one.
+ */
+export function workspacePathKey(path) {
+    const folded = path.trim().replace(/\\/g, "/").replace(/\/+$/, "");
+    return process.platform === "linux" ? folded : folded.toLowerCase();
+}
 function now() { return new Date().toISOString(); }
 const DEFAULT_CONVERSATION_TITLE = "\u65b0\u4f1a\u8bdd";
 /** Whether a value survives a `new Date()` round-trip. `createdAt` is typed string, but state.json only
@@ -676,6 +689,34 @@ export class Store {
             return new Store(repository, { workspaces: [], conversations: [], subagentRuns: [], backgroundTasks: [] });
         }
     }
+    /**
+     * THE MODEL FILTER RULES, WITHOUT CLONING THE STATE TO READ THEM.
+     *
+     * `snapshot()` deep-clones the WHOLE application - every workspace, every conversation, every
+     * message of every conversation - and the model filter check needs ONE small array. Reading that
+     * array through a full clone is the difference between a few hundred bytes and the entire
+     * transcript of the app, on the path that runs every time a message is sent.
+     *
+     * So the rules get their own narrow reader. It returns a COPY of the array (the caller may keep
+     * it, and the store's own state must not change under it), and the individual rules are treated
+     * as read-only - which is what the filter does with them.
+     */
+    modelFilterRules() {
+        return this.state.modelFilterRules ? [...this.state.modelFilterRules] : [];
+    }
+    /**
+     * THE WORKSPACE A CONVERSATION BELONGS TO, WITHOUT CLONING THE STATE TO FIND ONE ROW.
+     *
+     * The same argument as the rules above: the filter needs to know WHICH workspace the conversation
+     * is in (the rules are per workspace), and the only way to know that today is to clone everything
+     * and look. This returns a shallow copy of the one workspace - cheap, and detached enough that a
+     * caller cannot reach into the store's state through it.
+     */
+    workspaceForConversation(conversationId) {
+        const conversation = this.state.conversations.find((item) => item.id === conversationId);
+        const workspace = this.state.workspaces.find((item) => item.id === conversation?.workspaceId);
+        return workspace ? { ...workspace } : undefined;
+    }
     async setModelFilterRules(rules) {
         if (!Array.isArray(rules) || rules.some(rule => !rule || typeof rule.id !== "string" || typeof rule.workspacePattern !== "string" || typeof rule.modelPattern !== "string" || (rule.label !== undefined && typeof rule.label !== "string")))
             throw new Error("模型过滤规则格式不合法");
@@ -735,6 +776,35 @@ export class Store {
             console.warn(`[super-pi latency] phase=state.snapshot bytes=${JSON.stringify(value).length} cloneMs=${Math.round(performance.now() - startedAt)}`);
         return value;
     }
+    /** Cheap scalar/entity reads for hot paths. Never expose the live mutable state object. */
+    hasWorkspace(workspaceId) {
+        return this.state.workspaces.some((workspace) => workspace.id === workspaceId);
+    }
+    conversationStatus(conversationId) {
+        return this.state.conversations.find((conversation) => conversation.id === conversationId)?.status;
+    }
+    question(conversationId, messageId, index) {
+        const question = this.state.conversations.find((conversation) => conversation.id === conversationId)
+            ?.messages.find((message) => message.id === messageId)?.toolCalls?.[index]?.question;
+        return question ? structuredClone(question) : undefined;
+    }
+    pendingQuestion(conversationId) {
+        const conversation = this.state.conversations.find((item) => item.id === conversationId);
+        if (!conversation)
+            return undefined;
+        for (let messageIndex = conversation.messages.length - 1; messageIndex >= 0; messageIndex -= 1) {
+            const message = conversation.messages[messageIndex];
+            if (message.role !== "assistant")
+                continue;
+            for (let index = (message.toolCalls?.length ?? 0) - 1; index >= 0; index -= 1) {
+                const question = message.toolCalls?.[index]?.question;
+                if (message.toolCalls?.[index]?.label === "question" && question?.status === "pending") {
+                    return { messageId: message.id, index, question: structuredClone(question) };
+                }
+            }
+        }
+        return undefined;
+    }
     /**
      * Whether a conversation already holds a message with this id.
      *
@@ -767,6 +837,17 @@ export class Store {
             return undefined;
         return { conversation: structuredClone(conversation), workspace: structuredClone(workspace) };
     }
+    /**
+     * THE PHYSICAL DIRECTORY IS THE WORKSPACE'S IDENTITY.
+     *
+     * A workspace is a folder, not a row in a table: two workspaces pointing at the same directory are
+     * the same project, and the app used to mint a fresh UUID for each one. That is what broke
+     * re-adding a workspace - the new id matched none of the conversations that belonged to that
+     * directory, so the history was unreachable (and, before the soft unmount, actually deleted).
+     *
+     * So the same folder always means the same workspace id, and the id is what the conversations
+     * point at.
+     */
     async createWorkspace(name, path) {
         const cleanName = name.trim();
         if (!cleanName || cleanName.length > 80)
@@ -774,6 +855,19 @@ export class Store {
         const cleanPath = path?.trim() || process.cwd();
         if (cleanPath.length > 500)
             throw new Error("工作区路径太长了。");
+        // THE SAME FOLDER IS THE SAME WORKSPACE. Adding a directory that is already here re-opens it
+        // instead of forking a second one: the id stays, the conversations stay attached to it, and the
+        // name is left alone (renaming is an explicit action elsewhere, and silently renaming a
+        // workspace because someone typed a name into the add dialog would be its own surprise).
+        const existing = this.state.workspaces.find((item) => workspacePathKey(item.path) === workspacePathKey(cleanPath));
+        if (existing) {
+            if (existing.closedAt) {
+                delete existing.closedAt;
+                existing.updatedAt = now();
+                await this.persist();
+            }
+            return structuredClone(existing);
+        }
         const workspace = { id: id("workspace"), name: cleanName, path: cleanPath, updatedAt: now() };
         this.state.workspaces.push(workspace);
         await this.persist();
@@ -830,23 +924,55 @@ export class Store {
         await this.persist();
         return structuredClone(workspace);
     }
+    /**
+     * TAKES A WORKSPACE OUT OF THE SIDEBAR. IT DOES NOT DELETE ANYTHING.
+     *
+     * This used to cascade: the workspace row AND every conversation that pointed at it were erased
+     * from the state, in one persist. That made the most natural thing a user could do - remove a
+     * workspace to tidy the sidebar, then add the same folder back - silently destroy the history of
+     * that project, and there was no way to get it back.
+     *
+     * So the removal is a SOFT UNMOUNT, the same shape as a session's archive: the workspace row
+     * stays (with `closedAt` on it), the conversations stay, the uploads stay, and nothing is
+     * broadcast for either (see `clientState`). Adding the same folder again re-opens the very same
+     * workspace - same id, same conversations - which is the whole point of the physical path being
+     * the workspace's identity.
+     *
+     * The returned list is the conversations that were STOPPED, not deleted: a turn that was still
+     * running under a workspace that just left the sidebar cannot keep burning a model session
+     * behind the user's back, and a pending question would otherwise wait for an answer that the
+     * sidebar can no longer reach.
+     */
     async deleteWorkspace(workspaceId) {
-        if (!this.state.workspaces.some((item) => item.id === workspaceId))
+        const workspace = this.state.workspaces.find((item) => item.id === workspaceId);
+        if (!workspace)
             throw new Error("找不到这个工作区。");
-        // Deleting the LAST workspace is allowed: a fresh store starts with zero (see `openRepository`), so
-        // "at least one" was an artifact of the old first-run seed, and the client's zero-workspace empty
-        // state is the onboarding path back in.
-        // Cascade: workspaces and conversations live in one state.json, so this single atomic persist removes
-        // both together. A waiting message needs no sweep of its own any more - it is a message inside one of
-        // the conversations being removed, so it goes with its container, which is the whole reason it is a
-        // better shape than an entry keyed by conversation id in a separate array: that array needed this
-        // cascade to avoid naming a conversation that no longer exists, and could not have been trusted to
-        // get it right on its own.
-        const doomed = new Set(this.state.conversations.filter((item) => item.workspaceId === workspaceId).map((item) => item.id));
-        this.state.workspaces = this.state.workspaces.filter((item) => item.id !== workspaceId);
-        this.state.conversations = this.state.conversations.filter((item) => item.workspaceId !== workspaceId);
+        if (workspace.closedAt)
+            return [];
+        workspace.closedAt = now();
+        workspace.updatedAt = workspace.closedAt;
         await this.persist();
-        return [...doomed];
+        return [];
+    }
+    /**
+     * THE STATE THE CLIENT IS ALLOWED TO SEE.
+     *
+     * `snapshot()` is the truth of what the store HOLDS; this is the truth of what is ON SCREEN. The
+     * difference is the closed workspaces: one that was removed from the sidebar is still in the store
+     * - that is exactly why re-adding the folder brings its history back - but it is not part of the
+     * app any more, so neither it nor its conversations are broadcast.
+     *
+     * Filtering HERE, in one place, rather than in every reader, is what keeps the client dumb: the
+     * sidebar renders `state.workspaces` and never has to know that a closed workspace exists.
+     */
+    clientState() {
+        const state = this.snapshot();
+        const closed = new Set(state.workspaces.filter((item) => item.closedAt).map((item) => item.id));
+        if (!closed.size)
+            return state;
+        state.workspaces = state.workspaces.filter((item) => !closed.has(item.id));
+        state.conversations = state.conversations.filter((item) => !closed.has(item.workspaceId));
+        return state;
     }
     async createConversation(workspaceId, configuration) {
         const workspace = this.state.workspaces.find((item) => item.id === workspaceId);

package/dist/server/subagents.js

@@ -421,8 +421,16 @@ export class SubagentSupervisor {
                     }
                     if (!record)
                         break;
-                    if (record.type === "response" && record.id === "prompt" && record.success === false)
-                        throw new Error(`Pi rejected the sub-agent task: ${record.error ?? "no reason given"}`);
+                    // THE RECEIPT FOR OUR OWN PROMPT IS A KNOWN RECORD, NOT AN UNKNOWN ONE. Pi answers every
+                    // command with `type:"response"`, so the successful receipt for the prompt we just wrote is
+                    // part of the protocol - and treating it as unrecognised made every ordinary sub-agent run
+                    // log a false alarm ("unhandled child record response - consumed without action"). A FAILED
+                    // receipt is the run's failure and is thrown; a successful one is simply consumed.
+                    if (record.type === "response" && record.id === "prompt") {
+                        if (record.success === false)
+                            throw new Error(`Pi rejected the sub-agent task: ${record.error ?? "no reason given"}`);
+                        continue;
+                    }
                     if (record.type === "message_update") {
                         const event = record.assistantMessageEvent;
                         // `text_delta` is the only inner event that is output. `start` and `done` are the boundaries

package/dist/server/types.d.ts

@@ -586,6 +586,12 @@ export type AgentCatalog = {
  * the conversation's own field, an existing conversation is therefore immune to later workspace
  * edits, and deleting the workspace default cannot reach back into sessions already born.
  */
+/**
+ * `closedAt` marks a workspace that was REMOVED FROM THE SIDEBAR but is not gone: its conversations
+ * are still on disk and still belong to it. The removal is a soft unmount, exactly like a session's
+ * `archivedAt` - a state marker, never a deletion - and the marker is what lets the same physical
+ * directory be added again later and come back with its history instead of with an empty list.
+ */
 export type Workspace = {
     id: string;
     name: string;
@@ -594,6 +600,7 @@ export type Workspace = {
     defaultModel?: ModelSelection;
     defaultThinkingLevel?: string;
     defaultAgentId?: string;
+    closedAt?: string;
 };
 /**
  * Usage accumulated across one sub-agent run. `turns` is the number of finished assistant messages,
@@ -1469,6 +1476,9 @@ export type ChangedFile = {
     at: number;
 };
 export type ServerEvent = {
+    type: "run.stopping";
+    conversationId: string;
+} | {
     type: "tools.updated";
     tools: MountedToolSummary[];
 }

package/dist/server/ws-server.d.ts

@@ -13,6 +13,9 @@ export declare class WsBroadcaster implements EventBroadcaster {
     private readonly sockets;
     private readonly coalescedSockets;
     private readonly pendingStreams;
+    private cachedState?;
+    private cachedStatePayload?;
+    private stateFlushScheduled;
     constructor(getState: () => AppState);
     register(socket: WebSocket): void;
     unregister(socket: WebSocket): void;

package/dist/server/ws-server.js

@@ -1,5 +1,6 @@
 import { WebSocket, WebSocketServer } from "ws";
 import { isAuthorized } from "./http-server.js";
+import { describeThrown, describeThrownWithStack } from "./failure-text.js";
 /**
  * Concrete implementation of EventBroadcaster delivering server events
  * across active WebSocket connections.
@@ -9,6 +10,9 @@ export class WsBroadcaster {
     sockets = new Set();
     coalescedSockets = new Set();
     pendingStreams = new Map();
+    cachedState;
+    cachedStatePayload;
+    stateFlushScheduled = false;
     constructor(getState) {
         this.getState = getState;
     }
@@ -90,7 +94,23 @@ export class WsBroadcaster {
         }
     }
     broadcastState() {
-        this.broadcast({ type: "state", state: this.getState() });
+        if (this.stateFlushScheduled)
+            return;
+        this.stateFlushScheduled = true;
+        queueMicrotask(() => {
+            this.stateFlushScheduled = false;
+            this.cachedState = this.getState();
+            this.cachedStatePayload = JSON.stringify({ type: "state", state: this.cachedState });
+            const payload = this.cachedStatePayload;
+            for (const socket of this.sockets) {
+                if (socket.readyState !== WebSocket.OPEN)
+                    continue;
+                this.flushStreaming(socket);
+                socket.send(payload);
+            }
+            this.cachedState = undefined;
+            this.cachedStatePayload = undefined;
+        });
     }
     getStateSnapshot() {
         return this.getState();
@@ -228,7 +248,8 @@ export class WsServer {
                     parsed = JSON.parse(raw.toString());
                 }
                 catch {
-                    socket.send(JSON.stringify({ type: "error", message: "command failed" }));
+                    console.error("Super Pi command error: received a frame that is not valid JSON");
+                    socket.send(JSON.stringify({ type: "error", message: "收到一条无法解析的命令，已忽略。" }));
                     return;
                 }
                 if (parsed.type === "stream.configure") {
@@ -264,13 +285,21 @@ export class WsServer {
                         }
                     }
                     catch (error) {
+                        // A FAILED COMMAND WRITES ITSELF DOWN BEFORE IT ANSWERS.
+                        //
+                        // The server runs detached with its streams thrown away, so `console.error` here is not
+                        // decoration: the logger tees it into `<dataDir>/logs/server.log`, which is the only place
+                        // the stack survives. The browser gets the reason (never a stand-in phrase like
+                        // `command failed`), because the reader is the one who has to act on it.
+                        console.error("Super Pi command error:", describeThrownWithStack(error));
+                        const reason = describeThrown(error);
                         if (command?.operationRequestId) {
-                            socket.send(JSON.stringify({ type: "operation.result", requestId: command.operationRequestId, ok: false, message: error instanceof Error ? error.message : String(error) }));
+                            socket.send(JSON.stringify({ type: "operation.result", requestId: command.operationRequestId, ok: false, message: reason }));
                             return;
                         }
                         socket.send(JSON.stringify({
                             type: "error",
-                            message: error instanceof Error ? error.message : "command failed",
+                            message: reason || "服务端没有说明这次失败的原因。",
                         }));
                     }
                     finally {
@@ -284,11 +313,11 @@ export class WsServer {
                 };
                 if (runIndependently)
                     void execute().catch((error) => {
-                        console.warn(`Super Pi: command dispatch failed: ${error instanceof Error ? error.message : "unknown error"}`);
+                        console.error("Super Pi command dispatch failed:", describeThrownWithStack(error));
                     });
                 else
                     commandQueue = commandQueue.then(execute).catch((error) => {
-                        console.warn(`Super Pi: command dispatch failed: ${error instanceof Error ? error.message : "unknown error"}`);
+                        console.error("Super Pi command dispatch failed:", describeThrownWithStack(error));
                     });
             });
         });