@evandu/super-pi 0.1.100 → 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:29:09.656Z"
+  "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.100",
+  "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,
@@ -315,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}）。这一条本身就可能解释了前面几段的`);