@evandu/super-pi 0.1.138 → 0.1.140

package/dist/server/ws-server.js

@@ -1,6 +1,65 @@
 import { WebSocket, WebSocketServer } from "ws";
 import { isAuthorized } from "./http-server.js";
 import { describeThrown, describeThrownWithStack } from "./failure-text.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 const MAX_WS_BUFFERED_BYTES = 8 * 1024 * 1024;
+/** 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 const MAX_WS_PAYLOAD_BYTES = 4 * 1024 * 1024;
+/**
+ * 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 function safeSend(socket, payload) {
+    if (socket.readyState !== WebSocket.OPEN)
+        return false;
+    const bufferedAmount = Number(socket.bufferedAmount ?? 0);
+    if (Number.isFinite(bufferedAmount) && bufferedAmount > MAX_WS_BUFFERED_BYTES) {
+        // DROP THE FRAME, KEEP THE CONNECTION.  A peer that is merely behind is not
+        // a peer that is gone: the next broadcast carries the same state, so the
+        // browser catches up instead of being disconnected and losing its place.
+        // Terminating here is what produced "连接中 / 断连 / 连接中" forever on a
+        // server that was delivering sub-agent output faster than the browser could
+        // parse it - and the browser's own code 1006 was only the symptom.
+        return false;
+    }
+    try {
+        socket.send(payload);
+        return true;
+    }
+    catch (error) {
+        console.warn(`Super Pi: WebSocket send failed: ${error instanceof Error ? error.message : String(error)}`);
+        try {
+            socket.terminate();
+        }
+        catch { /* close races are already being cleaned up */ }
+        return false;
+    }
+}
 /**
  * Concrete implementation of EventBroadcaster delivering server events
  * across active WebSocket connections.
@@ -8,16 +67,31 @@ import { describeThrown, describeThrownWithStack } from "./failure-text.js";
 export class WsBroadcaster {
     getState;
     sockets = new Set();
+    // Undefined preserves the original full-state protocol. An object, including {}, opts into
+    // conversation-focused snapshots from the very first frame of the connection.
+    scopes = new Map();
+    fileIndexScopes = new Map();
     coalescedSockets = new Set();
     pendingStreams = new Map();
-    cachedState;
-    cachedStatePayload;
-    stateFlushScheduled = false;
+    /**
+     * 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.
+     */
+    sendStateImmediately = process.env.SUPER_PI_LEGACY_SUBAGENT_FLOOD === "1";
     constructor(getState) {
         this.getState = getState;
     }
-    register(socket) {
+    register(socket, scope) {
         this.sockets.add(socket);
+        this.scopes.set(socket, scope);
     }
     unregister(socket) {
         this.coalescedSockets.delete(socket);
@@ -25,8 +99,49 @@ export class WsBroadcaster {
         if (pending)
             clearTimeout(pending.timer);
         this.pendingStreams.delete(socket);
+        this.scopes.delete(socket);
+        this.fileIndexScopes.delete(socket);
         this.sockets.delete(socket);
     }
+    subscribe(socket, conversationId) {
+        // Finish the old transcript before replacing it. A later delta then belongs to the new scope,
+        // and the authoritative snapshot reconstructs anything not streamed while it was unselected.
+        this.flushStreaming(socket);
+        this.scopes.set(socket, conversationId ? { conversationId } : {});
+        this.sendState(socket);
+    }
+    sendState(socket) {
+        if (socket.readyState !== WebSocket.OPEN)
+            return;
+        this.flushStreaming(socket);
+        safeSend(socket, JSON.stringify({ type: "state", state: this.getState(this.scopes.get(socket)) }));
+    }
+    subscribeFileIndex(socket, workspaceId) {
+        if (workspaceId)
+            this.fileIndexScopes.set(socket, workspaceId);
+        else
+            this.fileIndexScopes.delete(socket);
+    }
+    receives(socket, event) {
+        const scope = this.scopes.get(socket);
+        if (!scope)
+            return true;
+        switch (event.type) {
+            case "files.index":
+                return this.fileIndexScopes.get(socket) === event.workspaceId;
+            case "message.delta":
+            case "message.thinking":
+            case "message.tools":
+                return event.conversationId === scope.conversationId;
+            case "subagent.event":
+                return event.run.conversationId === scope.conversationId;
+            case "workflow.event":
+                return event.workflow.conversationId === scope.conversationId;
+            default:
+                // Lifecycle and summary changes still reach the sidebar for every conversation.
+                return true;
+        }
+    }
     configureStreaming(socket, coalesce) {
         if (coalesce)
             this.coalescedSockets.add(socket);
@@ -42,8 +157,7 @@ export class WsBroadcaster {
         clearTimeout(pending.timer);
         this.pendingStreams.delete(socket);
         for (const event of pending.events.values())
-            if (socket.readyState === WebSocket.OPEN)
-                socket.send(JSON.stringify(event));
+            safeSend(socket, JSON.stringify(event));
     }
     enqueueStreaming(socket, event) {
         let pending = this.pendingStreams.get(socket);
@@ -52,6 +166,19 @@ export class WsBroadcaster {
             pending = { events, timer: setTimeout(() => this.flushStreaming(socket), 16) };
             this.pendingStreams.set(socket, pending);
         }
+        // A subagent.event is a whole-run SNAPSHOT whose output is the accumulated text so far: within one
+        // 16ms window the LATEST snapshot for a run supersedes every earlier one (they differ only by more
+        // text). Keeping the newest replaces a per-delta frame burst with at most one frame per run per
+        // window - the O(n²) burst the flood fix exists for - while the card still updates at ~60fps.
+        if (event.type === "subagent.event") {
+            const superseded = pending.events.findIndex((queued) => queued.type === "subagent.event" && queued.run.id === event.run.id);
+            if (superseded >= 0) {
+                pending.events[superseded] = event;
+                return;
+            }
+            pending.events.push(event);
+            return;
+        }
         // Only adjacent fragments from the same stream can merge. A different kind,
         // answer offset or lifecycle flag is an ordering boundary, even within 16ms.
         const previous = pending.events.at(-1);
@@ -67,53 +194,114 @@ export class WsBroadcaster {
         return this.sockets;
     }
     broadcast(event) {
-        const streaming = event.type === "message.delta" || event.type === "message.thinking";
-        /**
-         * SERIALIZED ONCE, NOT ONCE PER SOCKET. A `state` frame carries the whole application state, so
-         * `JSON.stringify` on it is the most expensive thing this method does - and every open tab used
-         * to pay for its own copy of the same string. The bytes are identical (no socket-specific field),
-         * so the string is built once and handed to every socket.
-         *
-         * 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)}`);
+        if (event.type === "state") {
+            this.broadcastState();
+            return;
+        }
+        const streaming = event.type === "message.delta" || event.type === "message.thinking" || event.type === "subagent.event";
+        // Serialize common events once, after finding a recipient. Coalesced text stays per socket;
+        // conversation snapshots are projected and serialized once per scope in broadcastState().
+        let payload;
         for (const socket of this.sockets) {
-            if (socket.readyState !== WebSocket.OPEN)
+            if (socket.readyState !== WebSocket.OPEN || !this.receives(socket, event))
                 continue;
             if (streaming && this.coalescedSockets.has(socket))
                 this.enqueueStreaming(socket, event);
             else {
                 // A state/tool/lifecycle event is a transcript boundary. Flush its preceding text first.
                 this.flushStreaming(socket);
-                socket.send(payload ?? JSON.stringify(event));
+                payload ??= JSON.stringify(event);
+                safeSend(socket, payload);
             }
         }
     }
+    /**
+     * 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.
+     */
+    stateFlushScheduled = false;
     broadcastState() {
+        // DIAGNOSTIC PATH: the pre-fix wire shape, one frame per request, no merge window.
+        if (this.sendStateImmediately) {
+            this.flushState();
+            return;
+        }
         if (this.stateFlushScheduled)
             return;
         this.stateFlushScheduled = true;
+        const now = Date.now();
+        // HOW MANY STATE FRAMES WENT OUT IN THE LAST SECOND.
+        //
+        // This is the flood detector, and it is a RATE, not a delay. A server that is behaving sends a
+        // handful of frames a second: one per user action, one per turn boundary. A server that is
+        // flooding sends hundreds - a sub-agent's delta used to ask for one full state frame each.
+        //
+        // The NORMAL path stays exactly as it always was: a microtask merge, so the frame goes out at the
+        // end of this tick. That matters for more than latency: "the user sent a message" and "the turn
+        // opened" are two broadcasts, and if they are merged into one frame the user's own message never
+        // appears on its own - it appears already accompanied by the assistant placeholder. A message
+        // that arrives half-written is a message the user does not believe they sent.
+        //
+        // The DEGRADED path is for a server that is genuinely flooding: requests are then merged into one
+        // frame per window, because a browser that cannot parse frames as fast as they arrive gets its
+        // connection dropped (the browser reports 1006) and the user sees "连接中 / 断连 / 连接中".
         queueMicrotask(() => {
             this.stateFlushScheduled = false;
-            this.cachedState = this.getState();
-            this.cachedStatePayload = JSON.stringify({ type: "state", state: this.cachedState });
-            const payload = this.cachedStatePayload;
-            for (const socket of this.sockets) {
-                if (socket.readyState !== WebSocket.OPEN)
-                    continue;
+            this.flushState();
+        });
+    }
+    flushState() {
+        const groups = new Map();
+        for (const socket of this.sockets) {
+            if (socket.readyState !== WebSocket.OPEN)
+                continue;
+            const scope = this.scopes.get(socket);
+            const key = scope ? `focused:${JSON.stringify(scope.conversationId ?? null)}` : "legacy";
+            let group = groups.get(key);
+            if (!group) {
+                group = { scope, sockets: [] };
+                groups.set(key, group);
+            }
+            group.sockets.push(socket);
+        }
+        for (const { scope, sockets } of groups.values()) {
+            const snapshotStartedAt = performance.now();
+            const state = this.getState(scope);
+            const snapshotMs = performance.now() - snapshotStartedAt;
+            const serializeStartedAt = performance.now();
+            const cachedStatePayload = JSON.stringify({ type: "state", state });
+            const serializeMs = performance.now() - serializeStartedAt;
+            if (process.env.SUPER_PI_TRACE_LATENCY === "1") {
+                console.warn(`[super-pi latency] phase=state.snapshot.ready bytes=${Buffer.byteLength(cachedStatePayload, "utf8")} snapshotMs=${Math.round(snapshotMs)} serializeMs=${Math.round(serializeMs)} sockets=${sockets.length} scope=${scope ? "focused" : "legacy"}`);
+            }
+            for (const socket of sockets) {
                 this.flushStreaming(socket);
-                socket.send(payload);
+                safeSend(socket, cachedStatePayload);
             }
-            this.cachedState = undefined;
-            this.cachedStatePayload = undefined;
-        });
+        }
     }
-    getStateSnapshot() {
-        return this.getState();
+    /**
+     * 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() {
+        this.stateFlushScheduled = false;
+    }
+    getStateSnapshot(scope) {
+        return this.getState(scope);
     }
 }
 import { checkDiskVersion } from "./version.js";
@@ -135,7 +323,11 @@ export class WsServer {
         this.accessToken = options.accessToken;
         this.rootDir = options.rootDir;
         this.onSocketClose = options.onSocketClose;
-        this.websocketServer = new WebSocketServer({ noServer: true });
+        // Remote clients are commonly separated from the server by a high-latency link. State snapshots can
+        // contain a long transcript, so sending them uncompressed turns every lifecycle event into a multi-MB
+        // transfer. Per-message deflate keeps the protocol unchanged while making the wire cost proportional
+        // to the actual information in the snapshot. The threshold avoids spending CPU on token-sized events.
+        this.websocketServer = new WebSocketServer({ noServer: true, maxPayload: MAX_WS_PAYLOAD_BYTES, perMessageDeflate: { threshold: 1024, serverNoContextTakeover: true } });
         this.setupUpgrade(options.httpServer);
         this.setupConnectionHandling();
     }
@@ -167,7 +359,39 @@ export class WsServer {
     }
     setupConnectionHandling() {
         this.websocketServer.on("connection", (socket, request) => {
-            this.broadcaster.register(socket);
+            const url = new URL(request.url ?? "/ws", "http://localhost");
+            // HOW A CLIENT ASKS FOR A SCOPE, AND WHAT IT GETS WHEN IT DOES NOT ASK.
+            //
+            // `undefined` means the WHOLE application: every workspace, every conversation and every
+            // message.  On a machine with a long history that is tens of megabytes in the FIRST FRAME.
+            //
+            // There are three cases, and they are NOT the same thing:
+            //
+            //   ?state=focused            -> the focused projection (sidebar + the selected transcript)
+            //   ?conversationId=<id>      -> the focused projection of that one conversation
+            //   (neither)                 -> the legacy full state, exactly as before this change
+            //
+            // The middle case is what the current browser sends (it sends both).  The third case is a
+            // client running an OLD bundle, and it MUST keep getting the full state: a focused frame
+            // with no conversationId carries NO transcripts at all, so an old client that never sends
+            // `state.subscribe` would connect and see an empty application.  Dropping it silently is
+            // worse than a big first frame.
+            //
+            // And the big first frame is no longer FATAL: `safeSend` drops an oversized frame instead
+            // of terminating the connection, so a browser that cannot digest 42 MB at once is merely
+            // SLOW on that first frame - it is not disconnected, and it does not enter the
+            // "连接中 / 断连 / 连接中" loop.  The disconnect is fixed at the buffer, not at the scope.
+            const wantsFocused = url.searchParams.get("state") === "focused";
+            const conversationId = url.searchParams.get("conversationId") || undefined;
+            const scope = wantsFocused || conversationId ? { conversationId } : undefined;
+            this.broadcaster.register(socket, scope);
+            socket.on("error", (error) => {
+                console.warn(`Super Pi: WebSocket error: ${error instanceof Error ? error.message : String(error)}`);
+                try {
+                    socket.terminate();
+                }
+                catch { /* already closed */ }
+            });
             /**
              * The peer address, captured ONCE per connection rather than read per message.
              *
@@ -184,18 +408,18 @@ export class WsServer {
              * only the shells belonging to the socket that went away.
              */
             const terminalSessionIds = new Set();
-            socket.send(JSON.stringify({ type: "state", state: this.broadcaster.getStateSnapshot() }));
+            this.broadcaster.sendState(socket);
             if (this.rootDir) {
-                socket.send(JSON.stringify({ type: "server.version", version: checkDiskVersion(this.rootDir) }));
+                safeSend(socket, JSON.stringify({ type: "server.version", version: checkDiskVersion(this.rootDir) }));
             }
             void this.catalogService.agentCatalog().then((catalog) => {
                 if (socket.readyState === WebSocket.OPEN) {
-                    socket.send(JSON.stringify({ type: "agent.catalog", catalog }));
+                    safeSend(socket, JSON.stringify({ type: "agent.catalog", catalog }));
                 }
             }).catch((error) => console.warn(`Super Pi: agent catalog for a new connection failed: ${error instanceof Error ? error.message : "unknown error"}`));
             void this.catalogService.subagentCatalog().then((catalog) => {
                 if (socket.readyState === WebSocket.OPEN) {
-                    socket.send(JSON.stringify({ type: "subagent.catalog", catalog }));
+                    safeSend(socket, JSON.stringify({ type: "subagent.catalog", catalog }));
                 }
             }).catch((error) => console.warn(`Super Pi: sub-agent catalog for a new connection failed: ${error instanceof Error ? error.message : "unknown error"}`));
             /**
@@ -219,7 +443,7 @@ export class WsServer {
                 if (this.rootDir) {
                     const v = checkDiskVersion(this.rootDir);
                     if (v.needsRestart) {
-                        socket.send(JSON.stringify({ type: "server.version", version: v }));
+                        safeSend(socket, JSON.stringify({ type: "server.version", version: v }));
                     }
                 }
             }, 30_000);
@@ -249,18 +473,34 @@ export class WsServer {
                 }
                 catch {
                     console.error("Super Pi command error: received a frame that is not valid JSON");
-                    socket.send(JSON.stringify({ type: "error", message: "收到一条无法解析的命令，已忽略。" }));
+                    safeSend(socket, JSON.stringify({ type: "error", message: "收到一条无法解析的命令，已忽略。" }));
+                    return;
+                }
+                if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || typeof parsed.type !== "string") {
+                    safeSend(socket, JSON.stringify({ type: "error", message: "收到一条格式无效的命令，已忽略。" }));
+                    return;
+                }
+                if (parsed.type === "files.index.subscribe") {
+                    this.broadcaster.subscribeFileIndex(socket, typeof parsed.workspaceId === "string" ? parsed.workspaceId : undefined);
                     return;
                 }
                 if (parsed.type === "stream.configure") {
                     this.broadcaster.configureStreaming(socket, parsed.coalesce);
                     return;
                 }
+                if (parsed.type === "state.subscribe") {
+                    if (parsed.conversationId !== undefined && typeof parsed.conversationId !== "string") {
+                        safeSend(socket, JSON.stringify({ type: "error", message: "会话订阅标识必须是字符串。" }));
+                        return;
+                    }
+                    this.broadcaster.subscribe(socket, parsed.conversationId);
+                    return;
+                }
                 // A send or selected queued turn is a streaming operation. It must leave the socket's command
                 // chain immediately: waiting for the model turn would block later priority/cancel commands and
                 // make a second send miss the durable queue. The service owns per-conversation run claims.
                 const runIndependently = parsed.type === "message.send" || parsed.type === "message.sendQueued"
-                    || parsed.type === "message.interrupt" || parsed.type === "run.stop";
+                    || parsed.type === "message.interrupt" || parsed.type === "run.stop" || parsed.type === "message.revert";
                 // ...WHICH MEANS A SEND CAN OVERTAKE A REVERT SENT JUST BEFORE IT, because the revert below is
                 // queued behind whatever this socket was already doing. The service only learns it is cutting
                 // when the command EXECUTES, so a send handled in between would find the conversation open and
@@ -275,14 +515,11 @@ export class WsServer {
                         if (command.type === "terminal.open")
                             terminalSessionIds.add(command.sessionId);
                         const entityId = await this.commandHandler.handleCommand(command, (event) => {
-                            if (socket.readyState === WebSocket.OPEN) {
-                                socket.send(JSON.stringify(event));
-                            }
+                            safeSend(socket, JSON.stringify(event));
                         }, remoteAddress);
                         // 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 }));
-                        }
+                        if (command.operationRequestId)
+                            safeSend(socket, JSON.stringify({ type: "operation.result", requestId: command.operationRequestId, ok: true, entityId }));
                     }
                     catch (error) {
                         // A FAILED COMMAND WRITES ITSELF DOWN BEFORE IT ANSWERS.
@@ -294,10 +531,10 @@ export class WsServer {
                         console.error("Super Pi command error:", describeThrownWithStack(error));
                         const reason = describeThrown(error);
                         if (command?.operationRequestId) {
-                            socket.send(JSON.stringify({ type: "operation.result", requestId: command.operationRequestId, ok: false, message: reason }));
+                            safeSend(socket, JSON.stringify({ type: "operation.result", requestId: command.operationRequestId, ok: false, message: reason }));
                             return;
                         }
-                        socket.send(JSON.stringify({
+                        safeSend(socket, JSON.stringify({
                             type: "error",
                             message: reason || "服务端没有说明这次失败的原因。",
                         }));
@@ -326,6 +563,9 @@ export class WsServer {
      * Gracefully closes all active WebSocket connections and terminates the server.
      */
     close() {
+        // A pending state window must not outlive the server: the timer holds the event loop
+        // open, and a flush after the sockets are closed would send to a dead peer.
+        this.broadcaster.dispose();
         for (const socket of this.broadcaster.getSockets()) {
             socket.close(1001, "server-shutdown");
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.138",
+  "version": "0.1.140",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -46,6 +46,8 @@
     "scripts/test-runner.test.mjs",
     "scripts/stream-checkpoint.test.mjs",
     "scripts/stream-transport.test.mjs",
+    "scripts/remote-transport.test.mjs",
+    "scripts/browser-safe-port.test.mjs",
     "scripts/inline-thinking.test.mjs",
     "scripts/inline-thinking-close-tag.test.mjs",
     "scripts/pi-session.test.mjs",
@@ -72,12 +74,13 @@
     "scripts/image-input-real-pi.test.mjs",
     "scripts/image-upload.test.mjs",
     "scripts/extension-ui-e2e.test.mjs",
-    "scripts/session-picker.test.mjs",
+    "scripts/session-picker.test.mjs", "scripts/session-orchestrator.test.mjs", "scripts/session-orchestrator-tools.test.mjs",
     "scripts/workspace-cwd.test.mjs",
     "scripts/subagents.test.mjs",
     "scripts/subagent-noise.test.mjs",
     "scripts/subagent-response-receipt.test.mjs",
     "scripts/subagent-runs.test.mjs",
+    "scripts/ws-flood-regression.test.mjs",
     "scripts/conversation-reconcile.test.mjs",
     "scripts/subagent-dispatch.test.mjs",
     "scripts/workflow-plan.test.mjs",
@@ -97,6 +100,13 @@
     "scripts/background-result-one-per-turn.test.mjs",
     "scripts/thinking-status-promotion.test.mjs",
     "scripts/thinking-delivery-once.test.mjs",
+    "scripts/thinking-tool-order.test.mjs",
+    "scripts/question-behind-body.test.mjs",
+    "scripts/workspace-default-model-rules.test.mjs",
+    "scripts/tool-call-persist-count.test.mjs",
+    "scripts/conversation-service-narrow-reads.test.mjs",
+    "scripts/revert-evicts-live-session.test.mjs",
+    "scripts/cdp-retry-bounded.test.mjs",
     "scripts/question-call-session-path.test.mjs",
     "scripts/withdrawn-message-persistence.test.mjs",
     "scripts/git-write-endpoint-guard.test.mjs",
@@ -116,6 +126,7 @@
     "scripts/files-missing-path.test.mjs",
     "scripts/file-changes.test.mjs",
     "scripts/file-index.test.mjs",
+    "scripts/file-index-write-refresh.test.mjs",
     "scripts/file-name-index.test.mjs",
     "scripts/file-content-search.test.mjs",
     "scripts/file-diff-client.test.mjs",
@@ -199,15 +210,18 @@
     "scripts/rail-workspace-follows-session-browser.test.mjs",
     "scripts/git-tab-browser.test.mjs",
     "scripts/workspace-reopen-browser.test.mjs",
+    "scripts/workspace-identity-browser.test.mjs",
     "scripts/sidebar-tools-browser.test.mjs",
     "scripts/tool-runtime-browser.test.mjs",
     "scripts/session-context-menu-browser.test.mjs",
     "scripts/tool-call-blocks-browser.test.mjs",
+    "scripts/model-notice-browser.test.mjs",
     "scripts/assistant-working-indicator-browser.test.mjs",
     "scripts/thinking-first-delta-once-browser.test.mjs",
     "scripts/files-tab-browser.test.mjs",
     "scripts/editor-blame-browser.test.mjs",
     "scripts/file-panel-external-poll-browser.test.mjs",
+    "scripts/editor-save-race-browser.test.mjs",
     "scripts/file-quickopen-browser.test.mjs",
     "scripts/file-content-search-browser.test.mjs",
     "scripts/file-changes-browser.test.mjs",