@evandu/super-pi 0.1.108 → 0.1.110

package/dist/client/index.html

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

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

@@ -190,6 +190,12 @@ export declare class RunService {
     askQuestion(conversationId: string): Promise<unknown>;
     /**
      * Resolves the conversation and workspace synchronously for a run.
+     *
+     * TWO CLONES, NOT TWO SNAPSHOTS. This used to call `store.snapshot()` twice - once for the
+     * conversation and once for the workspace - and a snapshot deep-clones the ENTIRE application
+     * state: every other conversation, every message in it, every tool result. It runs a handful of
+     * times per turn, twice of them before the frame that tells the browser a turn has started, so the
+     * size of the whole state was part of the wait between clicking 发送 and seeing 等待 LLM 返回.
      */
     turnContext(conversationId: string): {
         conversation: Conversation;

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

@@ -488,15 +488,24 @@ export class RunService {
     }
     /**
      * Resolves the conversation and workspace synchronously for a run.
+     *
+     * TWO CLONES, NOT TWO SNAPSHOTS. This used to call `store.snapshot()` twice - once for the
+     * conversation and once for the workspace - and a snapshot deep-clones the ENTIRE application
+     * state: every other conversation, every message in it, every tool result. It runs a handful of
+     * times per turn, twice of them before the frame that tells the browser a turn has started, so the
+     * size of the whole state was part of the wait between clicking 发送 and seeing 等待 LLM 返回.
      */
     turnContext(conversationId) {
-        const conversation = this.store.snapshot().conversations.find((item) => item.id === conversationId);
-        if (!conversation)
-            throw new Error("会话不存在");
-        const workspace = this.store.snapshot().workspaces.find((item) => item.id === conversation.workspaceId);
-        if (!workspace)
+        const context = this.store.turnContext(conversationId);
+        if (!context) {
+            // One snapshot, on the error path only, to say WHICH of the two is missing - the messages are
+            // what a person acts on, and this path never runs for a conversation that is merely being used.
+            const conversation = this.store.snapshot().conversations.find((item) => item.id === conversationId);
+            if (!conversation)
+                throw new Error("会话不存在");
             throw new Error(`会话所属的工作区 ${conversation.workspaceId} 已不存在，拒绝运行`);
-        return { conversation, workspace };
+        }
+        return context;
     }
     /**
      * Resolves conversation and workspace working directory for subagent dispatch.

package/dist/server/persistence/sqlite-state-repository.js

@@ -51,9 +51,14 @@ export class SqliteStateRepository {
             // An authoritative order row set means this conversation's transcript is rebuilt from it, rather
             // than from the base snapshot's array. That is what makes a WITHDRAWN message stay withdrawn: the
             // snapshot still lists it, and reading the array back would resurrect words the user took back.
+            //
+            // THE CONTENT COMES FROM THE `messages` TABLE WHEN IT HAS THE ROW, and only the ORDER comes from
+            // here. `message.replace` (the 50ms streaming checkpoint) writes that table alone, so preferring
+            // this table's copy of the JSON would reload a message at whatever content it had when the order
+            // was last rewritten - the placeholder an assistant message was born with, not what it streamed.
             const ordered = this.db.prepare("SELECT id,position,json FROM message_order WHERE conversation=? ORDER BY position").all(conversation.id);
             if (ordered.length) {
-                conversation.messages = ordered.map(row => JSON.parse(String(row.json)));
+                conversation.messages = ordered.map((row) => overrides.get(String(row.id)) ?? JSON.parse(String(row.json)));
             }
             else {
                 if (!Array.isArray(conversation.messages))
@@ -114,20 +119,52 @@ export class SqliteStateRepository {
                     write.run(name, JSON.stringify(value));
             }
             else if (transaction.kind === "conversation.messages") {
-                // Rewrite the WHOLE array, order included. A per-id upsert cannot express this transaction: it
-                // both reorders (a waiting message moving within its group) and removes (a withdrawn one), and
-                // both change which messages exist. Replacing the set is the honest write, and it is one
-                // transaction because a reader that saw the order without the content, or the content without
-                // the order, would see a transcript that was never true.
-                this.db.prepare("DELETE FROM message_order WHERE conversation=?").run(transaction.conversationId);
-                this.db.prepare("DELETE FROM messages WHERE conversation=?").run(transaction.conversationId);
+                // A DIFF, NOT A REWRITE. This used to DELETE the conversation's rows and re-INSERT every
+                // message - stringified twice, once per table - on every single send, under
+                // `synchronous=FULL`. That is O(transcript) work in front of the broadcast that tells the
+                // browser a turn has started, so a long conversation showed 「就绪」 for seconds after the
+                // click. A send changes ONE message (the appended user row); the rest are already on disk,
+                // byte for byte.
+                //
+                // THE ORDER TABLE IS STILL AUTHORITATIVE FOR ORDER, and its presence is what makes a
+                // withdrawn message stay withdrawn (the base snapshot still lists it). When it has no rows
+                // yet, the base array is authoritative - that is the `load` contract - so this falls back to
+                // the full write ONCE to materialise the order, and every later write is a diff.
+                const conversationId = transaction.conversationId;
+                const stored = new Map(this.db.prepare("SELECT id,json FROM messages WHERE conversation=?").all(conversationId)
+                    .map((row) => [String(row.id), String(row.json)]));
+                const ordered = this.db.prepare("SELECT id,position FROM message_order WHERE conversation=? ORDER BY position").all(conversationId);
                 const upsertMessage = this.db.prepare("INSERT INTO messages VALUES(?,?,?) ON CONFLICT(conversation,id) DO UPDATE SET json=excluded.json");
-                const insertOrdered = this.db.prepare("INSERT INTO message_order VALUES(?,?,?,?)");
-                transaction.messages.forEach((message, position) => {
-                    const json = JSON.stringify(message);
-                    upsertMessage.run(transaction.conversationId, message.id, json);
-                    insertOrdered.run(transaction.conversationId, message.id, position, json);
-                });
+                if (ordered.length === 0) {
+                    const insertOrdered = this.db.prepare("INSERT INTO message_order VALUES(?,?,?,?)");
+                    transaction.messages.forEach((message, position) => {
+                        const json = JSON.stringify(message);
+                        upsertMessage.run(conversationId, message.id, json);
+                        insertOrdered.run(conversationId, message.id, position, json);
+                    });
+                }
+                else {
+                    const nextIds = new Set(transaction.messages.map((message) => message.id));
+                    const deleteMessage = this.db.prepare("DELETE FROM messages WHERE conversation=? AND id=?");
+                    const deleteOrder = this.db.prepare("DELETE FROM message_order WHERE conversation=? AND id=?");
+                    for (const row of ordered) {
+                        if (nextIds.has(String(row.id)))
+                            continue;
+                        deleteMessage.run(conversationId, row.id);
+                        deleteOrder.run(conversationId, row.id);
+                    }
+                    const upsertOrder = this.db.prepare("INSERT INTO message_order VALUES(?,?,?,?) ON CONFLICT(conversation,id) DO UPDATE SET position=excluded.position, json=excluded.json");
+                    const positions = new Map(ordered.map((row) => [String(row.id), Number(row.position)]));
+                    transaction.messages.forEach((message, position) => {
+                        const json = JSON.stringify(message);
+                        if (stored.get(message.id) !== json)
+                            upsertMessage.run(conversationId, message.id, json);
+                        // An unchanged message at an unchanged position needs NO write at all. A pure append
+                        // therefore costs exactly one message row plus one order row.
+                        if (positions.get(message.id) !== position)
+                            upsertOrder.run(conversationId, message.id, position, json);
+                    });
+                }
                 // The stamp is WRITTEN, not cleared. Opening a turn moves `updatedAt`, and this is the only write
                 // that can record it; clearing the overlay instead would leave the reopened conversation reporting
                 // whatever the base snapshot held, which is the value the server had already decided was wrong.

package/dist/server/store.d.ts

@@ -91,6 +91,22 @@ export declare class Store {
      */
     setDefaultModel(model?: ModelSelection): Promise<void>;
     snapshot(): AppState;
+    /**
+     * One conversation and its workspace, as DETACHED copies, without cloning the whole state.
+     *
+     * The alternative - what the run path used to do - was two `snapshot()` calls, and `snapshot()`
+     * deep-clones every conversation, every message and every tool result in the app. That is the
+     * shape of the bug it fixes: reading one conversation's model cost O(entire state), and it sat on
+     * the path between a click on 发送 and the frame that tells the browser a turn has started.
+     *
+     * The two objects are still CLONES, because every caller of this is allowed to keep them after the
+     * store has moved on (a streamed turn holds its conversation for minutes), and handing out live
+     * references would turn the first such caller into a corruption bug that only shows up under load.
+     */
+    turnContext(conversationId: string): {
+        conversation: Conversation;
+        workspace: Workspace;
+    } | undefined;
     createWorkspace(name: string, path?: string): Promise<Workspace>;
     renameWorkspace(workspaceId: string, name: string): Promise<Workspace>;
     /**

package/dist/server/store.js

@@ -684,6 +684,27 @@ export class Store {
         }
     }
     snapshot() { return structuredClone(this.state); }
+    /**
+     * One conversation and its workspace, as DETACHED copies, without cloning the whole state.
+     *
+     * The alternative - what the run path used to do - was two `snapshot()` calls, and `snapshot()`
+     * deep-clones every conversation, every message and every tool result in the app. That is the
+     * shape of the bug it fixes: reading one conversation's model cost O(entire state), and it sat on
+     * the path between a click on 发送 and the frame that tells the browser a turn has started.
+     *
+     * The two objects are still CLONES, because every caller of this is allowed to keep them after the
+     * store has moved on (a streamed turn holds its conversation for minutes), and handing out live
+     * references would turn the first such caller into a corruption bug that only shows up under load.
+     */
+    turnContext(conversationId) {
+        const conversation = this.state.conversations.find((item) => item.id === conversationId);
+        if (!conversation)
+            return undefined;
+        const workspace = this.state.workspaces.find((item) => item.id === conversation.workspaceId);
+        if (!workspace)
+            return undefined;
+        return { conversation: structuredClone(conversation), workspace: structuredClone(workspace) };
+    }
     async createWorkspace(name, path) {
         const cleanName = name.trim();
         if (!cleanName || cleanName.length > 80)

package/dist/server/ws-server.js

@@ -64,6 +64,16 @@ export class WsBroadcaster {
     }
     broadcast(event) {
         const streaming = event.type === "message.delta" || event.type === "message.thinking";
+        /**
+         * SERIALIZED ONCE, NOT ONCE PER SOCKET. A `state` frame carries the whole application state, so
+         * `JSON.stringify` on it is the most expensive thing this method does - and every open tab used
+         * to pay for its own copy of the same string. The bytes are identical (no socket-specific field),
+         * so the string is built once and handed to every socket.
+         *
+         * Stream deltas stay per-event: they are coalesced per socket, so there is no single payload to
+         * share, and their cost is one small string.
+         */
+        const payload = streaming ? undefined : JSON.stringify(event);
         for (const socket of this.sockets) {
             if (socket.readyState !== WebSocket.OPEN)
                 continue;
@@ -72,7 +82,7 @@ export class WsBroadcaster {
             else {
                 // A state/tool/lifecycle event is a transcript boundary. Flush its preceding text first.
                 this.flushStreaming(socket);
-                socket.send(JSON.stringify(event));
+                socket.send(payload ?? JSON.stringify(event));
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.108",
+  "version": "0.1.110",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -95,6 +95,7 @@
     "scripts/tool-register-env.test.mjs",
     "scripts/bg-task-zombie.test.mjs",
     "scripts/scoped-sidebar-tabs.test.mjs",
+    "scripts/git-diff-view.test.mjs",
     "scripts/fork-server.test.mjs",
     "scripts/styles-no-dangling.test.mjs",
     "scripts/theme-no-hardcoded-colours.test.mjs",
@@ -163,7 +164,21 @@
     "scripts/knowledge-base-browser.test.mjs"
   ],
   "dependencies": {
+    "@codemirror/commands": "^6.11.1",
+    "@codemirror/lang-css": "^6.3.1",
+    "@codemirror/lang-go": "^6.0.1",
+    "@codemirror/lang-html": "^6.4.12",
+    "@codemirror/lang-javascript": "^6.2.5",
+    "@codemirror/lang-json": "^6.0.2",
+    "@codemirror/lang-markdown": "^6.5.2",
+    "@codemirror/lang-python": "^6.2.1",
+    "@codemirror/lang-rust": "^6.0.2",
+    "@codemirror/language": "^6.13.1",
+    "@codemirror/search": "^6.7.2",
+    "@codemirror/state": "^6.7.6",
+    "@codemirror/view": "^6.43.15",
     "@earendil-works/pi-coding-agent": "^0.86.1",
+    "@git-diff-view/react": "^0.1.8",
     "@types/diff": "^5.2.3",
     "@xterm/addon-fit": "^0.11.0",
     "@xterm/xterm": "^6.0.0",