@wrongstack/webui 0.319.0 → 1.0.0

package/dist/lib/platform.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Platform-dependent presentation details.
+ *
+ * The keyboard handlers throughout the app already accept either modifier
+ * (`e.ctrlKey || e.metaKey`), so the SHORTCUTS WORK on macOS — but every label
+ * that advertised them said "Ctrl", which is the key a Mac user does not press.
+ * The activity bar tooltips, the "…" overflow menu and the shortcuts overlay
+ * all hard-coded the string. This module is the one place that decides.
+ * See docs/audit/webui-full-review-2026-09-03.md B-15.
+ */
+/**
+ * True on Apple platforms, where the primary chord modifier is ⌘ rather than
+ * Ctrl. Read once at module load: the platform cannot change mid-session, and
+ * a per-render probe would be a needless global access in hot paths.
+ *
+ * `navigator.userAgentData.platform` is the modern, non-deprecated source;
+ * `navigator.platform` is the fallback for browsers that do not ship UA-CH
+ * (Safari and Firefox, which is to say most of the Macs this matters for).
+ * Guarded for non-browser contexts (SSR-style imports, vitest node env).
+ */
+export declare const IS_APPLE_PLATFORM: boolean;
+/**
+ * Label for the primary chord modifier: `⌘` on Apple platforms, `Ctrl`
+ * elsewhere. Deliberately NOT translated — modifier keys are engraved on the
+ * hardware and carry the same name in every locale this app ships.
+ */
+export declare const MOD_KEY_LABEL: string;
+/** `Alt` is `⌥` on Apple keyboards. Same reasoning as {@link MOD_KEY_LABEL}. */
+export declare const ALT_KEY_LABEL: string;
+/** `Shift` renders as `⇧` alongside the other glyphs on Apple keyboards. */
+export declare const SHIFT_KEY_LABEL: string;
+/**
+ * Render one key name from a shortcut table for the current platform.
+ *
+ * Tables stay written in the portable `['Ctrl', 'Shift', 'W']` form; this maps
+ * the three modifier names at display time and passes everything else through
+ * (letters, digits, `F5`, `Enter`, arrows) unchanged.
+ */
+export declare function platformKeyLabel(key: string): string;
+//# sourceMappingURL=platform.d.ts.map

package/dist/lib/view-navigation.d.ts

@@ -1,10 +1,35 @@
-import { type Activity } from '@/stores/ui-store';
+import { type Activity, type View } from '@/stores/ui-store';
+/**
+ * A view that is PAIRED with an activity-bar side panel: opening the panel
+ * steers the main area here, and vice versa.
+ */
 export type PanelMainView = 'chat' | 'files' | 'skill' | 'changes' | 'mailbox' | 'design-gallery';
+/**
+ * A standalone main view with its own activity-bar icon (or a slot in the "…"
+ * utilities menu). Selecting one collapses the side panel.
+ */
 export type MainView = 'goal' | 'kanban' | 'sddhub' | 'settings' | 'memory' | 'roster' | 'codemap' | 'techstack' | 'chronicle' | 'intake' | 'prompts' | 'chimera';
-export type AppView = PanelMainView | MainView | 'sessions' | 'session-inspect' | 'setup' | 'debug' | 'refresh-debug' | 'analytics';
+/**
+ * A view with no bar affordance at all — reached from the command palette, a
+ * deep link, or another view's action. Diagnostics and drill-downs live here.
+ */
+export type UnlistedView = 'sessions' | 'session-inspect' | 'setup' | 'context' | 'debug' | 'refresh-debug' | 'analytics' | 'deadcode';
+/**
+ * Every view the app can display. Derived from `VIEWS` in the UI store rather
+ * than re-declared, so the router and the navigation helpers cannot disagree.
+ */
+export type AppView = View;
 export declare const PANEL_VIEW_BY_ACTIVITY: Record<Activity, PanelMainView>;
 export declare const VIEW_ACTIVITY: Partial<Record<AppView, Activity>>;
 export declare const ACTIVITY_SHORTCUT_BY_KEY: Readonly<Record<string, Activity>>;
+/**
+ * Chord labels shown in activity-bar tooltips and the "…" overflow menu.
+ *
+ * Built from `ACTIVITY_SHORTCUT_BY_KEY` rather than re-typed, so a rebound
+ * digit cannot advertise the old one, and from `MOD_KEY_LABEL` so a Mac shows
+ * `⌘1` for a chord its handler already accepts via `e.metaKey`.
+ * The `agents` activity has no digit and stays deliberately unlabelled.
+ */
 export declare const ACTIVITY_SHORTCUT_LABEL_BY_ACTIVITY: Readonly<Record<Activity, string>>;
 export declare function pairedViewForActivity(activity: Activity): PanelMainView;
 export declare function shortcutLabelForActivity(activity: Activity): string;

package/dist/lib/ws-client-auth.d.ts

@@ -0,0 +1,17 @@
+export declare function wsUrlCanUseAuthCookie(wsUrl: string): boolean;
+/**
+ * Exchange a stored token for an HttpOnly auth cookie via `/ws-auth`.
+ * Called once before the first connect so subsequent reconnections can
+ * drop the `?token=` from the WS URL (C-2 fix — token-in-URL closes
+ * the C-598 query-string exposure class). No-op when the cookie is
+ * already set, when the server is on a loopback bind (no token
+ * required), or when no token is available yet.
+ *
+ * Failure is non-fatal only for local loopback or explicit public-WS URL
+ * flows. Normal remote browser clients need the cookie path so the token does
+ * not remain in the WebSocket URL.
+ *
+ * Returns the possibly-stripped WS URL.
+ */
+export declare function ensureAuthCookie(wsUrl: string): Promise<string>;
+//# sourceMappingURL=ws-client-auth.d.ts.map

package/dist/lib/ws-client-connection.d.ts

@@ -0,0 +1,26 @@
+import { planConnectionReconnect, type SurfaceConnectionState } from '@wrongstack/webui-protocol';
+import type { WSServerMessage } from '../types';
+export interface SocketLifecycleCallbacks {
+    isCurrentGeneration: () => boolean;
+    onOpen: () => void;
+    onMessage: (msg: WSServerMessage) => void;
+    onError: (lastError: string) => void;
+    onClose: (reasonText: string | undefined, isInitialFailure: boolean) => void;
+    onTimeout: () => void;
+}
+/**
+ * Bind standard WebSocket lifecycle handlers (open, message, error, close)
+ * with generation check and connection timeout.
+ */
+export declare function bindSocketLifecycle(ws: WebSocket, callbacks: SocketLifecycleCallbacks, timeoutMs?: number): {
+    cancelTimeout: () => void;
+};
+export declare function planReconnectHelper(state: SurfaceConnectionState, maxReconnectAttempts: number, queueLimit: number): {
+    state: SurfaceConnectionState;
+    plan: ReturnType<typeof planConnectionReconnect>['plan'];
+};
+export declare function retryNowHelper(statusState: string, reconnectTimer: ReturnType<typeof setTimeout> | null, connectionState: SurfaceConnectionState, connectFn: () => Promise<void>): {
+    reconnectTimer: ReturnType<typeof setTimeout> | null;
+    connectionState: SurfaceConnectionState;
+};
+//# sourceMappingURL=ws-client-connection.d.ts.map

package/dist/lib/ws-client-contracts.d.ts

@@ -6,5 +6,15 @@ export interface WSSendOptions {
     echoToChat?: boolean | undefined;
     /** Reject one-shot actions instead of replaying them after a reconnect. */
     queueIfDisconnected?: boolean | undefined;
+    /**
+     * Caller-supplied correlation id. When `echoToChat: false` and the request
+     * type has a known response counterpart, the client will mint one if you
+     * don't. The id is stamped on the outgoing payload so the server can echo
+     * it back, and the response suppression is keyed by it (B-04).
+     *
+     * Supply one when the same call is made in a loop and you need to tell
+     * which response belongs to which call.
+     */
+    requestId?: string | undefined;
 }
 //# sourceMappingURL=ws-client-contracts.d.ts.map

package/dist/lib/ws-client-echo.d.ts

@@ -0,0 +1,46 @@
+import type { WSClientMessage, WSServerMessage } from '../types';
+export declare const CHAT_ECHO_RESPONSE_BY_REQUEST: Partial<Record<WSClientMessage['type'], WSServerMessage['type']>>;
+export declare const CHAT_ECHO_SUPPRESSION_TTL_MS = 30000;
+/**
+ * Cadence of the lazy echo-suppression sweep (see ensureEchoSweep). Chosen
+ * at 2x the TTL granularity: stale timestamps are released within one
+ * sweep interval of expiry without a per-push clock read.
+ */
+export declare const CHAT_ECHO_SUPPRESSION_SWEEP_MS = 15000;
+export declare class WsClientEchoSuppression {
+    suppressedChatEchoes: Map<string, number>;
+    echoSweepTimer: ReturnType<typeof setInterval> | null;
+    registerSuppression(message: WSClientMessage, options: {
+        echoToChat?: boolean;
+        requestId?: string;
+    }): void;
+    /**
+     * Consume one UI-originated response that must not be mirrored into chat.
+     *
+     * B-04: the suppression map is keyed by requestId. The caller passes the
+     * full message so we can read the `requestId` echoed by the server; only
+     * the matching request consumes a slot. A response with no (or
+     * unrecognised) requestId is left alone — that is exactly the case the
+     * previous FIFO queue got wrong: tab A's suppression swallowed tab B's
+     * chat-issued `/tools` reply when B's response happened to arrive first.
+     *
+     * Pass `msg` whenever the caller has it (the central WS_HANDLERS path
+     * does). When `msg` is missing, no suppression is possible — that
+     * matches the audit's instruction that suppression must be correlated
+     * end-to-end, never type-keyed.
+     */
+    consumeSuppressedChatEcho(responseType: string, msg?: WSServerMessage): boolean;
+    /**
+     * Lazy periodic sweep for `suppressedChatEchoes`. TTL trimming otherwise
+     * runs only on consume — a requestId that was minted but never consumed
+     * (chat view unmounted, user on another screen) would otherwise retain
+     * its timestamp indefinitely. The sweep bounds retention to TTL + one
+     * sweep interval and self-stops when the map empties, so no timer runs
+     * for clients that never suppress. RAM-leak audit 2026-08-11 Finding 4
+     * / fix 2026-08-16.
+     */
+    private ensureEchoSweep;
+    private sweepSuppressedChatEchoes;
+    clear(): void;
+}
+//# sourceMappingURL=ws-client-echo.d.ts.map

package/dist/lib/ws-client-queue.d.ts

@@ -0,0 +1,18 @@
+import type { WSClientMessage } from '../types';
+export interface QueueState {
+    messageQueue: WSClientMessage[];
+    messageQueueChars: number;
+    messageQueueWeights: WeakMap<object, number>;
+}
+/**
+ * FIFO-drop oldest by both count and serialized size. A count-only cap
+ * still allows a disconnected tab to retain hundreds of multi-megabyte
+ * image messages.
+ */
+export declare function enqueueMessage(queueState: QueueState, message: WSClientMessage, serialized: string, maxQueuedMessages: number, maxQueuedChars: number): boolean;
+/**
+ * Drain the offline queue onto a freshly-opened socket.
+ * Local array drain makes the loop finite even if socket state changes.
+ */
+export declare function flushMessageQueueHelper(queueState: QueueState, sendFn: (msg: WSClientMessage) => void): void;
+//# sourceMappingURL=ws-client-queue.d.ts.map

package/dist/lib/ws-client-session-methods.d.ts

@@ -0,0 +1,54 @@
+import type { WSClientMessage, WSModelSwitchResult, WSServerMessage, WSUserMessageImage } from '../types';
+import type { WSSendOptions } from './ws-client-contracts';
+import type { EventHandler, PendingConfirm } from './ws-client-utils';
+/** Options for `sendMailboxMessage` — a mailbox message of a given intent
+ *  type (btw, steer, note, …) routed to a target agent/role. Shared by the
+ *  ws-client method, the `useWebSocket` wrapper, and UI prop contracts. */
+export type WSMailboxSendOptions = {
+    type: 'note' | 'ask' | 'assign' | 'steer' | 'btw' | 'broadcast' | 'status' | 'result' | 'review';
+    to: string;
+    subject: string;
+    body: string;
+    priority?: 'low' | 'normal' | 'high' | undefined;
+    audience?: 'all' | 'leaders' | undefined;
+};
+export interface WsClientSessionHost {
+    send(message: WSClientMessage, options?: WSSendOptions): boolean;
+    withSession<T extends Record<string, unknown>>(payload: T, sessionId?: string | undefined): T & {
+        sessionId?: string;
+    };
+    on<K extends WSServerMessage['type']>(eventType: K, handler: (msg: Extract<WSServerMessage, {
+        type: K;
+    }>) => void): () => void;
+    on(eventType: string, handler: EventHandler): () => void;
+    pendingConfirms: Map<string, PendingConfirm>;
+    subscribedSessionIds: string[];
+    replayOnNextSubscribe: boolean;
+    armedResends: Map<string, {
+        content: string;
+        freshContext?: boolean | undefined;
+        images?: WSUserMessageImage[] | undefined;
+        armedAt: number;
+    }>;
+}
+export interface WsClientSessionMethods {
+    sendMessage(content: string, images?: WSUserMessageImage[], freshContext?: boolean, sessionId?: string | undefined): string;
+    getChimeraReports(sessionId?: string | undefined): void;
+    adviseTopic(prompt: string, timeoutMs?: number): Promise<Extract<WSServerMessage, {
+        type: 'topic.advice_result';
+    }>['payload']>;
+    sendMailboxMessage(opts: WSMailboxSendOptions, sessionId?: string | undefined): string;
+    sendAbort(sessionId?: string | undefined): void;
+    subscribeSessions(sessionIds: string[]): void;
+    clearSessionSubscription(): void;
+    sendConfirm(id: string, decision: 'yes' | 'no' | 'always' | 'deny'): void;
+    switchModel(provider: string, model: string, timeoutMs?: number): Promise<WSModelSwitchResult['payload']>;
+    shutdownCodebaseIndexServer(timeoutMs?: number): Promise<Extract<WSServerMessage, {
+        type: 'codebase.index.server.shutdown_result';
+    }>['payload']>;
+}
+export declare const sessionMethods: WsClientSessionMethods;
+export declare function installWsClientSessionMethods(ctor: {
+    prototype: Partial<WsClientSessionHost>;
+}): void;
+//# sourceMappingURL=ws-client-session-methods.d.ts.map

package/dist/lib/ws-client-swap.d.ts

@@ -0,0 +1,53 @@
+import type { WSClientMessage, WSUserMessageImage } from '../types';
+/**
+ * Stand-in target for a `session.new`: the client asked the server to create a
+ * session and cannot name it until the answer arrives. Never a real id — the
+ * server issues opaque ids, and the leading `#` is not in that alphabet.
+ */
+export declare const NEW_SESSION_SWAP_TARGET = "#pending-new-session";
+/** Bound on `seenSessionIds`; four tabs plus a long tail of retired ones. */
+export declare const MAX_SEEN_SESSION_IDS = 64;
+/** Minimum spacing between automatic `session_not_ready` retries for ONE session. */
+export declare const NOT_READY_RETRY_COOLDOWN_MS = 15000;
+/** Upper bound on parked retries, so tab churn cannot grow the map forever. */
+export declare const MAX_ARMED_RESENDS = 8;
+/**
+ * The session a swap request is asking to land on, or `null` when the message
+ * is not a swap request at all. `session.resume` names its target in
+ * `payload.id`; `session.new` has none yet.
+ */
+export declare function resolveSwapTarget(message: WSClientMessage): string | null;
+/**
+ * Is this `session.start` the answer to the swap this client is waiting on?
+ *
+ * A resume names its target, so it matches by id. A `session.new` cannot —
+ * the server invents the id — so its answer is recognised as the first RESET
+ * announcement naming a session this client has never seen. Requiring
+ * `reset` keeps an unrelated first-sight announcement (a background tab the
+ * server announces on its own) from consuming the grant.
+ */
+export declare function matchesPendingSwap(pendingSwapTarget: string | null, seenSessionIds: Set<string>, payload: {
+    sessionId: string;
+    reset?: boolean;
+}): boolean;
+export declare function rememberSeenSession(seenSessionIds: Set<string>, sessionId: string): void;
+export declare function armNotReadyResendHelper(armedResends: Map<string, {
+    content: string;
+    freshContext?: boolean | undefined;
+    images?: WSUserMessageImage[] | undefined;
+    armedAt: number;
+}>, sessionId: string, message: {
+    content: string;
+    freshContext?: boolean | undefined;
+    images?: WSUserMessageImage[] | undefined;
+}): boolean;
+export declare function consumeArmedResendHelper(armedResends: Map<string, {
+    content: string;
+    freshContext?: boolean | undefined;
+    images?: WSUserMessageImage[] | undefined;
+    armedAt: number;
+}>, sessionId: string, onResend: (content: string, images?: WSUserMessageImage[], freshContext?: boolean, sessionId?: string) => void): void;
+export declare function sweepExpiredPendingConfirmsHelper(pendingConfirms: Map<string, {
+    expiresAtMs: number;
+}>, now: number): void;
+//# sourceMappingURL=ws-client-swap.d.ts.map

package/dist/lib/ws-client.d.ts

@@ -1,21 +1,11 @@
-import type { WSClientMessage, WSModelSwitchResult, WSServerMessage, WSUserMessageImage } from '../types';
+import type { WSClientMessage, WSServerMessage, WSUserMessageImage } from '../types';
 import { type WsClientActionMethods } from './ws-client-actions';
 import type { WSSendOptions } from './ws-client-contracts';
 import { type WsClientDomainMethods } from './ws-client-domain-methods';
-import { type EventHandler, type WsStatus } from './ws-client-utils';
+import { type WSMailboxSendOptions, type WsClientSessionMethods } from './ws-client-session-methods';
+import { type EventHandler, type PendingConfirm, type WsStatus } from './ws-client-utils';
 export type { WSSendOptions } from './ws-client-contracts';
-export type { WsStatus };
-/** Options for `sendMailboxMessage` — a mailbox message of a given intent
- *  type (btw, steer, note, …) routed to a target agent/role. Shared by the
- *  ws-client method, the `useWebSocket` wrapper, and UI prop contracts. */
-export type WSMailboxSendOptions = {
-    type: 'note' | 'ask' | 'assign' | 'steer' | 'btw' | 'broadcast' | 'status' | 'result' | 'review';
-    to: string;
-    subject: string;
-    body: string;
-    priority?: 'low' | 'normal' | 'high' | undefined;
-    audience?: 'all' | 'leaders' | undefined;
-};
+export type { WSMailboxSendOptions, WsStatus };
 declare class WrongStackWebSocketClientBase {
     private ws;
     private url;
@@ -36,7 +26,9 @@ declare class WrongStackWebSocketClientBase {
     private static readonly MAX_QUEUED_MESSAGES;
     /** Count-only limits are ineffective for image/base64 payloads. */
     private static readonly MAX_QUEUED_CHARS;
-    private pendingConfirms;
+    /** Shared with the session-method mixin (`WsClientSessionHost`), which is
+     *  installed onto this prototype — hence not private. */
+    pendingConfirms: Map<string, PendingConfirm>;
     /**
      * Wall-clock TTL for a `pendingConfirms` entry. The map is keyed by a
      * server-issued id and is only deleted by `sendConfirm`; a permission
@@ -87,26 +79,44 @@ declare class WrongStackWebSocketClientBase {
      * transcript? True for a page's first declaration and after every
      * reconnect; cleared as soon as one goes out. See `subscribeSessions`.
      */
-    private replayOnNextSubscribe;
+    replayOnNextSubscribe: boolean;
     /** Last declared open-tab set — see `subscribeSessions`. */
-    private subscribedSessionIds;
-    /** Minimum spacing between automatic `session_not_ready` retries for ONE session. */
-    private static readonly NOT_READY_RETRY_COOLDOWN_MS;
-    /** Upper bound on parked retries, so tab churn cannot grow the map forever. */
-    private static readonly MAX_ARMED_RESENDS;
+    subscribedSessionIds: string[];
     /**
      * Auto-retry parking for a `session_not_ready` refusal: the message the
      * server refused while its session had no live writer, held until that
      * session's `session.start` announces it open again. See `armNotReadyResend`.
      */
-    private readonly armedResends;
+    readonly armedResends: Map<string, {
+        content: string;
+        freshContext?: boolean | undefined;
+        images?: WSUserMessageImage[] | undefined;
+        armedAt: number;
+    }>;
     /** Stored last close reason / error message so the UI can show "what
      *  went wrong" while reconnecting instead of a generic spinner. */
     private lastErrorText;
     private statusListeners;
     private currentStatus;
-    private suppressedChatEchoes;
-    private echoSweepTimer;
+    /**
+     * requestId-keyed suppression map. Each `echoToChat: false` request mints
+     * a requestId, stamps it on the outgoing payload, and registers it here
+     * with an expiry timestamp. The server echoes the same requestId back
+     * in its response, and `consumeSuppressedChatEcho` looks it up to drop
+     * the chat echo only for the matching request — not for any other
+     * in-flight request of the same type from a different tab.
+     *
+     * The TTL (30 s) and a periodic sweep are the safety net for a
+     * requestId that was minted but whose response never arrived (chat
+     * unmounted mid-flight, server crash, etc.) so the map cannot grow
+     * unboundedly.
+     *
+     * B-04 (docs/audit/webui-full-review-2026-09-03.md).
+     */
+    private echoSuppression;
+    private get suppressedChatEchoes();
+    private get echoSweepTimer();
+    private set echoSweepTimer(value);
     private protocolCapabilities;
     private protocolVersion;
     supportsCapability(capability: string): boolean;
@@ -145,13 +155,7 @@ declare class WrongStackWebSocketClientBase {
      * Exchange a stored token for an HttpOnly auth cookie via `/ws-auth`.
      * Called once before the first connect so subsequent reconnections can
      * drop the `?token=` from the WS URL (C-2 fix — token-in-URL closes
-     * the C-598 query-string exposure class). No-op when the cookie is
-     * already set, when the server is on a loopback bind (no token
-     * required), or when no token is available yet.
-     *
-     * Failure is non-fatal only for local loopback or explicit public-WS URL
-     * flows. Normal remote browser clients need the cookie path so the token does
-     * not remain in the WebSocket URL.
+     * the C-598 query-string exposure class).
      */
     ensureAuthCookie(): Promise<void>;
     connect(): Promise<void>;
@@ -237,19 +241,12 @@ declare class WrongStackWebSocketClientBase {
     private sweepExpiredPendingConfirms;
     private emit;
     send(message: WSClientMessage, options?: WSSendOptions): boolean;
-    /** Consume one UI-originated response that must not be mirrored into chat. */
-    consumeSuppressedChatEcho(responseType: string): boolean;
     /**
-     * Lazy periodic sweep for `suppressedChatEchoes`. TTL trimming otherwise
-     * runs only on consume — a response type that is suppressed but never
-     * consumed (chat view unmounted, user on another screen) retains up to
-     * MAX_PER_TYPE stale timestamps indefinitely. The sweep bounds retention
-     * to TTL + one sweep interval and self-stops when the map empties, so no
-     * timer runs for clients that never suppress. RAM-leak audit 2026-08-11
-     * Finding 4 / fix 2026-08-16.
+     * Consume one UI-originated response that must not be mirrored into chat.
+     *
+     * B-04: the suppression map is keyed by requestId.
      */
-    private ensureEchoSweep;
-    private sweepSuppressedChatEchoes;
+    consumeSuppressedChatEcho(responseType: string, msg?: WSServerMessage): boolean;
     /**
      * Register a handler for a server message type. Two overloads:
      *  - `on('text_delta', (msg) => …)` — msg is narrowed to the matching union
@@ -265,39 +262,11 @@ declare class WrongStackWebSocketClientBase {
         type: K;
     }>) => void): void;
     off(eventType: string, handler: EventHandler): void;
-    sendMessage(content: string, images?: WSUserMessageImage[], freshContext?: boolean, sessionId?: string | undefined): string;
-    /** Ask the server for the persisted Chimera review reports of a session. */
-    getChimeraReports(sessionId?: string | undefined): void;
-    adviseTopic(prompt: string, timeoutMs?: number): Promise<Extract<WSServerMessage, {
-        type: 'topic.advice_result';
-    }>['payload']>;
-    /** Send a mailbox message of the given type (btw, steer, note, etc.)
-     *  to a target agent/role. Returns the requestId for response tracking. */
-    sendMailboxMessage(opts: WSMailboxSendOptions, sessionId?: string | undefined): string;
-    sendAbort(sessionId?: string | undefined): void;
-    /**
-     * Tell the server every session this page is displaying.
-     *
-     * Four tabs share ONE socket, so the server cannot infer the open set from
-     * the last message's `sessionId` — it would filter the other three tabs'
-     * runs out of every broadcast, and a background tab would simply stop
-     * producing output. Re-sent in full on every tab open/close (it replaces,
-     * it does not merge) and re-sent on reconnect, since the server forgets the
-     * set with the connection.
-     */
-    subscribeSessions(sessionIds: string[]): void;
-    /** Forget the declared set so the next call re-sends it (used on reconnect). */
-    clearSessionSubscription(): void;
-    sendConfirm(id: string, decision: 'yes' | 'no' | 'always' | 'deny'): void;
-    switchModel(provider: string, model: string, timeoutMs?: number): Promise<WSModelSwitchResult['payload']>;
-    shutdownCodebaseIndexServer(timeoutMs?: number): Promise<Extract<WSServerMessage, {
-        type: 'codebase.index.server.shutdown_result';
-    }>['payload']>;
     disconnect(): void;
     get isConnected(): boolean;
     get currentSessionId(): string | null;
 }
-export type WrongStackWebSocketClient = WrongStackWebSocketClientBase & WsClientActionMethods & WsClientDomainMethods;
+export type WrongStackWebSocketClient = WrongStackWebSocketClientBase & WsClientActionMethods & WsClientDomainMethods & WsClientSessionMethods;
 interface WrongStackWebSocketClientConstructor {
     new (url?: string): WrongStackWebSocketClient;
     readonly prototype: WrongStackWebSocketClient;

package/dist/manifest.json

@@ -14,4 +14,4 @@
   "theme_color": "#090a0f",
   "display": "standalone",
   "orientation": "any"
-}
+}

package/dist/stores/context-editor-store.d.ts

@@ -75,6 +75,6 @@ interface ContextEditorActions {
     getProposedMessages: () => ContextEditorMessage[];
 }
 type ContextEditorStore = ContextEditorState & ContextEditorActions;
-export declare const useContextEditorStore: import("zustand").UseBoundStore<import("zustand").StoreApi<ContextEditorStore>>;
+export declare const useContextEditorStore: import("./session-scoped-store").SessionScopedStore<ContextEditorStore>;
 export {};
 //# sourceMappingURL=context-editor-store.d.ts.map

package/dist/stores/council-log-store.d.ts

@@ -17,6 +17,12 @@ export interface CouncilPanelEntry {
     /** Distinct provider/model targets that served the valid votes. */
     distinctTargetCount?: number | undefined;
     judgeUsed?: boolean | undefined;
+    judgeLabel?: string | undefined;
+    /** The tie-breaker had already cast one of the votes it is breaking. */
+    judgeIsVoter?: boolean | undefined;
+    /** Deliberation rounds run (1 = none) and seats that moved in the last one. */
+    rounds?: number | undefined;
+    deliberationChanges?: number | undefined;
     totalTokens?: number | undefined;
     durationMs?: number | undefined;
     /** Structural warnings — most importantly a CORRELATED (non-diverse) panel. */

package/dist/stores/index.d.ts

@@ -42,12 +42,12 @@ export { type SddWizardPhase, type SddWizardSnapshot, useSddWizardStore, } from
 /** The lane pointer — the single answer to "which tab is in front". */
 export { activeSessionLaneId, useActiveSessionId } from './session-lanes.js';
 export { memorySessionSnapshots, useSessionStore } from './session-store.js';
-export { isTabBusy, MAX_OPEN_TABS, slotOf, summarizeTab, type TabSummary, useSessionTabStore } from './session-tab-store.js';
+export { isTabBusy, MAX_OPEN_TABS, slotOf, summarizeTab, type TabSummary, useSessionTabStore, } from './session-tab-store.js';
 export { type SideEffectEntry, useSideEffectStore } from './side-effect-store.js';
 export { type BoardTaskItem, type BoardTaskStatus, type SpecColumn, type SpecDetail, type SpecListItem, useSpecsStore, } from './specs-store.js';
 export { type TechStackCoverage, type TechStackDependency, type TechStackEvidence, type TechStackFinding, type TechStackFindingAction, type TechStackFindingSeverity, type TechStackFindingType, type TechStackJobKind, type TechStackJobStatus, type TechStackJobView, type TechStackProgress, type TechStackSnapshot, type TechStackWorkspace, useTechStackStore, } from './techstack-store.js';
 export { bucketSuccessRatio, LEADER_AGENT_KEY, sessionInFlight, type ToolStatsBucket, type ToolStatsDelegation, type ToolStatsSession, useToolStatsStore, } from './tool-stats-store.js';
-export type { AgentTranscriptEntry, AgentTranscriptKind, BrainDecisionData, ChatMessage, ChatMessageAttachment, CouncilDecisionData, CouncilSeatVote, FleetTimelineEvent, SessionHistoryEntry, SessionInfo, SubagentEvent, SubagentView, ToolExecution } from './types.js';
+export type { AgentTranscriptEntry, AgentTranscriptKind, BrainDecisionData, ChatMessage, ChatMessageAttachment, CouncilDecisionData, CouncilSeatVote, FleetTimelineEvent, SessionHistoryEntry, SessionInfo, SubagentEvent, SubagentView, ToolExecution, } from './types.js';
 export type { Activity, DockSection, InspectorTab, WorkDashboardTab } from './ui-store.js';
 export { coerceActivity, resetUiNavigationToHome, SIDEBAR_DEFAULT_WIDTH, SIDEBAR_MAX_WIDTH, SIDEBAR_MIN_WIDTH, useUIStore, } from './ui-store.js';
 export type { VizEdge, VizEvent, VizNode } from './viz-store.js';

package/dist/stores/session-tab-store.d.ts

@@ -67,6 +67,14 @@ interface SessionTabState {
      * drops to zero.
      */
     closeTabsForSessions: (sessionIds: string[]) => string[];
+    /**
+     * Retire `retiredId` and hand its slot to `nextId` IN PLACE — the tab does
+     * not close and no second tab opens for the newcomer. This is the client
+     * half of `session.new { replaceSessionId }`: the server closes the retired
+     * session and answers with a reset `session.start` whose `clearedSessionId`
+     * names it, and the tab it lived in must become the new session's tab.
+     */
+    swapTabSession: (retiredId: string, nextId: string) => void;
     markSeen: (sessionId: string) => void;
     setAttention: (sessionId: string, needsAttention: boolean) => void;
 }

package/dist/stores/types.d.ts

@@ -17,6 +17,10 @@ export interface CouncilSeatVote {
     weight?: number | undefined;
     durationMs?: number | undefined;
     error?: string | undefined;
+    /** Deliberation round this ballot came from; 1 is the independent round. */
+    round?: number | undefined;
+    /** The seat changed its vote after seeing the other seats' ballots. */
+    changed?: boolean | undefined;
     at: number;
 }
 export interface ToolExecution {
@@ -46,7 +50,7 @@ export interface ChatMessage {
     content: string;
     /** Images the user attached to this message (user role only). */
     attachments?: ChatMessageAttachment[] | undefined;
-    /** A compact, presentation-only summary for a built-in Elite Bug Hunter
+    /** A compact, presentation-only summary for a built-in Proof-Driven Bug Hunter
      * request. The full instruction is still sent to the agent, but never
      * printed into the user's transcript. */
     bugHunt?: {
@@ -184,9 +188,14 @@ export interface CouncilDecisionData {
     distinctTargetCount?: number | undefined;
     judgeUsed?: boolean | undefined;
     judgeModel?: string | undefined;
+    /** The tie-breaker had already cast one of the votes it is breaking. */
+    judgeIsVoter?: boolean | undefined;
     judgeRationale?: string | undefined;
     totalTokens?: number | undefined;
     durationMs?: number | undefined;
+    /** Deliberation rounds run (1 = none) and seats that moved in the last one. */
+    rounds?: number | undefined;
+    deliberationChanges?: number | undefined;
     warnings?: string[] | undefined;
     seats: CouncilSeatVote[];
 }

package/dist/stores/ui-store-chrome.d.ts

@@ -0,0 +1,12 @@
+import type { UIState, SessionChromeState } from "./ui-store-types.js";
+export declare function isDesktopShellStorageContext(): boolean;
+export declare function homeNavigationStatePatch(options?: {
+    sidebarOpen?: boolean | undefined;
+}): Partial<UIState>;
+export declare function defaultSkillsState(): UIState['skillsState'];
+export declare function defaultSessionChrome(): SessionChromeState;
+export declare function readSessionChrome(state: UIState): SessionChromeState;
+export declare function parkChrome(state: UIState, patch: Partial<SessionChromeState>): {
+    chromeBySession?: UIState['chromeBySession'];
+};
+//# sourceMappingURL=ui-store-chrome.d.ts.map

package/dist/stores/ui-store-persist.d.ts

@@ -0,0 +1,4 @@
+import type { PersistOptions } from "zustand/middleware";
+import type { UIState } from "./ui-store-types.js";
+export declare const uiPersistOptions: PersistOptions<UIState, Partial<UIState>>;
+//# sourceMappingURL=ui-store-persist.d.ts.map