@evandu/super-pi 0.1.102 → 0.1.104

package/dist/server/store.js

@@ -1634,17 +1634,27 @@ export class Store {
      * was written into the transcript when the user pressed send, long before Pi ever saw it - and it stays
      * exactly where it was, now with the agent answering it. Deleting it is what made a steered reply appear
      * with no question above it.
+     *
+     * `messageId` says WHICH message Pi picked up, for the case where position cannot answer it. A message
+     * handed to Pi's follow-up queue was never CLAIMED here - it is still `waiting`, because Super Pi keeps
+     * it in its own list so the user can still withdraw it - and a conversation can hold a `waiting` message
+     * and a `sending` one at the same time. The caller resolves the delivery by the text Pi announced,
+     * which is the same text Pi itself matched on.
      */
-    async deliverWaitingMessage(conversationId, agentIdentity) {
+    async deliverWaitingMessage(conversationId, agentIdentity, messageId) {
         const conversation = this.requireConversation(conversationId);
         // Looks for the single message Pi is currently answering. A `role: "tool"` 后台回传 that has been
         // steered or taken is on the same delivery state machine as a user message, so it is the answer
         // target too; the assistant placeholder still lands directly below it and the role/identity is read
         // from the conversation (not the message) when the turn opens.
-        const index = conversation.messages.findIndex((item) => (item.role === "user" || item.role === "tool") && item.delivery === "sending");
+        const index = messageId
+            ? conversation.messages.findIndex((item) => item.id === messageId)
+            : conversation.messages.findIndex((item) => (item.role === "user" || item.role === "tool") && item.delivery === "sending");
         if (index < 0)
             return undefined;
         const user = conversation.messages[index];
+        if (user.role !== "user" && user.role !== "tool")
+            return undefined;
         delete user.delivery;
         const assistant = { id: id("message"), role: "assistant", content: "", createdAt: now(), ...(agentIdentity ? { agentIdentity: structuredClone(agentIdentity) } : {}) };
         conversation.messages.splice(index + 1, 0, assistant);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.102",
+  "version": "0.1.104",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -43,6 +43,8 @@
     "scripts/stream-checkpoint.test.mjs",
     "scripts/stream-transport.test.mjs",
     "scripts/pi-session.test.mjs",
+    "scripts/pi-model-switch.test.mjs",
+    "scripts/pi-thinking-levels.test.mjs",
     "scripts/diagnose-cli.test.mjs",
     "scripts/lan-access.test.mjs",
     "scripts/terminal-pty.test.mjs",
@@ -75,6 +77,7 @@
     "scripts/agent-vis-records.test.mjs",
     "scripts/queue-store.test.mjs",
     "scripts/followup.test.mjs",
+    "scripts/pi-followup-queue.test.mjs",
     "scripts/md-render.test.mjs",
     "scripts/revert-session-format.test.mjs",
     "scripts/revert-session-file.test.mjs",

package/scripts/diagnose.mjs

@@ -21,6 +21,7 @@ import { mkdtempSync, rmSync, existsSync, statSync, readFileSync } from "node:fs
 import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
+import { createRequire } from "node:module";
 
 /** The Node version Pi requires. Below it, module loading and jiti transpiling are measurably slower. */
 const PI_NODE_REQUIREMENT = "22.19.0";
@@ -50,23 +51,42 @@ function atLeast(actual, required) {
  * and a message used to cost a full write of all of it before the browser was told the turn had
  * started. The size of that state is invisible from a fresh install and decisive on a real one, so it
  * is reported from the REAL data directory, read-only, and the write is measured on a COPY.
+ *
+ * THE NUMBER THAT MATTERS IS THE STATE, NOT THE FILE. An earlier version of this report called the
+ * SQLite FILE size "the state", and that is a different number: the file holds the base snapshot AND
+ * the incremental overlay tables, and the overlay is never pruned, so the file grows with every write
+ * while the state the BROWSER RECEIVES does not grow the same way. The number that costs time is the
+ * one that is cloned (`store.snapshot()`), serialised (`JSON.stringify`) and parsed (`JSON.parse` in
+ * the browser) on every state broadcast - so that is what is measured here, by rebuilding the state
+ * out of the database and measuring its JSON.
  */
 function measureRealState(dataDir) {
-  const result = { path: "", bytes: 0, conversations: 0, messages: 0, fullWriteMs: undefined };
+  const result = { path: "", bytes: 0, fileBytes: 0, conversations: 0, messages: 0, fullWriteMs: undefined };
   for (const name of ["state.sqlite", "state.json"]) {
     const path = join(dataDir, name);
     if (!existsSync(path)) continue;
     result.path = path;
     try {
-      result.bytes = statSync(path).size;
+      result.fileBytes = statSync(path).size;
       if (name === "state.json") {
         const parsed = JSON.parse(readFileSync(path, "utf8"));
         result.conversations = parsed.conversations?.length ?? 0;
         result.messages = (parsed.conversations ?? []).reduce((sum, c) => sum + (c.messages?.length ?? 0), 0);
+        // THE SIZE THAT IS ACTUALLY SENT. The browser gets this JSON, not the file.
+        result.bytes = Buffer.byteLength(readFileSync(path, "utf8"), "utf8");
       } else {
-        // The SQLite file holds the base snapshot AND the incremental overlays, so its size is the
-        // closest cheap proxy for how much state there is.
-        result.bytes = statSync(path).size;
+        // THE SQLITE STATE, REBUILT AND MEASURED. The repository's own loader is the authority on what
+        // the state IS, so the report does not guess at it: the database is opened READ-ONLY, the
+        // overlays are folded onto the base snapshot the way `load()` folds them, and the result is
+        // measured as JSON - the same bytes a state broadcast carries.
+        const measured = measureSqliteState(path);
+        if (measured.bytes > 0) {
+          result.bytes = measured.bytes;
+          result.conversations = measured.conversations;
+          result.messages = measured.messages;
+        } else {
+          result.bytes = result.fileBytes;
+        }
       }
     } catch { /* unreadable is not a fact worth reporting */ }
     break;
@@ -74,6 +94,72 @@ function measureRealState(dataDir) {
   return result;
 }
 
+/**
+ * The size of the state a SQLite store holds, measured as the JSON a broadcast would carry.
+ *
+ * READ-ONLY, and it opens its OWN connection rather than the server's: a report must not disturb the
+ * session someone is in the middle of, and a second read-only connection sees a consistent snapshot
+ * without taking any lock the server needs.
+ */
+function measureSqliteState(path) {
+  let db;
+  const empty = { bytes: 0, conversations: 0, messages: 0 };
+  try {
+    const require = createRequire(import.meta.url);
+    const { DatabaseSync } = require("node:sqlite");
+    db = new DatabaseSync(path, { readOnly: true });
+    const row = db.prepare("SELECT json FROM state WHERE id=1").get();
+    if (!row) return empty;
+    const state = JSON.parse(String(row.json));
+    if (!Array.isArray(state.conversations)) state.conversations = [];
+    // THE OVERLAYS, folded the way `load()` folds them: a conversation's metadata replaces its fields
+    // except its messages, and its messages are the union of the base array and the overlay rows - with
+    // the authoritative order rows winning when they are there.
+    const metadata = db.prepare("SELECT conversation,json FROM metadata").all();
+    const overrides = db.prepare("SELECT conversation,id,json FROM messages").all();
+    const ordered = db.prepare("SELECT conversation,id,position,json FROM message_order").all();
+    const byConversation = new Map();
+    for (const item of overrides) {
+      const list = byConversation.get(String(item.conversation)) ?? new Map();
+      list.set(String(item.id), JSON.parse(String(item.json)));
+      byConversation.set(String(item.conversation), list);
+    }
+    const orderByConversation = new Map();
+    for (const item of ordered) {
+      const list = orderByConversation.get(String(item.conversation)) ?? [];
+      list.push({ position: Number(item.position), message: JSON.parse(String(item.json)) });
+      orderByConversation.set(String(item.conversation), list);
+    }
+    for (const item of metadata) {
+      const conversation = state.conversations.find((entry) => entry.id === String(item.conversation));
+      if (!conversation) continue;
+      const messages = conversation.messages;
+      for (const key of Object.keys(conversation)) Reflect.deleteProperty(conversation, key);
+      Object.assign(conversation, JSON.parse(String(item.json)), { messages });
+    }
+    for (const conversation of state.conversations) {
+      const map = byConversation.get(conversation.id) ?? new Map();
+      const order = orderByConversation.get(conversation.id) ?? [];
+      if (order.length) {
+        conversation.messages = order.sort((a, b) => a.position - b.position).map((entry) => entry.message);
+      } else if (Array.isArray(conversation.messages)) {
+        conversation.messages = conversation.messages.map((message) => map.get(message.id) ?? message);
+      } else {
+        conversation.messages = [];
+      }
+    }
+    return {
+      bytes: Buffer.byteLength(JSON.stringify(state), "utf8"),
+      conversations: state.conversations.length,
+      messages: state.conversations.reduce((sum, conversation) => sum + (conversation.messages?.length ?? 0), 0),
+    };
+  } catch {
+    return empty;
+  } finally {
+    try { db?.close(); } catch { /* already closed */ }
+  }
+}
+
 /**
  * Runs the diagnosis against a throwaway server and returns what it measured.
  *
@@ -276,6 +362,14 @@ export async function diagnose({ repositoryRoot, turns = 2, onProgress = () => {
         } catch { /* reported as not measured below */ }
         const interruptText = Date.now() - clicked;
         const interruptLog = log.slice(interruptLogMark);
+        // The whole trace of the interrupt, in order. It is kept because the interrupt is the one path
+        // whose cost has turned out to be surprising, and a number without the phases around it cannot
+        // say which phase the number belongs to.
+        result.interruptTrace = interruptLog
+          .split("\n")
+          .filter((line) => line.includes("[super-pi latency]"))
+          .map((line) => line.replace(/.*\[super-pi latency\] /, "").trim())
+          .slice(0, 24);
         result.interrupt = {
           toWaitingMs: interruptWaiting || undefined,
           toTextMs: interruptText,
@@ -330,6 +424,11 @@ export function renderReport(result) {
     lines.push(`     第${turn.turn}轮 等待中 -> 出字     ${ms(turn.modelMs)}   模型       （不是 Super Pi）`);
   }
   if (result.interrupt) {
+    if (Array.isArray(result.interruptTrace) && result.interruptTrace.length) {
+      lines.push("    打断时的完整阶段（按顺序）：");
+      for (const entry of result.interruptTrace) lines.push(`      ${entry}`);
+    }
+
     lines.push("");
     lines.push("  打断（点「打断并回答」之后）：");
     lines.push(`     点击 -> 新一轮报等待中     ${ms(result.interrupt.toWaitingMs)}   Super Pi   （等旧轮退完 + 等槽位）`);
@@ -366,10 +465,16 @@ export function renderReport(result) {
     lines.push(`    ${real.path}`);
     const megabytes = (real.bytes / 1024 / 1024).toFixed(2);
     const shape = real.conversations ? `，${real.conversations} 个会话，${real.messages} 条消息` : "";
-    lines.push(`    大小 ${megabytes}MB${shape}`);
+    lines.push(`    浏览器每次收到的那份 state：${megabytes}MB${shape}`);
+    if (real.fileBytes && real.fileBytes !== real.bytes) {
+      lines.push(`    数据库文件本身：${(real.fileBytes / 1024 / 1024).toFixed(2)}MB`);
+      lines.push("    （文件比 state 大是因为它还存着增量写的那几层，那些层从不被清理；");
+      lines.push("      真正花时间的是上面那个数字——每次广播都要克隆它、序列化它、");
+      lines.push("      再在浏览器里解析一遍。）");
+    }
     if (real.bytes > 1024 * 1024) {
-      lines.push("    这个体积的 state 如果每发一条消息都要全量写一遍，在慢机器上就是秒级——");
-      lines.push("    而那次写就挡在「服务端告诉浏览器回合开始了」之前。");
+      lines.push("    这个体积的 state 每变一次就要整份克隆 + 整份序列化 + 浏览器整份解析，");
+      lines.push("    在慢机器上每一次广播都是秒级，而一轮里会广播好几次。");
     }
   }