@evandu/super-pi 0.1.138 → 0.1.140

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;
@@ -852,6 +871,29 @@ export type TodoItem = {
     status: "pending" | "in_progress" | "completed";
     priority?: "high" | "medium" | "low";
 };
+/** Summary of an orchestrated sibling session, returned by orchestrator queries. */
+export type OrchestratorSessionSummary = {
+    conversationId: string;
+    workspaceId: string;
+    title: string;
+    status: RunStatus;
+    origin: "user" | "orchestrator";
+    parentConversationId?: string;
+    task?: string;
+    messageCount: number;
+    turnCount: number;
+    lastAssistantSnippet?: string;
+    lastUserSnippet?: string;
+    hasPendingQuestion: boolean;
+    activeTool?: {
+        label: string;
+        detail?: string;
+    };
+    error?: string;
+    updatedAt: string;
+    createdAt?: number;
+    lastProgress?: string;
+};
 /**
  * What Pi reports about ITS OWN queue, forwarded to the browser as it arrives.
  *
@@ -1194,6 +1236,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,40 @@ 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.
+ *
+ * AND YET DROPPING IT IS THE WRONG ANSWER FOR A BUSY SERVER.  The threshold was
+ * written for a peer that has gone away - a frozen tab, a pulled cable.  A server
+ * that is merely DELIVERING TOO MUCH hits the same number: a sub-agent that
+ * streams text emits one `subagent.event` per delta, each of which asks for a
+ * full state broadcast, and a browser that cannot parse frames as fast as they
+ * arrive lets the buffer grow past the threshold while it is perfectly alive.
+ * The browser then reports code 1006 and reconnects, only to be dropped again -
+ * "连接中 / 断连 / 连接中" forever - and the user's work is interrupted rather
+ * than slowed.
+ *
+ * So a frame that does not fit is DROPPED, not the connection: the next frame
+ * carries the same state, and a browser that is behind will catch up on the next
+ * one instead of being disconnected and losing its place.  The connection is
+ * only terminated when the socket itself is gone (readyState is not OPEN).
+ */
+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 +45,67 @@ 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;
+    /**
+     * DIAGNOSTIC ONLY - sends every requested state frame immediately instead of merging them.
+     *
+     * The legacy flood switch (`SUPER_PI_LEGACY_SUBAGENT_FLOOD=1`) restores the pre-fix WIRING: one
+     * full state broadcast per sub-agent event. But the 150ms merge window would still fold those
+     * broadcasts into one frame, so the "before" measurement would not actually be "before" - it
+     * would show a flood that the fixed server also survives, and the A/B comparison would prove
+     * nothing. This flag removes the window as well, so the probe can reproduce the real pre-fix
+     * wire shape: one frame per request, sent at once.
+     *
+     * Never set outside a probe or a regression test that is asserting the old behaviour.
+     */
+    private readonly sendStateImmediately;
+    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;
+    /**
+     * BROADCAST STATES IN A TIME WINDOW, NOT IN A MICROTASK.
+     *
+     * The microtask flag this replaces merged only the calls that arrived within the
+     * SAME tick.  A sub-agent that streams text emits one `subagent.event` per delta,
+     * each asking for a full state broadcast, and those deltas arrive across many
+     * ticks - so a single sub-agent run could ask for HUNDREDS of full state
+     * broadcasts.  On a machine whose state is large, that is a flood the browser
+     * cannot drain: its parse queue falls behind, the socket buffer grows, and the
+     * connection is dropped (the browser reports 1006).
+     *
+     * A window turns a burst into a handful of frames.  The state a browser receives
+     * is the LATEST state - the intermediate ones carried nothing the last one did
+     * not - so nothing is lost by sending fewer of them.  The only thing that
+     * changes is how promptly the browser sees a change, and 150ms is below the
+     * threshold at which a person notices.
+     */
+    private stateFlushScheduled;
     broadcastState(): void;
-    getStateSnapshot(): AppState;
+    private flushState;
+    /**
+     * Releases the pending state window, so a shutting-down server does not hold the event loop
+     * open on a timer whose flush would send to sockets that are already closed.
+     */
+    dispose(): void;
+    getStateSnapshot(scope?: {
+        conversationId?: string;
+    }): AppState;
 }
 export interface WsServerOptions {
     httpServer: NodeHttpServer;