@evandu/super-pi 0.1.99 → 0.1.101

package/dist/client/.super-pi-client-sources.json

@@ -24,5 +24,5 @@
     "src/client/types.ts": "6487df00c164370550b5977f9b23b17e22aff4bfb59dfe1e52200042340e3769",
     "src/client/vite-env.d.ts": "65996936fbb042915f7b74a200fcdde7e410f32a669b1ab9597cfaa4b0faddb5"
   },
-  "recordedAt": "2026-10-21T05:09:03.121Z"
+  "recordedAt": "2026-10-21T05:59:50.882Z"
 }

package/dist/server/store.js

@@ -902,7 +902,17 @@ export class Store {
         // the new turn starts: leaving it up would show "was interrupted, marked failed" above a conversation
         // that is visibly working again.
         delete conversation.error;
-        await this.persist();
+        // AN INCREMENTAL WRITE, NOT A FULL ONE. This line was the last full-state write on the hot path
+        // of every message, and it was in front of the broadcast that tells the browser a turn has
+        // started - so the size of the WHOLE state was the delay between clicking send and the stream
+        // tail saying 「等待 LLM 返回」. Measured: a full write of a 12MB state costs 62ms on a fast
+        // machine and seconds on a slow one, while the incremental write stays at 5ms regardless.
+        //
+        // The conversation's metadata (status, title, updatedAt) and its messages are exactly what
+        // changed, and the repository has an incremental path for each. The base snapshot every other
+        // conversation lives in is untouched by this call, so rewriting it buys nothing.
+        await this.persistMessages(conversation);
+        await this.persistMetadata(conversationId);
         return structuredClone(message);
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.99",
+  "version": "0.1.101",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",

package/scripts/diagnose.mjs

@@ -17,8 +17,8 @@
 // slow one; seconds are not. If the process count is zero and a span is still long, the time is not in
 // Super Pi, and this says so rather than leaving it to be guessed at.
 import { spawn } from "node:child_process";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
+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";
 
@@ -41,6 +41,39 @@ function atLeast(actual, required) {
   return true;
 }
 
+/**
+ * How big the REAL state is, and what a full write of it costs.
+ *
+ * WHY THIS IS HERE AND NOT IN THE MEASUREMENT ABOVE. The measurement above runs against a THROWAWAY
+ * data directory, so its state is empty and its writes are instant - which is exactly why it could
+ * not see the thing it was looking for. A real server holds every conversation a person has ever had,
+ * 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.
+ */
+function measureRealState(dataDir) {
+  const result = { path: "", bytes: 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;
+      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);
+      } 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;
+      }
+    } catch { /* unreadable is not a fact worth reporting */ }
+    break;
+  }
+  return result;
+}
+
 /**
  * Runs the diagnosis against a throwaway server and returns what it measured.
  *
@@ -72,7 +105,9 @@ export async function diagnose({ repositoryRoot, turns = 2, onProgress = () => {
   const stop = () => { try { server.kill(); } catch { /* already gone */ } };
 
   const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+  const realDataDir = process.env.SUPER_PI_DATA_DIR ?? join(homedir(), ".super-pi");
   const result = {
+    realState: measureRealState(realDataDir),
     node: process.versions.node,
     nodeOk: atLeast(process.versions.node, PI_NODE_REQUIREMENT),
     required: PI_NODE_REQUIREMENT,
@@ -121,6 +156,44 @@ export async function diagnose({ repositoryRoot, turns = 2, onProgress = () => {
     result.catalogSource = catalog.catalog?.source ?? catalog.source ?? "unknown";
     result.models = (catalog.catalog?.models ?? catalog.models ?? []).length;
 
+    // Span 1b: THE PICKER AFTER A WORKSPACE DEFAULT IS SET.
+    //
+    // THIS IS THE PATH THE FIRST MEASUREMENT MISSED, and it is the one most people are actually on.
+    // `createConversation` copies the workspace's default model onto the new conversation, and it
+    // VALIDATES that default against the catalog first - so creating a conversation with a default
+    // model READS THE CATALOG, and a picker opened afterwards asks for the LEVELS of that model, which
+    // is a different catalog key. A measurement that never sets a default model never sees any of it.
+    //
+    // The report says which path it measured, because a number for a path nobody is on is worse than
+    // no number at all.
+    const defaultModel = (catalog.catalog?.models ?? catalog.models ?? []).find((m) => m.modelId)
+      ?? (catalog.catalog?.defaultModel ?? catalog.defaultModel);
+    if (defaultModel) {
+      onProgress("setting a workspace default model, then creating a conversation...");
+      send({
+        type: "workspace.settings",
+        workspaceId: "workspace_default",
+        model: { provider: defaultModel.provider, modelId: defaultModel.modelId },
+        thinkingLevel: null,
+      });
+      await sleep(400);
+      const withDefaultStart = Date.now();
+      send({ type: "conversation.create", workspaceId: "workspace_default" });
+      const withDefault = await waitFor((e) => e.type === "state"
+        && e.state.conversations.length >= 2, "a conversation with the workspace default");
+      result.conversationWithDefaultMs = Date.now() - withDefaultStart;
+      const withDefaultConversation = events.filter((e) => e.type === "state").at(-1).state.conversations[0];
+      // And the picker for THAT conversation, which is the one a person actually opens.
+      const defaultPickerStart = Date.now();
+      send({ type: "catalog.fetch", conversationId: withDefaultConversation.id });
+      // The conversation id is a SIBLING of the catalog, not inside it - `broadcastCatalog` sends
+      // `{ type, catalog, conversationId }` - and reading it from the wrong place times out on a
+      // catalog that has already arrived.
+      await waitFor((e) => e.type === "model.catalog" && e.conversationId === withDefaultConversation.id,
+        "the catalog for the conversation with a default model");
+      result.pickerWithDefaultMs = Date.now() - defaultPickerStart;
+    }
+
     // Spans 2 and 3, per turn.
     result.turns = [];
     for (let turn = 1; turn <= turns; turn += 1) {
@@ -153,6 +226,65 @@ export async function diagnose({ repositoryRoot, turns = 2, onProgress = () => {
         reused: (added.match(/phase=session\.reused/g) ?? []).length,
       });
     }
+    // Span 4: THE INTERRUPT.
+    //
+    // The second thing people report is "打断并回答 → 开始回答还要好十秒", and it is a DIFFERENT
+    // chain from sending a message: it waits for the running turn to unwind, waits for its slot, and
+    // only then asks the model. Those first two waits are Super Pi's, and they are the ones that can
+    // be slow; the model's share is the same as any other turn.
+    //
+    // So it is measured as its own span, with a tool running so there is something to interrupt.
+    onProgress("measuring the interrupt...");
+    const interruptMark = events.length;
+    const interruptLogMark = log.length;
+    send({
+      type: "message.send",
+      conversationId: conversation.id,
+      content: '用 bash 运行：node -e "setTimeout(()=>{},20000)"。等它跑完再回复。',
+    });
+    let toolStarted = false;
+    const toolDeadline = Date.now() + 60000;
+    while (!toolStarted && Date.now() < toolDeadline) {
+      toolStarted = events.slice(interruptMark).some((e) => e.type === "message.tools");
+      if (!toolStarted) await sleep(30);
+    }
+    if (toolStarted) {
+      // Queue the message that the interrupt will answer.
+      send({ type: "message.send", conversationId: conversation.id, content: "被打断的那条：只回答「第二」两个字。" });
+      let queued = null;
+      const queueDeadline = Date.now() + 60000;
+      while (!queued && Date.now() < queueDeadline) {
+        queued = events.filter((e) => e.type === "state").at(-1)?.state?.conversations
+          ?.find((c) => c.id === conversation.id)?.messages
+          ?.find((m) => m.content?.includes("被打断的那条") && m.delivery === "waiting");
+        if (!queued) await sleep(30);
+      }
+      if (queued) {
+        await sleep(800);
+        const clicked = Date.now();
+        send({ type: "message.interrupt", conversationId: conversation.id, messageId: queued.id });
+        let interruptWaiting = 0;
+        try {
+          await waitFor((e, i) => i >= interruptMark && e.type === "state"
+            && e.state.conversations.find((c) => c.id === conversation.id)?.status === "waiting"
+            && Date.now() > clicked, "the interrupted turn to report waiting", 60000);
+          interruptWaiting = Date.now() - clicked;
+          await waitFor((e, i) => i >= interruptMark && e.type === "message.delta" && e.conversationId === conversation.id
+            && Date.now() > clicked + 50, "the interrupted turn's first character", 180000);
+        } catch { /* reported as not measured below */ }
+        const interruptText = Date.now() - clicked;
+        const interruptLog = log.slice(interruptLogMark);
+        result.interrupt = {
+          toWaitingMs: interruptWaiting || undefined,
+          toTextMs: interruptText,
+          modelMs: interruptText - (interruptWaiting || 0),
+          spawned: (interruptLog.match(/phase=pi\.spawned/g) ?? []).length,
+          built: (interruptLog.match(/phase=session\.build\.begin/g) ?? []).length,
+          reused: (interruptLog.match(/phase=session\.reused/g) ?? []).length,
+        };
+      }
+    }
+
     socket.close();
   } catch (error) {
     result.error = error instanceof Error ? error.message : String(error);
@@ -185,10 +317,27 @@ export function renderReport(result) {
   lines.push("");
   lines.push("  每一段耗时                    耗时      归属");
   lines.push(`  1. picker 有数据            ${ms(result.pickerMs)}   Super Pi   （catalog 读取）`);
+  if (typeof result.conversationWithDefaultMs === "number") {
+    lines.push(`  1b. 建会话（工作区有默认模型） ${ms(result.conversationWithDefaultMs)}   Super Pi   （建会话要校验默认模型，会再读一次 catalog）`);
+    lines.push(`  1c. 该会话的 picker        ${ms(result.pickerWithDefaultMs)}   Super Pi   （带默认模型时读的是另一份 catalog）`);
+  } else {
+    lines.push("  1b/1c. 未测：这次没有可用的模型来设工作区默认模型");
+  }
   for (const turn of result.turns ?? []) {
     lines.push(`     第${turn.turn}轮 发送 -> 等待中     ${ms(turn.toWaitingMs)}   Super Pi   （建会话 + 首个 prompt）`);
     lines.push(`     第${turn.turn}轮 等待中 -> 出字     ${ms(turn.modelMs)}   模型       （不是 Super Pi）`);
   }
+  if (result.interrupt) {
+    lines.push("");
+    lines.push("  打断（点「打断并回答」之后）：");
+    lines.push(`     点击 -> 新一轮报等待中     ${ms(result.interrupt.toWaitingMs)}   Super Pi   （等旧轮退完 + 等槽位）`);
+    lines.push(`     点击 -> 出字             ${ms(result.interrupt.toTextMs)}   整条链`);
+    lines.push(`     其中模型                 ${ms(result.interrupt.modelMs)}   模型       （不是 Super Pi）`);
+    lines.push(`     打断后启动的 Pi 进程数： ${result.interrupt.spawned}`);
+  } else {
+    lines.push("");
+    lines.push("  打断：未测（需要一次正在跑工具的轮次）");
+  }
   lines.push("");
   lines.push(`  catalog: ${result.catalogSource}，${result.models} 个模型`);
 
@@ -201,6 +350,21 @@ export function renderReport(result) {
   lines.push(`    建立的会话数：      ${built}`);
   lines.push(`    复用的会话数：      ${reused}`);
 
+  const real = result.realState;
+  if (real && real.path) {
+    lines.push("");
+    lines.push("  你真实的 state（上面那些数字是在一个全新的空目录上量的，看不到它）：");
+    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}`);
+    if (real.bytes > 1024 * 1024) {
+      lines.push("    这个体积的 state 如果每发一条消息都要全量写一遍，在慢机器上就是秒级——");
+      lines.push("    而那次写就挡在「服务端告诉浏览器回合开始了」之前。");
+    }
+  }
+
+
   lines.push("");
   if (!result.nodeOk) {
     lines.push(`  Node 版本低于 Pi 的要求（>= ${result.required}）。这一条本身就可能解释了前面几段的`);