@evandu/super-pi 0.1.127 → 0.1.129

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

@@ -210,6 +210,15 @@ export interface PiSessionLike {
      * message for later", and the caller falls back to answering it as a turn of its own.
      */
     followUp?(message: string, images?: unknown[]): Promise<"queued" | "handled">;
+    sendCustomMessage?(message: {
+        customType: string;
+        content: unknown;
+        display?: string;
+        details?: unknown;
+    }, options?: {
+        triggerTurn?: boolean;
+        deliverAs?: "steer" | "followUp" | "nextTurn";
+    }): Promise<void>;
     /**
      * Removes every message Pi is holding in its steering and follow-up queues, and returns what was
      * removed.

package/dist/server/pi-session.js

@@ -231,7 +231,15 @@ export async function createPiSession(creation) {
     const sdk = await loadSdk();
     traceSession(creation.sessionId, "sdk.load.end", startedAt);
     const agentDir = creation.agentDir ?? defaultAgentDir();
-    return withEnvironment(creation.extensionEnv, async () => {
+    // Extension credentials are per-session capabilities. Do not temporarily mutate process.env here:
+    // two concurrent session creations otherwise race and can capture each other's capability.
+    const inlinePaths = creation.extensionPaths.filter((path) => /super-pi-(task|memory|knowledge)/.test(path.replaceAll("\\", "/")));
+    const externalPaths = creation.extensionPaths.filter((path) => !inlinePaths.includes(path));
+    const extensionFactories = await Promise.all(inlinePaths.map(async (path) => {
+        const mod = await import(pathToFileURL(path).href);
+        return async (pi) => mod.default?.(pi, creation.extensionEnv);
+    }));
+    return (async () => {
         // THE AGENT'S PROMPT. Pi's loader takes the same two shapes the command line took: a `systemPrompt`
         // that REPLACES Pi's own, and an `appendSystemPrompt` list of files that are ADDED to it. An agent
         // that says `promptMode: replace` gets the first, and one that says nothing gets the second - the
@@ -241,7 +249,8 @@ export async function createPiSession(creation) {
         const loader = new sdk.DefaultResourceLoader({
             cwd: creation.cwd,
             agentDir,
-            ...(creation.extensionPaths.length ? { additionalExtensionPaths: creation.extensionPaths } : {}),
+            ...(externalPaths.length ? { additionalExtensionPaths: externalPaths } : {}),
+            ...(extensionFactories.length ? { extensionFactories } : {}),
             ...(creation.systemPromptFile && creation.systemPromptMode === "replace"
                 ? { systemPrompt: creation.systemPromptFile }
                 : creation.systemPromptFile
@@ -298,7 +307,7 @@ export async function createPiSession(creation) {
             return found;
         };
         return live;
-    });
+    })();
 }
 function transcriptBytes(sessionManager) {
     const file = sessionManager.getSessionFile?.();

package/dist/server/runtime.d.ts

@@ -272,6 +272,12 @@ export interface AgentRuntime {
      * own waiting list - Pi is holding a copy, not the only copy.
      */
     followUp?(conversationId: string, message: string, images?: MessageImage[]): Promise<SteerDisposition>;
+    sendCustomMessage?(conversationId: string, message: {
+        customType: string;
+        content: string;
+        display?: string;
+        details: Record<string, unknown>;
+    }): Promise<void>;
     /**
      * Empties Pi's steering and follow-up queues, and returns what was in them.
      *
@@ -1067,6 +1073,12 @@ export declare class PiRpcRuntime implements AgentRuntime {
      * was busy means).
      */
     followUp(conversationId: string, message: string, images?: MessageImage[]): Promise<SteerDisposition>;
+    sendCustomMessage(conversationId: string, message: {
+        customType: string;
+        content: string;
+        display?: string;
+        details: Record<string, unknown>;
+    }): Promise<void>;
     /**
      * Empties Pi's steering and follow-up queues and returns what was in them.
      *

package/dist/server/runtime.js

@@ -2184,6 +2184,12 @@ export class PiRpcRuntime {
         // do anyway.
         throw new SteerUnavailableError(`会话 ${conversationId} 当前没有可以接手的 Pi 会话，无法排队`);
     }
+    async sendCustomMessage(conversationId, message) {
+        const session = await this.sessionFor(conversationId);
+        if (!session.sendCustomMessage)
+            throw new SteerUnavailableError(`会话 ${conversationId} 的 Pi 不支持 custom message`);
+        await session.sendCustomMessage(message, { triggerTurn: true, deliverAs: "followUp" });
+    }
     /**
      * Empties Pi's steering and follow-up queues and returns what was in them.
      *
@@ -2421,26 +2427,10 @@ export class PiRpcRuntime {
             if (!models.length)
                 return unavailable("Pi's SDK reported no usable models");
             const pick = (model) => (model ? { provider: model.provider, modelId: model.modelId, label: model.label } : undefined);
-            // The levels belong to the SELECTED model, so they are asked of the model in question rather
-            // than of whatever Pi would have defaulted to.
-            //
-            // A MODEL THIS PI DOES NOT KNOW IS NOT A REASON TO THROW THE WHOLE READ AWAY. The MODEL LIST
-            // does not depend on the selection at all - it is the same list for every conversation - so
-            // abandoning it because one model's levels are unknown turns "the model this session used was
-            // removed" into "the picker is empty", which is the exact opposite of what the person needs
-            // at that moment. Measured before this change: removing the model in use produced a catalog
-            // with `source: "unavailable"` and ZERO models, and the spawned fallback that produced it had
-            // only reached its own `set_model` rejection ("Model not found").
-            //
-            // The levels then come from Pi's default model, because that is the model a turn on a
-            // nonexistent model actually runs on (the session cannot resolve it and falls back), so they
-            // describe the model in force rather than a different one.
+            // Unknown levels do not invalidate the SDK model list or imply an external Pi.
+            // Keep the catalog usable without spawning a process or borrowing another model's levels.
             const forModel = selection ?? reader.defaultModel;
-            let levels = forModel ? await reader.thinkingLevelsFor(forModel) : undefined;
-            if (forModel && !levels && reader.defaultModel) {
-                levels = await reader.thinkingLevelsFor(reader.defaultModel);
-            }
-            const levelNames = levels ?? [];
+            const levelNames = (forModel ? await reader.thinkingLevelsFor(forModel) : undefined) ?? [];
             const value = {
                 source: "pi",
                 models,

package/dist/server/store.js

@@ -636,13 +636,17 @@ export class Store {
                     console.warn(`Super Pi: state file ${repository.filePath} could not be loaded (${reason}) and could not be moved aside either (${moveError instanceof Error ? moveError.message : String(moveError)}) - the server starts with a fresh state; the unreadable file is still at ${repository.filePath}.`);
                 }
             }
-            const createdAt = now();
             // NO WRITE HERE, AND THAT IS AN INVARIANT RATHER THAN AN OMISSION: a store with no file behind it
             // stays lazy, so opening one never creates a file and never has to un-create one. `persistence-
             // repository.test.mjs` asserts it by reading the path and expecting ENOENT. Repairing an EXISTING
             // file is the other case and is handled above; this branch invented its contents and says nothing
             // until something actually happens.
-            return new Store(repository, { workspaces: [{ id: "workspace_default", name: "Super Pi", path: process.cwd(), updatedAt: createdAt }], conversations: [], subagentRuns: [], backgroundTasks: [] });
+            //
+            // A fresh state starts with NO workspace, and that is a constraint rather than a gap: this branch
+            // used to seed one named after process.cwd(), so whatever directory the server happened to be
+            // launched from silently became a workspace. The first workspace is always an explicit decision -
+            // the client's zero-workspace empty state (App.tsx) asks for one instead.
+            return new Store(repository, { workspaces: [], conversations: [], subagentRuns: [], backgroundTasks: [] });
         }
     }
     async setModelFilterRules(rules) {
@@ -697,7 +701,13 @@ export class Store {
             throw error;
         }
     }
-    snapshot() { return structuredClone(this.state); }
+    snapshot() {
+        const startedAt = process.env.SUPER_PI_TRACE_LATENCY === "1" ? performance.now() : 0;
+        const value = structuredClone(this.state);
+        if (startedAt)
+            console.warn(`[super-pi latency] phase=state.snapshot bytes=${JSON.stringify(value).length} cloneMs=${Math.round(performance.now() - startedAt)}`);
+        return value;
+    }
     /**
      * Whether a conversation already holds a message with this id.
      *
@@ -796,8 +806,9 @@ export class Store {
     async deleteWorkspace(workspaceId) {
         if (!this.state.workspaces.some((item) => item.id === workspaceId))
             throw new Error("找不到这个工作区。");
-        if (this.state.workspaces.length <= 1)
-            throw new Error("至少要保留一个工作区，不能把最后一个删掉。");
+        // Deleting the LAST workspace is allowed: a fresh store starts with zero (see `openRepository`), so
+        // "at least one" was an artifact of the old first-run seed, and the client's zero-workspace empty
+        // state is the onboarding path back in.
         // Cascade: workspaces and conversations live in one state.json, so this single atomic persist removes
         // both together. A waiting message needs no sweep of its own any more - it is a message inside one of
         // the conversations being removed, so it goes with its container, which is the whole reason it is a

package/dist/server/ws-server.js

@@ -73,7 +73,10 @@ export class WsBroadcaster {
          * Stream deltas stay per-event: they are coalesced per socket, so there is no single payload to
          * share, and their cost is one small string.
          */
+        const startedAt = performance.now();
         const payload = streaming ? undefined : JSON.stringify(event);
+        if (!streaming && event.type === "state" && process.env.SUPER_PI_TRACE_LATENCY === "1")
+            console.warn(`[super-pi latency] phase=state.broadcast bytes=${payload?.length ?? 0} sockets=${this.sockets.size} serializeMs=${Math.round(performance.now() - startedAt)}`);
         for (const socket of this.sockets) {
             if (socket.readyState !== WebSocket.OPEN)
                 continue;
@@ -255,8 +258,10 @@ export class WsServer {
                                 socket.send(JSON.stringify(event));
                             }
                         }, remoteAddress);
-                        if (command.operationRequestId)
+                        // Void-returning configuration commands also need an ack to release optimistic UI state.
+                        if (command.operationRequestId && socket.readyState === WebSocket.OPEN) {
                             socket.send(JSON.stringify({ type: "operation.result", requestId: command.operationRequestId, ok: true, entityId }));
+                        }
                     }
                     catch (error) {
                         if (command?.operationRequestId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.127",
+  "version": "0.1.129",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -101,6 +101,7 @@
     "scripts/send-retry.test.mjs",
     "scripts/error-messages.test.mjs",
     "scripts/git-diff-view.test.mjs",
+    "scripts/git-blame.test.mjs",
     "scripts/fork-server.test.mjs",
     "scripts/styles-no-dangling.test.mjs",
     "scripts/theme-no-hardcoded-colours.test.mjs",

package/scripts/diagnose.mjs

@@ -229,8 +229,13 @@ export async function diagnose({ repositoryRoot, turns = 2, onProgress = () => {
       throw new Error(`timed out waiting for ${label}`);
     };
 
+    // A fresh store starts with no workspace, so the diagnosis creates the one it measures against -
+    // before any measured span, so workspace setup never lands inside a number.
+    send({ type: "workspace.create", name: "diagnose", path: process.cwd() });
+    const workspaceId = (await waitFor((e) => e.type === "state" && e.state.workspaces.some((w) => w.name === "diagnose"), "the diagnose workspace")).state.workspaces.find((w) => w.name === "diagnose").id;
+
     onProgress("creating a conversation...");
-    send({ type: "conversation.create", workspaceId: "workspace_default" });
+    send({ type: "conversation.create", workspaceId });
     await waitFor((e) => e.type === "state" && e.state.conversations.length > 0, "a conversation");
     const conversation = events.filter((e) => e.type === "state").at(-1).state.conversations[0];
 
@@ -258,13 +263,13 @@ export async function diagnose({ repositoryRoot, turns = 2, onProgress = () => {
       onProgress("setting a workspace default model, then creating a conversation...");
       send({
         type: "workspace.settings",
-        workspaceId: "workspace_default",
+        workspaceId,
         model: { provider: defaultModel.provider, modelId: defaultModel.modelId },
         thinkingLevel: null,
       });
       await sleep(400);
       const withDefaultStart = Date.now();
-      send({ type: "conversation.create", workspaceId: "workspace_default" });
+      send({ type: "conversation.create", workspaceId });
       const withDefault = await waitFor((e) => e.type === "state"
         && e.state.conversations.length >= 2, "a conversation with the workspace default");
       result.conversationWithDefaultMs = Date.now() - withDefaultStart;