@evandu/super-pi 0.1.99 → 0.1.100

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:29:09.656Z"
 }

package/package.json

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

package/scripts/diagnose.mjs

@@ -121,6 +121,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 +191,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 +282,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} 个模型`);