@evandu/super-pi 0.1.100 → 0.1.102

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-gjLqMWYT.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-8olCbCbk.css">
+    <script type="module" crossorigin src="/assets/index-pD4FaDWr.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-DDkbPYLz.css">
   </head>
   <body>
     <div id="root"></div>

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

@@ -58,6 +58,27 @@ export declare class CatalogService {
      * Broadcasts subagents to connected clients.
      */
     broadcastSubagents(): Promise<void>;
+    /**
+     * Sets the app-wide default model, or clears it back to "Pi's own default".
+     *
+     * THE MODEL IS CHECKED AGAINST PI'S OWN CATALOG, for the same reason the workspace default is:
+     * a default Pi does not offer would be stamped onto every new conversation, and the first turn
+     * would fail on a model the user never chose. The check happens at SAVE time rather than at
+     * birth time so the user hears about it while they are still looking at the list.
+     *
+     * The label is taken from the catalog row rather than from the request, so the stored value
+     * always carries the display name Pi itself reported.
+     */
+    setDefaultModel(model: {
+        provider: string;
+        modelId: string;
+    } | null): Promise<void>;
+    /**
+     * The UNFILTERED catalog, for the settings window's model panel. Deliberately not the scoped one:
+     * the panel is where the app-wide default is chosen, and a workspace's model rules must not hide
+     * models from the place that decides what the app-wide default may be.
+     */
+    getAllCatalog(): Promise<ModelCatalog>;
     /**
      * Helper formatting an error when a requested model/thinking level is not offered by Pi.
      */

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

@@ -165,6 +165,43 @@ export class CatalogService {
     async broadcastSubagents() {
         this.broadcaster.broadcast({ type: "subagent.catalog", catalog: await this.subagentCatalog() });
     }
+    /**
+     * Sets the app-wide default model, or clears it back to "Pi's own default".
+     *
+     * THE MODEL IS CHECKED AGAINST PI'S OWN CATALOG, for the same reason the workspace default is:
+     * a default Pi does not offer would be stamped onto every new conversation, and the first turn
+     * would fail on a model the user never chose. The check happens at SAVE time rather than at
+     * birth time so the user hears about it while they are still looking at the list.
+     *
+     * The label is taken from the catalog row rather than from the request, so the stored value
+     * always carries the display name Pi itself reported.
+     */
+    async setDefaultModel(model) {
+        if (!this.store)
+            throw new Error("Store unavailable");
+        let selection;
+        if (model) {
+            const catalog = await this.runtime.catalog();
+            const option = catalog.source === "pi"
+                ? catalog.models.find(item => item.provider === model.provider && item.modelId === model.modelId)
+                : undefined;
+            if (catalog.source === "pi" && !option)
+                throw this.notOffered(`模型 ${model.provider}/${model.modelId}`, catalog);
+            selection = option
+                ? { provider: option.provider, modelId: option.modelId, label: option.label }
+                : { provider: model.provider, modelId: model.modelId, label: model.modelId };
+        }
+        await this.store.setDefaultModel(selection);
+        this.broadcaster.broadcastState();
+    }
+    /**
+     * The UNFILTERED catalog, for the settings window's model panel. Deliberately not the scoped one:
+     * the panel is where the app-wide default is chosen, and a workspace's model rules must not hide
+     * models from the place that decides what the app-wide default may be.
+     */
+    async getAllCatalog() {
+        return this.runtime.catalog();
+    }
     /**
      * Helper formatting an error when a requested model/thinking level is not offered by Pi.
      */

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

@@ -42,7 +42,13 @@ export class ConversationService {
         // stamp a dead selection onto every new conversation: the scoped catalog probe would
         // fail and leave the model/thinking controls unavailable. A missing or invalid default
         // means "follow Pi's current default" for this newly-created conversation.
-        let model = workspace.defaultModel;
+        // THE PRECEDENCE AT BIRTH IS WORKSPACE > APP > Pi. The app-wide default is a FALLBACK, not an
+        // override: a workspace that has a default of its own keeps it, and only a workspace with none
+        // inherits the app-wide one. Both are copied onto the conversation and never consulted again,
+        // so changing either default never rewrites an existing conversation.
+        const appDefault = this.store.snapshot().defaultModel;
+        const inheritsAppDefault = !workspace.defaultModel && Boolean(appDefault);
+        let model = workspace.defaultModel ?? appDefault;
         let thinkingLevel = workspace.defaultThinkingLevel;
         const catalog = model || thinkingLevel ? await this.runtime.catalog() : undefined;
         if (catalog?.source === "pi" && model) {
@@ -60,6 +66,19 @@ export class ConversationService {
                 }
             }
         }
+        if (inheritsAppDefault && model) {
+            // An app-wide default belongs to no workspace, so the workspace's model rules are checked HERE,
+            // at birth, where the workspace is finally known. A default the rules forbid is not stamped
+            // on: the conversation starts on Pi's own default instead, which is the same outcome as a
+            // workspace default that pointed at a model Pi no longer offers.
+            try {
+                assertModelAllowed(this.store.snapshot().modelFilterRules, workspace, model);
+            }
+            catch {
+                model = undefined;
+                thinkingLevel = undefined;
+            }
+        }
         const resolved = workspace.defaultAgentId
             ? await this.resolveAgentConfiguration({ id: workspaceId, model, thinkingLevel }, workspace.defaultAgentId, workspaceId)
             : { model, thinkingLevel };

package/dist/server/command-handler.js

@@ -65,6 +65,10 @@ export class CommandHandler {
             await this.catalogService.setModelRules(command.rules);
             return;
         }
+        if (command.type === "settings.defaultModel") {
+            await this.catalogService.setDefaultModel(command.model);
+            return;
+        }
         if (command.type === "workspace.create") {
             return await this.workspaceService.createWorkspace(command.name, command.path);
         }
@@ -239,6 +243,14 @@ export class CommandHandler {
                 await this.catalogService.broadcastCatalog(undefined, command.conversationId);
             return;
         }
+        // The unfiltered catalog, for the settings window's model panel. Sent to the ASKING socket only:
+        // it is a panel's private list, and broadcasting it would overwrite every open conversation's
+        // filtered catalog with one that no workspace's rules apply to.
+        if (command.type === "catalog.fetchAll") {
+            if (sendToSocket)
+                sendToSocket({ type: "model.catalog.all", catalog: await this.catalogService.getAllCatalog() });
+            return;
+        }
         if (command.type === "agent.catalog.fetch") {
             await this.catalogService.broadcastAgents();
             return;

package/dist/server/pi-session.d.ts

@@ -184,6 +184,15 @@ export interface PiSessionLike {
     readonly sessionFile?: string | undefined;
     /** The id of the session. */
     readonly sessionId?: string | undefined;
+    /**
+     * The system prompt Pi will send with every turn.
+     *
+     * READ FOR ITS SIZE, not for its content. The time to first token is a function of how many bytes
+     * the provider has to receive before it can answer, so this number is what turns "the model was
+     * slow" into a fact. Pi builds the prompt from the agent directory, the skills, the extensions and
+     * the context files - none of which Super Pi controls.
+     */
+    readonly systemPrompt?: string | undefined;
     /**
      * The model the session is running on.
      *

package/dist/server/runtime.js

@@ -755,12 +755,29 @@ export class PiRpcRuntime {
             abortTurn();
         else
             signal.addEventListener("abort", onAbort, { once: true });
+        // HOW BIG IS THE PROMPT WE ARE ABOUT TO SEND. The time to first token is a function of
+        // this, not of anything Super Pi does, and it is the number that explains a slow first turn: the
+        // model's provider has to RECEIVE the whole thing before it can answer, so a big prompt on a slow
+        // link is seconds before the first word.
+        //
+        // It is traced rather than computed, because the system prompt is what Pi builds from the agent
+        // directory, the skills, the extensions and the context files - none of which Super Pi controls,
+        // and all of which the person who installed them controls.
+        const promptSize = () => {
+            try {
+                const system = typeof session.systemPrompt === "string" ? session.systemPrompt : "";
+                return `systemPrompt=${Buffer.byteLength(system, "utf8")}B`;
+            }
+            catch {
+                return "systemPrompt=?";
+            }
+        };
         let firstTextSeen = false;
         const finished = (async () => {
             try {
                 const promptOptions = images?.length
-                    ? { images: images, preflightResult: () => traceLatency(conversation.id, "session.prompt.accepted", latencyStartedAt) }
-                    : { preflightResult: () => traceLatency(conversation.id, "session.prompt.accepted", latencyStartedAt) };
+                    ? { images: images, preflightResult: () => traceLatency(conversation.id, "session.prompt.accepted", latencyStartedAt, promptSize()) }
+                    : { preflightResult: () => traceLatency(conversation.id, "session.prompt.accepted", latencyStartedAt, promptSize()) };
                 await session.prompt(prompt, promptOptions);
                 // `prompt()` RETURNING IS NOT THE TURN ENDING. Pi's `prompt` resolves when the message has
                 // been ACCEPTED and the run has been started; the agent is still streaming, still executing

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>;

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();
@@ -902,7 +927,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/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.100",
+  "version": "0.1.102",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -90,6 +90,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 +136,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

@@ -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,
@@ -181,6 +216,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,
@@ -315,6 +352,28 @@ 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("");
+    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}）。这一条本身就可能解释了前面几段的`);