@evandu/super-pi 0.1.137 → 0.1.139

package/dist/server/store.js

@@ -721,6 +721,47 @@ export class Store {
         const workspace = this.state.workspaces.find((item) => item.id === workspaceId);
         return workspace ? { ...workspace } : undefined;
     }
+    /** Read the app-wide default without cloning conversations or transcripts. */
+    defaultModel() {
+        const model = this.state.defaultModel;
+        return model ? { ...model } : undefined;
+    }
+    /** Read one detached conversation for lifecycle operations. */
+    conversation(conversationId) {
+        const conversation = this.state.conversations.find((item) => item.id === conversationId);
+        return conversation ? structuredClone(conversation) : undefined;
+    }
+    /** Return every pending question in one conversation without cloning unrelated history. */
+    pendingQuestions(conversationId) {
+        const conversation = this.state.conversations.find((item) => item.id === conversationId);
+        if (!conversation)
+            return [];
+        const pending = [];
+        for (const message of conversation.messages) {
+            for (let index = 0; index < (message.toolCalls?.length ?? 0); index += 1) {
+                const question = message.toolCalls?.[index]?.question;
+                if (message.toolCalls?.[index]?.label === "question" && question?.status === "pending") {
+                    pending.push({ messageId: message.id, index, question: structuredClone(question) });
+                }
+            }
+        }
+        return pending;
+    }
+    /**
+     * THE SCHEDULED TASKS, WITHOUT CLONING THE STATE TO FIND THEM.
+     *
+     * The same argument as the readers above, with a sharper edge: the scheduled-task clock sweeps
+     * every fifteen seconds and used to read its three-to-zero tasks through `snapshot()` - a deep
+     * clone of the whole application, every fifteen seconds, whether the user has any scheduled task or
+     * not. On a server holding a long transcript that is a full copy of the app four times a minute,
+     * produced for a list that is usually empty.
+     *
+     * The tasks are returned as a shallow copy of the array: the sweep reads `enabled` and
+     * `nextRunAt` and then hands the whole task back to the store, which owns the real one.
+     */
+    scheduledTasks() {
+        return this.state.scheduledTasks ? [...this.state.scheduledTasks] : [];
+    }
     /** Small detached rows used when refreshing each conversation's scoped model catalog. */
     catalogConversationTargets() {
         return this.state.conversations.map(({ id, archivedAt, model }) => ({
@@ -788,8 +829,10 @@ export class Store {
     snapshot() {
         const startedAt = process.env.SUPER_PI_TRACE_LATENCY === "1" ? performance.now() : 0;
         const value = structuredClone(this.state);
+        // Do not stringify here just to count bytes: that makes tracing add a second full serialization
+        // and mislabels that extra work as clone time. The broadcaster measures the actual JSON payload.
         if (startedAt)
-            console.warn(`[super-pi latency] phase=state.snapshot bytes=${JSON.stringify(value).length} cloneMs=${Math.round(performance.now() - startedAt)}`);
+            console.warn(`[super-pi latency] phase=state.snapshot cloneMs=${Math.round(performance.now() - startedAt)}`);
         return value;
     }
     /** Cheap scalar/entity reads for hot paths. Never expose the live mutable state object. */
@@ -981,14 +1024,32 @@ export class Store {
      * Filtering HERE, in one place, rather than in every reader, is what keeps the client dumb: the
      * sidebar renders `state.workspaces` and never has to know that a closed workspace exists.
      */
-    clientState() {
-        const state = this.snapshot();
-        const closed = new Set(state.workspaces.filter((item) => item.closedAt).map((item) => item.id));
-        if (!closed.size)
-            return state;
-        state.workspaces = state.workspaces.filter((item) => !closed.has(item.id));
-        state.conversations = state.conversations.filter((item) => !closed.has(item.workspaceId));
-        return state;
+    clientState(scope) {
+        const closed = new Set(this.state.workspaces.filter((item) => item.closedAt).map((item) => item.id));
+        const workspaces = this.state.workspaces.filter((item) => !closed.has(item.id));
+        const visible = this.state.conversations.filter((item) => !closed.has(item.workspaceId));
+        // Legacy sockets still receive complete visible transcripts. Project before cloning so a closed
+        // workspace's retained history is never copied just to discard it afterwards.
+        if (scope === undefined)
+            return structuredClone({ ...this.state, workspaces, conversations: visible });
+        // A focused socket keeps every sidebar row, but owns only the selected transcript. An empty scope
+        // deliberately loads none; a missing/closed selection must not expose retained workspace history.
+        const selectedId = visible.find((item) => item.id === scope.conversationId)?.id;
+        const conversations = visible.map(({ messages, ...metadata }) => ({
+            ...metadata,
+            messages: metadata.id === selectedId ? messages : [],
+            messagesLoaded: metadata.id === selectedId,
+            hasPendingQuestion: messages.some((message) => message.toolCalls?.some((call) => call.question?.status === "pending")),
+        }));
+        return structuredClone({
+            ...this.state,
+            workspaces,
+            conversations,
+            subagentRuns: this.state.subagentRuns.filter((run) => run.conversationId === selectedId),
+            ...(this.state.workflows ? { workflows: this.state.workflows.filter((run) => run.conversationId === selectedId) } : {}),
+            ...(this.state.todosByConversation ? { todosByConversation: selectedId && this.state.todosByConversation[selectedId]
+                    ? { [selectedId]: this.state.todosByConversation[selectedId] } : {} } : {}),
+        });
     }
     async createConversation(workspaceId, configuration) {
         const workspace = this.state.workspaces.find((item) => item.id === workspaceId);
@@ -1007,6 +1068,10 @@ export class Store {
         if (workspace.defaultAgentId)
             conversation.agentId = workspace.defaultAgentId;
         if (configuration) {
+            // WHY THIS CONVERSATION IS NOT ON THE MODEL THE USER SET. Set once, at birth, and never
+            // rewritten: it describes how this conversation came to be, not what is true right now.
+            if (configuration.modelNotice !== undefined)
+                conversation.modelNotice = configuration.modelNotice;
             if (configuration.model !== undefined) {
                 if (configuration.model)
                     conversation.model = { ...configuration.model };
@@ -1477,7 +1542,7 @@ export class Store {
         };
         calls.push(structuredClone(placed));
         conversation.updatedAt = now();
-        await this.persist();
+        await this.persistToolCallMessage(conversationId, messageId);
         return structuredClone(calls);
     }
     /**
@@ -1521,7 +1586,7 @@ export class Store {
         // finished tool block that vanishes the moment the call ends is a block that taught the reader
         // nothing. The client prefers `live` when both are present, falling back to `result`.
         conversation.updatedAt = now();
-        await this.persist();
+        await this.persistToolCallMessage(conversationId, messageId);
         return structuredClone(calls);
     }
     /**
@@ -1533,6 +1598,26 @@ export class Store {
      * Every field is `undefined`-tested for the same reason `settleToolCall` does it: `""` and `[]` are
      * values a tool can genuinely produce, and treating them as "not reported" would erase a real answer.
      */
+    /**
+     * THE TOOL-CALL WRITES, PERSISTED AS ONE MESSAGE INSTEAD OF THE WHOLE APPLICATION.
+     *
+     * A tool call's lifecycle touches exactly ONE thing: the `toolCalls` array of ONE message. The
+     * write used to be `this.persist()`, which hands the ENTIRE state to the repository - every
+     * workspace, every conversation, every message of every conversation - to be serialized and
+     * written. A turn that calls five tools therefore wrote the whole application ten to fifteen
+     * times, and every one of those writes was proportional to the whole history rather than to the
+     * one row that changed (LAT-020).
+     *
+     * `message.replace` is the transaction that means 「this one message now reads like this」, and it
+     * is exactly the write this is: the row's content did not change, only its tool calls did.
+     */
+    async persistToolCallMessage(conversationId, messageId) {
+        const conversation = this.requireConversation(conversationId);
+        const message = conversation.messages.find((item) => item.id === messageId);
+        if (!message)
+            return;
+        await this.persistTransaction({ kind: "message.replace", conversationId, message: structuredClone(message), updatedAt: conversation.updatedAt });
+    }
     async updateToolCall(conversationId, messageId, index, patch) {
         const conversation = this.requireConversation(conversationId);
         const message = conversation.messages.find((item) => item.id === messageId);
@@ -1569,11 +1654,28 @@ export class Store {
         // the call was being written are gone by the time it runs.
         if (patch.live !== undefined)
             call.live = patch.live;
+        // WHERE THE CALL HAPPENED, corrected when the call is announced. The placeholder stamped the
+        // offsets of the moment it was made, and that moment is not the moment the call belongs to
+        // (UX-008).
+        if (patch.at !== undefined)
+            call.at = patch.at;
+        if (patch.thinkingAt !== undefined)
+            call.thinkingAt = patch.thinkingAt;
+        // WHICH REASONING BLOCK THIS CALL BELONGS TO. It is written when the call is ANNOUNCED, not
+        // when its placeholder was made, and it is written HERE because the placeholder row already
+        // exists by then - a placeholder created while the model was still writing the arguments
+        // cannot know whether the reasoning was over by the time the call was made (UX-008).
+        //
+        // `null` IS A VALUE, NOT AN ABSENCE: it says the call is outside every reasoning block, and
+        // the browser needs to hear that difference from "not decided yet". So the check is
+        // `!== undefined`, never a truthiness test.
+        if (patch.thinkingBlock !== undefined)
+            call.thinkingBlock = patch.thinkingBlock;
         // The question rides on the call rather than beside it, so this is the only write it needs.
         if (patch.question !== undefined)
             call.question = patch.question;
         conversation.updatedAt = now();
-        await this.persist();
+        await this.persistToolCallMessage(conversationId, messageId);
         return structuredClone(calls);
     }
     /**

package/dist/server/subagent-runs.js

@@ -125,7 +125,22 @@ export class SubagentRunRecorder {
         // Generated HERE, not by `run()`, because the record has to exist first - see this file's header.
         const id = input.id ?? newSubagentRunId();
         const started = { id, conversationId, agentId, task, dispatchedBy, parentRunId: input.parentRunId, depth: input.depth ?? 0, loopId: input.loopId, role: input.role, originMessageId: input.originMessageId, originCallRow: input.originCallRow, status: "running", startedAt: new Date().toISOString(), sessionId: id };
-        await this.hooks.store.beginSubagentRun(started);
+        // Own cancellation before the first persistence await. A conversation stop must also reach a
+        // human dispatch whose initial row is still being written, before a supervisor/child exists.
+        const controller = new AbortController();
+        this.controllers.set(id, { controller, conversationId });
+        const onCallerAbort = () => controller.abort();
+        input.signal?.addEventListener("abort", onCallerAbort, { once: true });
+        if (input.signal?.aborted)
+            controller.abort();
+        try {
+            await this.hooks.store.beginSubagentRun(started);
+        }
+        catch (error) {
+            input.signal?.removeEventListener("abort", onCallerAbort);
+            this.controllers.delete(id);
+            throw error;
+        }
         // The recorder's own copy, held separately from the store's. Mutating the object `beginSubagentRun`
         // was handed would reach into the store's state behind its back, and every snapshot it hands out
         // would then move under its reader.
@@ -219,13 +234,9 @@ export class SubagentRunRecorder {
          * run happened.
          */
         const elapsedMs = () => Math.max(0, Date.now() - new Date(started.startedAt).getTime());
-        // One controller for both abort sources: the caller's signal and `abortAll` are the same button from
-        // the child's point of view, and `run()` takes exactly one.
-        const controller = new AbortController();
-        this.controllers.set(id, { controller, conversationId });
-        const onCallerAbort = () => controller.abort();
-        input.signal?.addEventListener("abort", onCallerAbort, { once: true });
         try {
+            if (controller.signal.aborted)
+                throw new SubagentCancelled(id);
             const result = await this.supervisor.run({
                 id,
                 conversationId,

package/dist/server/subagents.js

@@ -265,6 +265,13 @@ export class SubagentSupervisor {
             args.push("--provider", chosen.provider, "--model", chosen.modelId);
         if (agent.thinkingLevel)
             args.push("--thinking", agent.thinkingLevel);
+        // Cancellation may arrive during filesystem/config/model preparation, before the child or its
+        // abort listener exists. Refuse the spawn instead of starting work after the user pressed stop.
+        if (signal?.aborted) {
+            if (memoryToken)
+                this.memory?.release(memoryToken);
+            throw new SubagentCancelled(id);
+        }
         // npm exposes global CLIs as .cmd shims on Windows; Node requires a shell to launch those shims.
         const child = spawn(shellQuote(this.pi.command), args, { cwd: childCwd, stdio: ["pipe", "pipe", "pipe"], shell: process.platform === "win32", ...(memoryToken ? { env: { ...process.env, SUPER_PI_MEMORY_ENDPOINT: process.env.SUPER_PI_MEMORY_ENDPOINT, SUPER_PI_MEMORY_TOKEN: memoryToken, SUPER_PI_MEMORY_READ_ONLY: "1" } } : {}) });
         if (memoryToken)

package/dist/server/tool-runner.js

@@ -156,8 +156,15 @@ export class ToolRunner {
         // -I ignores user Python configuration and user site packages. No shell means params never become code.
         const child = spawn(python.path, ["-I", "-u", input.script], { cwd: input.cwd, shell: false, windowsHide: true, stdio: ["pipe", "pipe", "pipe"], env: { PATH: process.env.PATH, SystemRoot: process.env.SystemRoot, TEMP: process.env.TEMP, TMP: process.env.TMP, PYTHONIOENCODING: "utf-8", PYTHONNOUSERSITE: "1", SUPER_PI_TOOL_ID: input.toolId } });
         active.child = child;
-        child.stdout.on("data", (data) => { active.stdout = clipped(`${active.stdout}${data.toString("utf8")}`); });
-        child.stderr.on("data", (data) => logLine(active, data.toString("utf8")));
+        // A PIPE CARRIES BYTES, AND A READ BOUNDARY CAN LAND INSIDE A CHARACTER. A Chinese character is
+        // three bytes, so decoding one chunk at a time turns every character that straddles a boundary
+        // into U+FFFD - the same output comes out damaged on one machine and whole on another. The
+        // stream decodes instead, and Node keeps an incomplete character until the rest of its bytes
+        // arrive.
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (text) => { active.stdout = clipped(`${active.stdout}${text}`); });
+        child.stderr.on("data", (text) => logLine(active, text));
         child.once("error", (error) => this.finish(id, "failed", error.message));
         child.once("close", (code) => {
             if (active.run.status !== "running")
@@ -210,8 +217,10 @@ function runCapture(python, args, timeoutMs, onOutput) {
         }
         catch { } resolve({ ok: false, code: null, stdout, error: `timed out after ${timeoutMs}ms` }); }, timeoutMs);
         timer.unref();
-        child.stdout.on("data", (data) => { const text = data.toString("utf8"); stdout += text; onOutput?.(text); });
-        child.stderr.on("data", (data) => { const text = data.toString("utf8"); stderr += text; onOutput?.(text); });
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (text) => { stdout += text; onOutput?.(text); });
+        child.stderr.on("data", (text) => { stderr += text; onOutput?.(text); });
         child.once("error", (error) => { if (settled)
             return; settled = true; clearTimeout(timer); resolve({ ok: false, code: null, stdout, error: error.message }); });
         child.once("close", (code) => { if (settled)

package/dist/server/types.d.ts

@@ -464,6 +464,10 @@ export type Conversation = {
     status: RunStatus;
     messages: Message[];
     archivedAt?: string;
+    /** Transport projection only: false means messages were omitted, rather than an empty transcript. */
+    messagesLoaded?: boolean;
+    /** Pending question summary, retained when a focused snapshot omits this conversation's messages. */
+    hasPendingQuestion?: boolean;
     /** Pi's own resolved transcript path, observed from this conversation's live worker. It is only a
      * locator: revert still verifies the file header and every retained boundary before writing. */
     piSessionFile?: string;
@@ -484,6 +488,21 @@ export type Conversation = {
      * would answer "what happened" with something the reader has to go and decode.
      */
     error?: string;
+    /**
+     * WHY THIS CONVERSATION IS NOT ON THE MODEL THE USER SET FOR IT - in words a person reads.
+     *
+     * A default model can stop being usable between one session and the next: Pi may drop the model
+     * from its list, or the workspace's own model rules may forbid it. The conversation then starts on
+     * Pi's own default, which is the right behaviour - but doing it SILENTLY is not: the user set a
+     * default, they set a rule, and nobody told them the two contradicted each other (TEST-062).
+     *
+     * It lives on the conversation rather than on the workspace because that is where the decision
+     * was made: a default can be usable for one workspace and unusable for another, and two
+     * conversations of the same workspace can disagree if the rules changed in between. It is set
+     * ONCE, at birth, and never rewritten afterwards - it describes how this conversation came to be,
+     * not what is true right now.
+     */
+    modelNotice?: string;
     /** Absent means "Pi's own default", which is why a conversation created before the picker existed still works. */
     model?: ModelSelection;
     thinkingLevel?: string;
@@ -1194,6 +1213,14 @@ export type ClientCommandBody =
     type: "stream.configure";
     coalesce: boolean;
 }
+/** Selects this socket's transcript; omitted conversationId requests sidebar summaries only. */
+ | {
+    type: "files.index.subscribe";
+    workspaceId?: string;
+} | {
+    type: "state.subscribe";
+    conversationId?: string;
+}
 /** Asks for the agent catalog read from disk. Answered by `agent.catalog`. */
  | {
     type: "agent.catalog.fetch";

package/dist/server/ws-server.d.ts

@@ -4,6 +4,25 @@ import type { AppState, ServerEvent } from "./types.js";
 import type { EventBroadcaster } from "./server-context.js";
 import type { CommandHandler } from "./command-handler.js";
 import type { CatalogService } from "./application/catalog-service.js";
+/**
+ * A WebSocket is a live transport, not an unbounded queue.  `ws.send()` only
+ * copies bytes into the socket's userland buffer; a browser that is frozen or
+ * a network peer that has disappeared can therefore make the buffer grow
+ * without throwing.  Once this threshold is crossed we drop that connection
+ * and let the normal close path clean up its resources.
+ */
+export declare const MAX_WS_BUFFERED_BYTES: number;
+/** Maximum size of one inbound WebSocket message. Attachments are uploaded
+ * over HTTP and commands contain references, so multi-megabyte WS frames are
+ * almost certainly malformed or abusive. */
+export declare const MAX_WS_PAYLOAD_BYTES: number;
+/**
+ * Send one frame without allowing a race with close/error to escape as an
+ * uncaught exception.  The `ws` package can throw synchronously after the
+ * readyState check (for example when a close happens between the two calls),
+ * and an unhandled `error` event can otherwise terminate the Node process.
+ */
+export declare function safeSend(socket: WebSocket, payload: string): boolean;
 /**
  * Concrete implementation of EventBroadcaster delivering server events
  * across active WebSocket connections.
@@ -11,21 +30,31 @@ import type { CatalogService } from "./application/catalog-service.js";
 export declare class WsBroadcaster implements EventBroadcaster {
     private readonly getState;
     private readonly sockets;
+    private readonly scopes;
+    private readonly fileIndexScopes;
     private readonly coalescedSockets;
     private readonly pendingStreams;
-    private cachedState?;
-    private cachedStatePayload?;
     private stateFlushScheduled;
-    constructor(getState: () => AppState);
-    register(socket: WebSocket): void;
+    constructor(getState: (scope?: {
+        conversationId?: string;
+    }) => AppState);
+    register(socket: WebSocket, scope?: {
+        conversationId?: string;
+    }): void;
     unregister(socket: WebSocket): void;
+    subscribe(socket: WebSocket, conversationId?: string): void;
+    sendState(socket: WebSocket): void;
+    subscribeFileIndex(socket: WebSocket, workspaceId?: string): void;
+    private receives;
     configureStreaming(socket: WebSocket, coalesce: boolean): void;
     private flushStreaming;
     private enqueueStreaming;
     getSockets(): Set<WebSocket>;
     broadcast(event: ServerEvent): void;
     broadcastState(): void;
-    getStateSnapshot(): AppState;
+    getStateSnapshot(scope?: {
+        conversationId?: string;
+    }): AppState;
 }
 export interface WsServerOptions {
     httpServer: NodeHttpServer;