@evandu/super-pi 0.1.101 → 0.1.103

package/dist/server/store.d.ts

@@ -78,6 +78,18 @@ export declare class Store {
     /** Opens an injected repository, retaining domain reconciliation here. */
     static openRepository(repository: AppStateRepository): Promise<Store>;
     setModelFilterRules(rules: import("./types.js").ModelFilterRule[]): Promise<void>;
+    /**
+     * Sets (or clears) the app-wide default model.
+     *
+     * `undefined` DELETES the key, for the same reason the workspace defaults do it that way: "follow
+     * Pi" has to be the ABSENCE of a value, not a frozen copy of whatever Pi's default was when the
+     * setting was saved. A stored copy would keep answering with a model the user had already
+     * removed, and Pi's own default may have changed underneath us in the meantime.
+     *
+     * The pair is written field by field, never as a spread, because the type declares exactly three
+     * fields and a spread would quietly start persisting whatever is added to `ModelSelection` next.
+     */
+    setDefaultModel(model?: ModelSelection): Promise<void>;
     snapshot(): AppState;
     createWorkspace(name: string, path?: string): Promise<Workspace>;
     renameWorkspace(workspaceId: string, name: string): Promise<Workspace>;
@@ -533,8 +545,14 @@ export declare 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.
      */
-    deliverWaitingMessage(conversationId: string, agentIdentity?: Message["agentIdentity"]): Promise<{
+    deliverWaitingMessage(conversationId: string, agentIdentity?: Message["agentIdentity"], messageId?: string): Promise<{
         user: Message;
         assistant: Message;
     } | undefined>;

package/dist/server/store.js

@@ -596,6 +596,31 @@ export class Store {
             throw error;
         }
     }
+    /**
+     * Sets (or clears) the app-wide default model.
+     *
+     * `undefined` DELETES the key, for the same reason the workspace defaults do it that way: "follow
+     * Pi" has to be the ABSENCE of a value, not a frozen copy of whatever Pi's default was when the
+     * setting was saved. A stored copy would keep answering with a model the user had already
+     * removed, and Pi's own default may have changed underneath us in the meantime.
+     *
+     * The pair is written field by field, never as a spread, because the type declares exactly three
+     * fields and a spread would quietly start persisting whatever is added to `ModelSelection` next.
+     */
+    async setDefaultModel(model) {
+        const previous = this.state.defaultModel;
+        if (model === undefined)
+            delete this.state.defaultModel;
+        else
+            this.state.defaultModel = { provider: model.provider, modelId: model.modelId, label: model.label };
+        try {
+            await this.persist();
+        }
+        catch (error) {
+            this.state.defaultModel = previous;
+            throw error;
+        }
+    }
     snapshot() { return structuredClone(this.state); }
     async createWorkspace(name, path) {
         const cleanName = name.trim();
@@ -1609,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/dist/server/types.d.ts

@@ -730,8 +730,19 @@ export type BackgroundTaskSummary = {
  * import and is erased at compile time, so it does not close a runtime cycle with the rules that
  * construct them - the same relationship `SubagentRun` already has with `subagent-runs.ts`.
  */
+/**
+ * `defaultModel` is the app-wide fallback model: the `provider/modelId` pair a NEW conversation gets
+ * when its workspace has no default of its own. It sits BELOW the workspace default and ABOVE Pi's own
+ * default, so the precedence at birth is workspace > app > Pi.
+ *
+ * It is a PAIR, never a provider and a model apart, for the same reason `ModelSelection` is a pair:
+ * Pi's `set_model` needs both halves, and half a selection is a selection Pi refuses. There is no
+ * separate "default provider" anywhere in this state: a provider is not a thing this app can be
+ * configured with, it is only the first half of a model id.
+ */
 export type AppState = {
     modelFilterRules?: ModelFilterRule[];
+    defaultModel?: ModelSelection;
     workspaces: Workspace[];
     conversations: Conversation[];
     subagentRuns: SubagentRun[];
@@ -862,6 +873,27 @@ export type ClientCommandBody =
 } | {
     type: "model.rules.set";
     rules: ModelFilterRule[];
+}
+/**
+ * Sets the app-wide default model. `null` clears it back to "Pi's own default" - the same
+ * "absence, not a frozen copy" convention the workspace defaults use, so removing the default
+ * really removes it instead of pinning whatever Pi's default happened to be when it was saved.
+ */
+ | {
+    type: "settings.defaultModel";
+    model: {
+        provider: string;
+        modelId: string;
+    } | null;
+}
+/**
+ * Asks for the model catalog WITHOUT a conversation, so the settings window can list every model Pi
+ * offers. A separate command from `catalog.fetch` because that one is scoped to a conversation and
+ * filtered by that workspace's model rules: reusing it here would either hide the models the panel
+ * must offer, or - worse - leak them into the composer picker, which is filtered for a reason.
+ */
+ | {
+    type: "catalog.fetchAll";
 } | {
     type: "workspace.create";
     name: string;
@@ -1287,6 +1319,17 @@ export type ServerEvent = {
     catalog: ModelCatalog;
     conversationId?: string;
 }
+/**
+ * The UNFILTERED catalog, for the settings window's model panel. A different event type from
+ * `model.catalog` on purpose: that one is scoped to a conversation and filtered by that
+ * workspace's model rules, and the settings panel must be able to offer the models the rules
+ * hide - while the composer picker must keep hiding them. One event carrying both would force
+ * one of the two to be wrong.
+ */
+ | {
+    type: "model.catalog.all";
+    catalog: ModelCatalog;
+}
 /**
  * The answer to conversation.autoRename. Carries a title OR an error and never both, because the client
  * has exactly two things to say about it: here is the new name, or here is why there isnt one.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.101",
+  "version": "0.1.103",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -75,6 +75,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",
@@ -90,6 +91,7 @@
     "scripts/theme-no-hardcoded-colours.test.mjs",
     "scripts/agent-config-regression.test.mjs",
     "scripts/model-filter.test.mjs",
+    "scripts/settings-default-model.test.mjs",
     "scripts/active-memory.test.mjs",
     "scripts/knowledge-base.test.mjs",
     "scripts/tool-runner.test.mjs",
@@ -135,6 +137,7 @@
     "scripts/theme-contrast.test.mjs",
     "scripts/theme-switch-state.test.mjs",
     "scripts/settings-window-structure.test.mjs",
+    "scripts/settings-model-browser.test.mjs",
     "scripts/file-tab-selected-contrast.test.mjs",
     "scripts/help-window.test.mjs",
     "scripts/composer-regression-browser.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.
  *
@@ -216,6 +302,8 @@ export async function diagnose({ repositoryRoot, turns = 2, onProgress = () => {
       }
       await sleep(250);
       const added = log.slice(logMark);
+      const promptSize = /systemPrompt=(\d+)B/.exec(added)?.[1];
+      if (promptSize) result.systemPromptBytes = Number(promptSize);
       result.turns.push({
         turn,
         toWaitingMs: waiting - sent,
@@ -274,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,
@@ -328,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   （等旧轮退完 + 等槽位）`);
@@ -350,6 +451,13 @@ export function renderReport(result) {
   lines.push(`    建立的会话数：      ${built}`);
   lines.push(`    复用的会话数：      ${reused}`);
 
+  if (result.systemPromptBytes) {
+    lines.push("");
+    lines.push(`  发给模型的系统提示：${(result.systemPromptBytes / 1024).toFixed(1)}KB`);
+    lines.push("  这是每一轮都要先传过去的东西。模型的 provider 得先收下它才能回答，");
+    lines.push("  所以在慢链路上，它直接就是首字之前的那几秒。");
+  }
+
   const real = result.realState;
   if (real && real.path) {
     lines.push("");
@@ -357,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("    在慢机器上每一次广播都是秒级，而一轮里会广播好几次。");
     }
   }