@evandu/super-pi 0.1.97 → 0.1.98

package/dist/server/runtime.js

@@ -17,7 +17,7 @@ import { describeDeliveredUserMessage, describePiQueue, handleSessionEvent, Turn
 // them; the one-shot drain loop below reads the same records through the same two functions, so both
 // paths recognise a delivery identically. Re-exported because they were part of this module's surface.
 export { describeDeliveredUserMessage, describePiQueue } from "./pi-session-events.js";
-import { createPiSession, piSdkAvailable, superPiExtensionPaths } from "./pi-session.js";
+import { createPiSession, createSdkCatalog, piSdkAvailable, resolveTranscriptFile, superPiExtensionPaths } from "./pi-session.js";
 import { TASK_CONVERSATION_ENV, TASK_DEPTH_ENV, TASK_ENDPOINT_ENV, TASK_EXEC_ENDPOINT_ENV, TASK_ROSTER_ENV, TASK_TOOL_NAME, TODO_ENDPOINT_ENV, TODO_TOOL_NAME, WORKFLOW_ENDPOINT_ENV, WORKFLOW_TOOL_NAME, RUN_ASYNC_TOOL_NAME, rosterPayload, } from "./task-tool.js";
 import { BLOCKING_UI_METHODS, EXTENSION_UI_METHODS, } from "./types.js";
 import { loadConversationImages } from "./upload.js";
@@ -193,8 +193,19 @@ const CATALOG_TTL_MS = 10 * 60_000;
 /** A FAILED catalog is cached for far less time, so one broken Pi cannot be retried on every keystroke of a model switch. */
 const CATALOG_FAILURE_TTL_MS = 30_000;
 const CATALOG_COMMAND_TIMEOUT_MS = 15_000;
-/** Keys Pi's model answers by. Exported so the store and the tests agree with the runtime. */
-export const catalogKey = (selection) => (selection?.provider && selection.modelId ? `${selection.provider}/${selection.modelId}` : "default");
+/**
+ * Keys Pi's model answers by. Exported so the store and the tests agree with the runtime.
+ *
+ * THE MODEL IS NOT PART OF THE KEY, and that is the second half of why the picker no longer starts a
+ * process. The MODEL LIST is the same answer whichever model a conversation has selected - it is the
+ * list of models Pi offers, not the ones one conversation may use. The only thing that varies with the
+ * selection is the THINKING LEVELS, which belong to the model in use.
+ *
+ * So the key records just whether levels were asked for. Keying on the model (as this used to) meant a
+ * cache miss for every model a person ever picked, and every miss was a process start - so the picker
+ * went grey again after every model change, which is exactly when a person is moving between models.
+ */
+export const catalogKey = (selection) => (selection?.provider && selection.modelId ? "levels" : "list");
 /**
  * Where the `task` extension lives, as an ABSOLUTE path.
  *
@@ -255,6 +266,8 @@ export class PiRpcRuntime {
      * in the pool, and a turn is a run ON that session rather than a process OF its own.
      */
     sessionPool;
+    /** Where Super Pi itself is installed, which is also where its own extensions are found. */
+    repositoryRoot;
     /**
      * The turn currently running on each conversation's session.
      *
@@ -297,8 +310,25 @@ export class PiRpcRuntime {
     /** Distinguishes steer command ids. Never reused, so a late response cannot settle a later steer. */
     steerSeq = 0;
     catalogs = new Map();
-    /** In-flight reads, so N clients asking at once cost ONE Pi spawn rather than N. */
+    /**
+     * In-flight reads, so N clients asking at once cost ONE read rather than N.
+     *
+     * "One read", not "one Pi spawn": the catalog is answered out of Pi's SDK and no process is started
+     * at all. The wording here used to promise a shared spawn, which is what the old implementation did.
+     */
     pendingCatalogs = new Map();
+    /**
+     * Pi's SDK catalog reader, built once and reused.
+     *
+     * The ModelRuntime and SettingsManager it holds read the auth store and the model store from disk, so
+     * building a new one per call would put back the I/O this exists to avoid. They are read-mostly
+     * views of files that change rarely, and Pi's own long-lived session holds the same objects for its
+     * whole life.
+     *
+     * A FAILED build is remembered as a failure rather than retried per call: a broken SDK would
+     * otherwise be re-imported on every picker open.
+     */
+    sdkCatalogPromise;
     /** Latches the "no extension on disk" warning, so it is said once rather than once per turn. */
     warnedMissingExtension = false;
     /** Latches the "Pi's SDK is not installed" warning, for the same reason. */
@@ -376,7 +406,8 @@ export class PiRpcRuntime {
             console.warn(`PiRpcRuntime: ${this.pi.reason}`);
         this.sessionMode = this.options.sessionMode
             ?? (process.env.SUPER_PI_SESSION_MODE === "oneshot" ? "oneshot" : "sdk");
-        this.sessionPool = new PiSessionPool(sessionDir, repositoryRootFrom(), undefined, (conversationId) => {
+        this.repositoryRoot = repositoryRootFrom();
+        this.sessionPool = new PiSessionPool(sessionDir, this.repositoryRoot, undefined, (conversationId) => {
             // A session's credential dies with the session. The session is what HELD the token - its
             // extension read it out of the environment when it was loaded - so a session that is gone must
             // not leave a usable token behind.
@@ -727,8 +758,10 @@ export class PiRpcRuntime {
         let firstTextSeen = false;
         const finished = (async () => {
             try {
-                await session.prompt(prompt, images?.length ? { images: images } : undefined);
-                traceLatency(conversation.id, "session.prompt.accepted", latencyStartedAt);
+                const promptOptions = images?.length
+                    ? { images: images, preflightResult: () => traceLatency(conversation.id, "session.prompt.accepted", latencyStartedAt) }
+                    : { preflightResult: () => traceLatency(conversation.id, "session.prompt.accepted", latencyStartedAt) };
+                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
                 // tools, still settling. A turn that ended here would release the reader while the model was
@@ -1633,6 +1666,23 @@ export class PiRpcRuntime {
         if (!info?.isDirectory())
             throw new Error(`工作区目录不存在或不是目录，无法在其中找到这个会话的 Pi 记录：${childCwd}`);
         await mkdir(this.sessionDir, { recursive: true });
+        // THE SDK ANSWERS THIS, AND ANSWERING IT WITH A PROCESS IS WHAT USED TO MAKE REVERT SLOW.
+        //
+        // Pi looks a session up by id AND by working directory, and the SDK's session manager resolves the
+        // same thing the RPC command would have - so the library is asked first, and a process is started
+        // only when there is no library to ask. The verification below is unchanged and still decides
+        // whether the file may be written: `truncateSessionFile` proves the header belongs to this
+        // conversation and validates the boundary, so a wrong answer from either source still cannot
+        // truncate somebody else's history.
+        const resolved = await this.resolveTranscriptFileWithoutSpawn(childCwd, conversation.id);
+        if (resolved !== undefined) {
+            const found = await stat(resolved).catch(() => undefined);
+            if (!found?.isFile())
+                throw new Error(`Pi 还没有为这个会话建立记录文件（${resolved}），没有可以回退的历史。`);
+            const result = await truncateSessionFile(resolved, boundaryEntryId, conversation.id, beforeBoundary);
+            await this.sessionPool.evict(conversation.id);
+            return { sessionFile: resolved, linesKept: result.linesKept, entriesDropped: result.entriesDropped };
+        }
         // NO agent flags and NO extension on this spawn. It sends no prompt and must leave nothing behind:
         // `SessionManager._persist` only creates a file once a session holds a message
         // (`session-manager.ts:1160-1170`), so an answer to `get_state` cannot write anything. Adding the
@@ -1724,10 +1774,10 @@ export class PiRpcRuntime {
             return { entriesCopied: 0 };
         if (!this.pi.found)
             throw new Error(this.pi.reason);
+        const stamp = new Date().toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
+        const target = join(this.sessionDir, `${stamp}_${forkedConversationId}.jsonl`);
         const cached = conversation.piSessionFile;
         if (cached && (await stat(cached).catch(() => undefined))?.isFile()) {
-            const stamp = new Date().toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
-            const target = join(this.sessionDir, `${stamp}_${forkedConversationId}.jsonl`);
             const result = await forkSessionFile(cached, target, conversation.id, forkedConversationId);
             return { sessionFile: target, entriesCopied: result.entriesCopied };
         }
@@ -1736,6 +1786,16 @@ export class PiRpcRuntime {
         if (!info?.isDirectory())
             throw new Error(`工作区目录不存在或不是目录，无法在其中找到这个会话的 Pi 记录：${childCwd}`);
         await mkdir(this.sessionDir, { recursive: true });
+        // THE SAME SDK LOOKUP AS REVERT, FOR THE SAME REASON: a process would be started only to be told
+        // which file Pi uses, and Pi's own session manager answers that without a process.
+        const resolved = await this.resolveTranscriptFileWithoutSpawn(childCwd, conversation.id);
+        if (resolved !== undefined) {
+            const found = await stat(resolved).catch(() => undefined);
+            if (!found?.isFile())
+                return { entriesCopied: 0 };
+            const copied = await forkSessionFile(resolved, target, conversation.id, forkedConversationId);
+            return { sessionFile: target, entriesCopied: copied.entriesCopied };
+        }
         // The same lookup spawn as `revert`, and the same reason for leaving the agent flags off: this child
         // sends no prompt and must leave nothing behind.
         const child = spawn(shellQuote(this.pi.command), ["--mode", "rpc", "--session-dir", this.sessionDir, "--session-id", conversation.id], {
@@ -1778,8 +1838,6 @@ export class PiRpcRuntime {
         // is the fork's, not the source's: the file header keeps the SOURCE timestamp verbatim (it is history),
         // while the filename carries when this copy was made, which is what makes the ordering of a directory
         // full of forks mean anything.
-        const stamp = new Date().toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
-        const target = join(this.sessionDir, `${stamp}_${forkedConversationId}.jsonl`);
         const result = await forkSessionFile(sessionFile, target, conversation.id, forkedConversationId);
         return { sessionFile: target, entriesCopied: result.entriesCopied };
     }
@@ -2091,28 +2149,146 @@ export class PiRpcRuntime {
         const key = catalogKey(selection);
         const cached = this.catalogs.get(key);
         const ttl = cached?.value.source === "pi" ? CATALOG_TTL_MS : CATALOG_FAILURE_TTL_MS;
-        if (cached && Date.now() - cached.at < ttl)
+        if (cached && Date.now() - cached.at < ttl) {
+            if (process.env.SUPER_PI_TRACE_LATENCY === "1")
+                console.warn(`[super-pi latency] catalog key=${key} phase=catalog.cache-hit`);
             return cached.value;
+        }
         const inFlight = this.pendingCatalogs.get(key);
-        if (inFlight)
+        if (inFlight) {
+            if (process.env.SUPER_PI_TRACE_LATENCY === "1")
+                console.warn(`[super-pi latency] catalog key=${key} phase=catalog.inflight-join`);
             return inFlight;
+        }
+        if (process.env.SUPER_PI_TRACE_LATENCY === "1")
+            console.warn(`[super-pi latency] catalog key=${key} phase=catalog.read-begin`);
         const pending = this.readCatalog(selection, key).finally(() => this.pendingCatalogs.delete(key));
         this.pendingCatalogs.set(key, pending);
         return pending;
     }
     /**
-     * Asks one throwaway Pi for its model list, its thinking levels and its own current selection.
+     * Reads the model catalog WITHOUT starting a Pi process, and falls back to a spawned Pi only when
+     * the SDK is not available.
      *
-     * The three commands are written back to back and only then awaited, so Pi works on them in
-     * parallel - measured at 394ms for all three, against 714ms for the slowest one alone. A Pi
-     * scoped to one conversation's model needs `set_model` FIRST and alone, because thinking levels are
-     * a property of the selected model, not of Pi's default.
+     * WHY THIS IS THE DEFAULT. The picker used to be answered by starting a `pi --mode rpc` child,
+     * asking it three questions and killing it: a process start, measured at 866ms on a fast machine and
+     * seconds on a slow one. And the cache key is the SELECTED MODEL, so it started again for every model
+     * a person picked - which is why "the picker stays grey for ten seconds" followed choosing a model,
+     * and not only the first time.
+     *
+     * Pi's SDK is the same code Pi's RPC mode is built on, so the answers are the same, and the two are
+     * compared field by field in `scripts/probe-catalog-equivalence.mjs`.
      */
     async readCatalog(selection, key) {
         const unavailable = (error) => {
             console.warn(`PiRpcRuntime: catalog for ${key} could not be read: ${error}`);
             return { source: "unavailable", models: [], levels: [], fetchedAt: new Date().toISOString(), error };
         };
+        // AN EXPLICITLY NAMED PI IS THE ONE THAT WILL RUN THE CONVERSATION, SO IT IS THE ONE THAT GETS
+        // ASKED. Naming a Pi is a statement about which Pi runs a turn, and the model list a person sees
+        // has to be THAT Pi's list - otherwise the picker offers a model that no turn could ever use, and a
+        // test harness driving its own Pi is refused models its Pi actually has.
+        //
+        // The SDK's list is the right answer only when the SDK IS the thing that will run the conversation,
+        // which is the ordinary case: Super Pi depends on that package, so the SDK and the conversation
+        // are the same Pi. It is the wrong answer the moment something else is - and then that something
+        // else is asked, at the cost this change was made to remove.
+        // NOT `this.pi.found &&`: a NAMED command that does not exist is still a named command, and the
+        // honest answer to "this Pi cannot be asked" is still "unavailable" rather than a list from some
+        // other Pi. `found: false` is exactly the case that must NOT be answered from elsewhere.
+        const namedPiIsInCharge = this.pi.explicit === true || this.sessionMode === "oneshot";
+        if (namedPiIsInCharge) {
+            if (process.env.SUPER_PI_TRACE_LATENCY === "1")
+                console.warn(`[super-pi latency] catalog key=${key} phase=catalog.asks-named-pi explicit=${this.pi.explicit ?? "not-found"} mode=${this.sessionMode}`);
+            return this.readCatalogBySpawningPi(selection, key, unavailable);
+        }
+        const sdkRead = await this.readCatalogFromSdk(selection, unavailable);
+        if (sdkRead) {
+            this.catalogs.set(key, { at: Date.now(), value: sdkRead });
+            return sdkRead;
+        }
+        return this.readCatalogBySpawningPi(selection, key, unavailable);
+    }
+    /**
+     * The transcript file for a conversation, out of Pi's SDK, or undefined when the SDK cannot answer.
+     *
+     * Undefined means "ask someone else", not "no such file": a missing SDK and a missing transcript
+     * are different facts, and only the first one should send the caller to the spawning path.
+     *
+     * For the same reason as the catalog, a NAMED Pi is not asked here: when something else will run the
+     * conversation, it is also the only one that knows which file that conversation's transcript is in.
+     */
+    async resolveTranscriptFileWithoutSpawn(cwd, conversationId) {
+        if (!this.pi.found || this.pi.explicit || this.sessionMode === "oneshot")
+            return undefined;
+        const support = await this.sessionSupport();
+        if (!support.available)
+            return undefined;
+        try {
+            return await resolveTranscriptFile(cwd, conversationId, this.sessionDir);
+        }
+        catch (error) {
+            console.warn(`PiRpcRuntime: Pi's SDK could not locate the transcript of ${conversationId}: ${error instanceof Error ? error.message : String(error)}. Falling back to asking a Pi process, which is slower but the same answer.`);
+            return undefined;
+        }
+    }
+    async sdkCatalog() {
+        if (!this.sdkCatalogPromise) {
+            this.sdkCatalogPromise = createSdkCatalog(this.repositoryRoot).catch((error) => {
+                console.warn(`PiRpcRuntime: Pi's SDK could not be used for the catalog: ${error instanceof Error ? error.message : String(error)}`);
+                return undefined;
+            });
+        }
+        return this.sdkCatalogPromise;
+    }
+    /**
+     * The catalog, out of Pi's SDK. Returns undefined when the SDK is not available, which is the only
+     * case in which the spawning path is reached.
+     */
+    async readCatalogFromSdk(selection, unavailable) {
+        const support = await this.sessionSupport();
+        if (!support.available)
+            return undefined;
+        try {
+            const reader = await this.sdkCatalog();
+            if (!reader)
+                return undefined;
+            const models = describeModels(reader.models);
+            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.
+            const forModel = selection ?? reader.defaultModel;
+            const levels = forModel ? await reader.thinkingLevelsFor(forModel) : [];
+            const value = {
+                source: "pi",
+                models,
+                levels,
+                defaultModel: pick(reader.defaultModel ? describeModel({ provider: reader.defaultModel.provider, id: reader.defaultModel.modelId, name: reader.defaultModel.modelId }) : undefined),
+                defaultThinkingLevel: reader.defaultThinkingLevel ?? levels[0],
+                fetchedAt: new Date().toISOString(),
+            };
+            return value;
+        }
+        catch (error) {
+            // A failure here is a REASON TO WARN, not a reason to start a process: falling back to the spawn
+            // would put the cost back exactly when the machine is already in trouble.
+            console.warn(`PiRpcRuntime: the SDK catalog read failed, and this catalog will be empty rather than slow: ${error instanceof Error ? error.message : String(error)}`);
+            return unavailable(`Pi's SDK could not answer: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Asks one throwaway Pi for its model list, its thinking levels and its own current selection.
+     *
+     * Only reached when Pi's SDK is not available - which is a broken installation, not a normal one.
+     *
+     * The three commands are written back to back and only then awaited, so Pi works on them in
+     * parallel - measured at 394ms for all three, against 714ms for the slowest one alone. A Pi
+     * scoped to one conversation's model needs `set_model` FIRST and alone, because thinking levels are
+     * a property of the selected model, not of Pi's default.
+     */
+    async readCatalogBySpawningPi(selection, key, unavailable) {
         // Catalog probes get their OWN session directory and a fixed session id: they must never write
         // into a conversation's transcript, and a fixed id means a refresh reuses one file instead of
         // leaving a new one behind on every model switch.
@@ -2125,6 +2301,8 @@ export class PiRpcRuntime {
         let child;
         try {
             child = spawn(shellQuote(this.pi.command), ["--mode", "rpc", "--session-dir", directory, "--session-id", "catalog"], { cwd: directory, stdio: ["pipe", "pipe", "pipe"], shell: process.platform === "win32" });
+            if (process.env.SUPER_PI_TRACE_LATENCY === "1")
+                console.warn(`[super-pi latency] catalog key=${key} phase=catalog.spawned pid=${child.pid ?? "unknown"}`);
         }
         catch (error) {
             return unavailable(`could not spawn Pi: ${error instanceof Error ? error.message : "unknown error"}`);
@@ -2185,6 +2363,9 @@ export class PiRpcRuntime {
             // under load in scripts/workspace-settings-browser.test.mjs, which timed out at 60s with an
             // accepted command, an empty error channel and an untouched state.json.
             if (child.exitCode === null && child.pid !== undefined) {
+                const killedAt = performance.now();
+                if (process.env.SUPER_PI_TRACE_LATENCY === "1")
+                    console.warn(`[super-pi latency] catalog key=${key} phase=catalog.kill.begin pid=${child.pid}`);
                 if (!child.killed) {
                     if (process.platform === "win32")
                         await killTree(child.pid);
@@ -2193,6 +2374,8 @@ export class PiRpcRuntime {
                 }
                 if (child.exitCode === null)
                     await new Promise((resolve) => { child.once("exit", resolve); setTimeout(resolve, 5000); });
+                if (process.env.SUPER_PI_TRACE_LATENCY === "1")
+                    console.warn(`[super-pi latency] catalog key=${key} phase=catalog.kill.end elapsedMs=${Math.round(performance.now() - killedAt)}`);
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.97",
+  "version": "0.1.98",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -36,8 +36,7 @@
     "start": "node dist/server/index.js",
     "restart:server": "node scripts/restart-server.mjs",
     "smoke": "npm run build && node scripts/smoke.mjs",
-    "check": "node scripts/run-check.mjs",
-    "postinstall": "node scripts/patch-brace-expansion.mjs"
+    "check": "node scripts/run-check.mjs"
   },
   "check:logic": [
     "scripts/stream-checkpoint.test.mjs",