@wrongstack/webui 0.313.0 → 0.316.1

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

@@ -1,7 +1,7 @@
 import type { WSClientMessage, WSModelSwitchResult, WSServerMessage, WSUserMessageImage } from '../types';
 import { type WsClientActionMethods } from './ws-client-actions';
-import { type WsClientDomainMethods } from './ws-client-domain-methods';
 import type { WSSendOptions } from './ws-client-contracts';
+import { type WsClientDomainMethods } from './ws-client-domain-methods';
 import { type EventHandler, type WsStatus } from './ws-client-utils';
 export type { WSSendOptions } from './ws-client-contracts';
 export type { WsStatus };
@@ -51,7 +51,55 @@ declare class WrongStackWebSocketClientBase {
      */
     private static readonly PENDING_CONFIRM_TTL_MS;
     private sessionId;
-    private sessionSwapPending;
+    /**
+     * The session this client is currently waiting to be switched to, or
+     * `NEW_SESSION_SWAP_TARGET` when it asked the server to CREATE one and does
+     * not know the id yet. `null` means no swap is outstanding.
+     *
+     * This used to be a bare boolean (`sessionSwapPending`), and that is what
+     * made four tabs fight each other: `session.start` arrives for background
+     * sessions too (another tab's resume answer landing late, a server-side
+     * re-announce, a broadcast), and an unkeyed flag was consumed by whichever
+     * announcement happened to arrive first. The grant meant for the tab the
+     * user clicked was then spent on a DIFFERENT session — which took the
+     * foreground — and the click's own answer, arriving with the flag already
+     * cleared, was treated as an unrequested re-announce and ignored. That is
+     * exactly "I click tab 2 and get tab 1's transcript".
+     */
+    private pendingSwapTarget;
+    /**
+     * The session id of the `session.start` currently being dispatched, when it
+     * is the answer to THIS client's swap request. Set in `handleMessage`
+     * immediately before `emit`, read (and cleared) by `handleSessionStart` via
+     * `consumeRequestedSwitch`. Keyed by session id so a grant can never be
+     * spent on a different session than the one it was issued for.
+     */
+    private requestedSwitchSessionId;
+    /**
+     * Session ids this client has already seen a `session.start` for. Used to
+     * recognise the answer to a `session.new`, whose id the client cannot know
+     * in advance: the answer is the first RESET announcement naming a session
+     * this client has never seen.
+     */
+    private readonly seenSessionIds;
+    /**
+     * Should the next `session.subscribe` ask the server for each tab's
+     * transcript? True for a page's first declaration and after every
+     * reconnect; cleared as soon as one goes out. See `subscribeSessions`.
+     */
+    private replayOnNextSubscribe;
+    /** 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;
+    /**
+     * 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;
     /** Stored last close reason / error message so the UI can show "what
      *  went wrong" while reconnecting instead of a generic spinner. */
     private lastErrorText;
@@ -67,7 +115,30 @@ declare class WrongStackWebSocketClientBase {
     get status(): WsStatus;
     private setStatus;
     constructor(url?: string);
-    withSession<T extends Record<string, unknown>>(payload: T): T & {
+    /**
+     * Stamp the outgoing payload with the session it belongs to.
+     *
+     * `sessionId` is an explicit override for anything sent on behalf of a tab
+     * that is NOT in front — draining a background lane's queue, aborting a
+     * background run. Without it the payload inherits the foreground session and
+     * the background tab's message starts a run in the wrong session; that is
+     * the send-side twin of the cross-tab transcript bleed.
+     *
+     * "The foreground" is the LANE POINTER — the same value the chat surface
+     * renders from — and nothing else. Two weaker sources used to stand in for
+     * it and both mis-addressed runs:
+     *
+     *  - `useSessionStore().session?.id` is the lane's SessionInfo, which is
+     *    null between opening a tab and its `session.start` landing. A message
+     *    typed in that window fell through to the next fallback.
+     *  - `this.sessionId` is whatever session announced LAST on this socket,
+     *    background tabs included. Stamping it sent the foreground tab's message
+     *    into another tab's session: its transcript grew there, its `isLoading`
+     *    never cleared here (no `run.result` for a session this tab never ran),
+     *    and when that other session was mid-run the server answered with
+     *    "Agent.run() is already in progress on this instance".
+     */
+    withSession<T extends Record<string, unknown>>(payload: T, sessionId?: string | undefined): T & {
         sessionId?: string;
     };
     /**
@@ -107,6 +178,49 @@ declare class WrongStackWebSocketClientBase {
      */
     private flushMessageQueue;
     private handleMessage;
+    /**
+     * 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.
+     */
+    private matchesPendingSwap;
+    private rememberSeenSession;
+    /**
+     * Claim the "this client asked to switch here" grant for ONE session.
+     *
+     * Read by `handleSessionStart` to decide whether the announced session takes
+     * the foreground or merely updates its own lane. Keyed by session id and
+     * one-shot: a later re-announce of the same session does not inherit the
+     * grant, and an announce for a DIFFERENT session cannot spend it.
+     */
+    consumeRequestedSwitch(sessionId: string): boolean;
+    /**
+     * Park ONE automatic retry for a `session_not_ready` refusal.
+     *
+     * The refusal means the session is not open in the runtime yet (placeholder
+     * writer — the F5-restored-tab case): resuming it and resending exactly what
+     * was refused is safe and expected. The cooldown makes the retry one-shot
+     * per window, so a resume→announce→resend→refuse race degrades to the
+     * ordinary error bubble on the second refusal instead of ping-ponging
+     * forever. Returns false while on cooldown — the caller then renders the
+     * refusal as a normal error (manual recovery).
+     */
+    armNotReadyResend(sessionId: string, message: {
+        content: string;
+        freshContext?: boolean | undefined;
+        images?: WSUserMessageImage[] | undefined;
+    }): boolean;
+    /**
+     * Fire the armed retry once the refused session announces itself live.
+     *
+     * Guarded on the lane still existing: a tab closed while the retry was
+     * parked must not start a server-side run nobody is watching.
+     */
+    private consumeArmedResend;
     /**
      * Drop `pendingConfirms` entries whose TTL has passed. Entries are
      * created when a `tool.confirm_needed` message arrives and only
@@ -151,14 +265,29 @@ declare class WrongStackWebSocketClientBase {
         type: K;
     }>) => void): void;
     off(eventType: string, handler: EventHandler): void;
-    sendMessage(content: string, images?: WSUserMessageImage[], freshContext?: boolean): string;
+    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): string;
-    sendAbort(): void;
+    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, {

package/dist/manifest.json

@@ -0,0 +1,17 @@
+{
+  "short_name": "WrongStack",
+  "name": "WrongStack Operator Workbench",
+  "description": "WrongStack WebUI Operator Workbench",
+  "icons": [
+    {
+      "src": "/wrongstack.svg",
+      "type": "image/svg+xml",
+      "sizes": "192x192 512x512 any"
+    }
+  ],
+  "start_url": "/",
+  "background_color": "#090a0f",
+  "theme_color": "#090a0f",
+  "display": "standalone",
+  "orientation": "any"
+}

package/dist/protocol-compatibility.d.ts

@@ -1,12 +1,2 @@
-import type { CanonicalClientMessageType, CanonicalServerMessageType } from '@wrongstack/webui-protocol';
-import type { WSClientMessageCore, WSServerMessage } from './types.js';
-type AssertNever<T extends never> = T;
-/**
- * Compile-time bridge while payload-rich surface types remain in this package.
- * A newly added detailed message cannot compile until the canonical runtime
- * registry represents its wire name in the matching direction.
- */
-export type UnregisteredClientSurfaceMessage = AssertNever<Exclude<WSClientMessageCore['type'], CanonicalClientMessageType>>;
-export type UnregisteredServerSurfaceMessage = AssertNever<Exclude<WSServerMessage['type'], CanonicalServerMessageType>>;
 export {};
 //# sourceMappingURL=protocol-compatibility.d.ts.map

package/dist/stores/auto-submit-streak.d.ts

@@ -53,7 +53,9 @@ interface UseAutoSubmitStreak {
     /** Reset the cap-warning flag — call when autonomy mode changes */
     resetCapWarned: () => void;
 }
-/** Module-level streak — reset when the page hard-reloads (acceptable tradeoff) */
+/** Drop a closed tab's bookkeeping. */
+export declare function disposeStreakState(sessionId: string): void;
+/** Per-session streak — reset when the page hard-reloads (acceptable tradeoff) */
 export declare function useAutoSubmitStreak(): UseAutoSubmitStreak;
 export {};
 //# sourceMappingURL=auto-submit-streak.d.ts.map

package/dist/stores/chat-lanes.d.ts

@@ -0,0 +1,279 @@
+/**
+ * chat-lanes.ts — The chat surface's per-session source of truth.
+ *
+ * ONE LANE PER TAB. Four tabs, four lanes, no shared mutable chat state
+ * between them. Think of them as four side-by-side layouts that happen to be
+ * stacked: nothing in lane 2 can be observed or written by lane 1, background
+ * included.
+ *
+ * Why this exists (the bug it replaces): the chat surface used to be a single
+ * live store plus a `memorySessionCaches` map of parked snapshots. Every WS
+ * writer therefore had to ask "is this event for the tab in front?" and drop it
+ * otherwise. That is a NEGATIVE routing rule, and it fails two ways:
+ *
+ *   1. One writer that forgets the guard appends another session's tokens to
+ *      whatever transcript happens to be in front. That is the bleed.
+ *   2. Even when every guard is right, a background tab's own output is
+ *      DROPPED — it was never written anywhere — so switching back showed a
+ *      transcript frozen at the moment you left.
+ *
+ * Lanes make routing POSITIVE: an event names its session, the router hands
+ * back that session's lane, and the write lands there. A message that names no
+ * session, or names a session with no lane, is dropped by the router — never
+ * mis-delivered. There is no "current lane" a writer can accidentally reach.
+ *
+ * `chat-store.ts` is a thin read/write facade over `lanes[activeSessionId]` so
+ * the foreground components keep their existing API.
+ */
+import type { QueuedItem, ToolExecution } from './chat-store-types';
+import type { ChatMessage } from './types.js';
+/**
+ * Hard ceiling on concurrent lanes. Four tabs, four lanes, no exceptions —
+ * and the server accepts exactly this many declared sessions per connection,
+ * hence the shared constant rather than a second 4 that could drift from it.
+ */
+export declare const MAX_LANES = 4;
+/**
+ * Lane used before any session exists (boot, setup screen, tests that never
+ * start a session). `adoptDefaultLane` hands its contents to the first real
+ * session so a message typed before `session.start` lands is not lost.
+ */
+export declare const DEFAULT_LANE_ID = "__unbound__";
+/** Everything the chat surface owns for ONE session. Plain data only. */
+export interface ChatLaneData {
+    messages: ChatMessage[];
+    currentAssistantMessageId: string | null;
+    currentToolId: string | null;
+    isLoading: boolean;
+    abortController: AbortController | null;
+    executions: Map<string, ToolExecution>;
+    toolMessageIdsByUseId: Map<string, string>;
+    queue: QueuedItem[];
+    runStart: {
+        at: number;
+        cost: number;
+    } | null;
+    refining: boolean;
+    pendingRefinement: {
+        text: string;
+        images: Array<{
+            data: string;
+            mime: string;
+        }>;
+        mode: QueuedItem['mode'];
+    } | null;
+    thinkingBuffer: string;
+    thinkingStartedAt: number | null;
+    thinkingLogBuffer: string;
+    thinkingLogStartedAt: number | null;
+    /**
+     * An approval prompt raised while this tab was in the BACKGROUND.
+     *
+     * A modal is the loudest possible cross-tab bleed, so a background tab's
+     * prompt is never opened over the tab in front. It is parked here instead
+     * and opened when the user switches to the tab that raised it — without
+     * this the prompt was simply discarded and the run sat blocked behind an
+     * attention dot with no way to answer it.
+     */
+    pendingConfirm: PendingConfirm | null;
+    /**
+     * A provider-fallback prompt raised while this tab was in the BACKGROUND.
+     *
+     * Same reasoning as `pendingConfirm`: the fallback dialog is one global
+     * surface, so a background tab's prompt must not open over the tab in front.
+     * It used to be DROPPED instead — the run then sat behind a question nobody
+     * could answer until the server's countdown auto-switched the model on its
+     * own, which is a route change the user never chose.
+     */
+    pendingFallback: LaneFallbackPrompt | null;
+}
+/** The provider-fallback prompt payload, as the dialog needs it. */
+interface LaneFallbackPrompt {
+    requestId: string;
+    from: {
+        providerId: string;
+        model: string;
+    };
+    status: number;
+    candidates: Array<{
+        providerId: string;
+        model: string;
+    }>;
+    autoSwitchSeconds: number;
+    timestamp: number;
+}
+/** The tool-approval prompt payload, as the dialog needs it. */
+export interface PendingConfirm {
+    id: string;
+    toolName: string;
+    input: unknown;
+    suggestedPattern: string;
+    decisionSource?: string | undefined;
+    riskTier?: 'safe' | 'standard' | 'destructive' | undefined;
+    boundaryReason?: string | undefined;
+}
+/**
+ * Stable empty lane handed to selectors that ask for a lane which does not
+ * exist. Must be a singleton: returning a fresh object would make every
+ * `useChatStore((s) => s.messages)` re-render on every store touch.
+ */
+export declare const EMPTY_LANE: ChatLaneData;
+interface ChatLanesState {
+    lanes: Record<string, ChatLaneData>;
+    /** Which lane the chat surface renders. Owned by the tab registry. */
+    activeSessionId: string;
+}
+export declare const useChatLanes: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<ChatLanesState>, "persist" | "setState"> & {
+    setState(partial: ChatLanesState | Partial<ChatLanesState> | ((state: ChatLanesState) => ChatLanesState | Partial<ChatLanesState>), replace?: false | undefined): unknown;
+    setState(state: ChatLanesState | ((state: ChatLanesState) => ChatLanesState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<ChatLanesState, {
+            lanes: {
+                [k: string]: {
+                    messages: ChatMessage[];
+                    queue: QueuedItem[];
+                    thinkingLogBuffer: string;
+                };
+            };
+        }, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: ChatLanesState) => void) => () => void;
+        onFinishHydration: (fn: (state: ChatLanesState) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<ChatLanesState, {
+            lanes: {
+                [k: string]: {
+                    messages: ChatMessage[];
+                    queue: QueuedItem[];
+                    thinkingLogBuffer: string;
+                };
+            };
+        }, unknown>>;
+    };
+}>;
+/** Read a lane's data, or the shared empty lane when it does not exist. */
+export declare function readLane(sessionId: string | null | undefined): ChatLaneData;
+export declare function hasLane(sessionId: string | null | undefined): boolean;
+export declare function laneIds(): string[];
+/** Create the lane if missing. Returns the sessionId for chaining. */
+export declare function ensureLane(sessionId: string): string;
+/** Subscribe to lane disposal. Returns an unsubscribe. */
+export declare function onLaneDisposed(fn: (sessionId: string) => void): () => void;
+export declare function disposeLane(sessionId: string): void;
+/**
+ * Hand the pre-session (`__unbound__`) lane's contents to a real session.
+ * Only ever moves the default lane, and only into an empty target — a real
+ * lane's transcript is never overwritten by this.
+ */
+export declare function adoptDefaultLane(sessionId: string): void;
+/** Point the foreground at a lane, creating it if needed. */
+export declare function setActiveLane(sessionId: string | null): void;
+export declare function activeLaneId(): string;
+export interface ChatLaneActions {
+    readonly sessionId: string;
+    readonly messages: ChatMessage[];
+    readonly currentAssistantMessageId: string | null;
+    readonly currentToolId: string | null;
+    readonly isLoading: boolean;
+    readonly abortController: AbortController | null;
+    readonly executions: Map<string, ToolExecution>;
+    readonly toolMessageIdsByUseId: Map<string, string>;
+    readonly queue: QueuedItem[];
+    readonly runStart: {
+        at: number;
+        cost: number;
+    } | null;
+    readonly refining: boolean;
+    readonly pendingRefinement: ChatLaneData['pendingRefinement'];
+    readonly thinkingBuffer: string;
+    readonly thinkingStartedAt: number | null;
+    readonly thinkingLogBuffer: string;
+    readonly thinkingLogStartedAt: number | null;
+    readonly pendingConfirm: PendingConfirm | null;
+    addMessage: (msg: Omit<ChatMessage, 'id' | 'timestamp'> & {
+        id?: string;
+        timestamp?: number;
+    }) => string;
+    setMessages: (messages: ChatMessage[]) => void;
+    updateMessage: (id: string, updates: Partial<ChatMessage>) => void;
+    appendToMessage: (id: string, text: string) => void;
+    finalizeMessage: (id: string, opts?: {
+        final?: boolean;
+    }) => void;
+    setToolResult: (id: string, result: string, ok: boolean) => void;
+    appendToolProgress: (id: string, line: string) => void;
+    appendToolProgressLines: (id: string, lines: string[]) => void;
+    getToolMessageId: (toolUseId: string) => string | undefined;
+    setToolResultByUseId: (toolUseId: string, result: string, ok: boolean) => void;
+    appendToolProgressLinesByUseId: (toolUseId: string, lines: string[]) => void;
+    setLoading: (loading: boolean) => void;
+    setAbortController: (ctrl: AbortController | null) => void;
+    clearMessages: () => void;
+    setCurrentAssistantMessage: (id: string | null) => void;
+    setCurrentToolId: (id: string | null) => void;
+    truncateAfter: (id: string) => void;
+    addExecution: (exec: ToolExecution) => void;
+    updateExecution: (id: string, updates: Partial<ToolExecution>) => void;
+    enqueue: (text: string, mode?: QueuedItem['mode'], images?: QueuedItem['images'], alreadyDispatched?: boolean) => void;
+    dequeue: () => QueuedItem | null;
+    dequeueDrainable: () => QueuedItem | null;
+    removeQueued: (idx: number) => void;
+    clearQueue: () => void;
+    setRefining: (v: boolean) => void;
+    /** Park (or clear) this tab's unanswered approval prompt. */
+    setPendingConfirm: (confirm: PendingConfirm | null) => void;
+    setPendingFallback: (prompt: LaneFallbackPrompt | null) => void;
+    setPendingRefinement: (text: string | null, images?: Array<{
+        data: string;
+        mime: string;
+    }>, mode?: QueuedItem['mode']) => void;
+    removeMessage: (id: string) => void;
+    updateLastUserMessage: (text: string) => void;
+    setRunStart: (s: {
+        at: number;
+        cost: number;
+    } | null) => void;
+    appendThinking: (text: string) => void;
+    clearThinking: () => void;
+    flushThinkingLog: (iteration: number) => void;
+    clearThinkingLog: () => void;
+    /** Bulk patch — used by the facade's `setState` and by replay hydration. */
+    patch: (updates: Partial<ChatLaneData>) => void;
+}
+/**
+ * The one way to write chat state. `sessionId` is mandatory: there is no
+ * "current" lane an action can fall back to, which is what makes cross-tab
+ * bleed unrepresentable rather than merely guarded against.
+ */
+/**
+ * Retire an approval prompt once it has been answered, wherever it is parked.
+ *
+ * Keyed on the prompt id rather than the tab, because a prompt can be resolved
+ * from outside the tab that raised it — turning YOLO on makes the server
+ * auto-approve everything pending. A stale parked prompt would then re-open a
+ * dead dialog the next time the user switched to that tab.
+ */
+export declare function resolvePendingConfirm(confirmId: string): void;
+/**
+ * Retire a parked fallback prompt by request id, wherever it is parked.
+ *
+ * The answer (or the server's own countdown) settles the request for good, so
+ * the copy must not survive to open a dead dialog on the next tab switch —
+ * the same retirement `resolvePendingConfirm` performs for approvals.
+ */
+export declare function resolvePendingFallback(requestId: string): void;
+export declare function chatLane(sessionId: string): ChatLaneActions;
+/**
+ * Replace one or more of a lane's actions in place.
+ *
+ * The action object is a per-session singleton, so this is how a caller
+ * substitutes behaviour for a specific tab — and how tests keep the
+ * `useChatStore.setState({ clearMessages: fn })` idiom the single store
+ * supported. Overrides live until the lane is disposed.
+ */
+export declare function overrideLaneActions(sessionId: string, patch: Partial<Record<keyof ChatLaneActions, unknown>>): void;
+/** Actions bound to the lane currently in front. Foreground UI only. */
+export declare function activeChatLane(): ChatLaneActions;
+export {};
+//# sourceMappingURL=chat-lanes.d.ts.map

package/dist/stores/chat-retention.d.ts

@@ -1,4 +1,4 @@
-import type { ChatRetentionBudget } from './chat-store-types';
+import type { ChatRetentionBudget, ToolExecution } from './chat-store-types';
 import type { ChatMessage } from './types.js';
 export declare function dedupeRepeatedBlocks(text: string): string;
 export declare const MAX_CHAT_MESSAGES = 1000;
@@ -6,9 +6,7 @@ export declare const MAX_PERSISTED_MESSAGES = 200;
 export declare const MAX_CHAT_RETAINED_BYTES: number;
 export declare const MAX_CHAT_FIELD_CHARS: number;
 export declare function boundChatField(text: string, maxChars?: number): string;
-export declare function estimateUnknownBytes(value: unknown): number;
-export declare function normalizeRetainedMessage(message: ChatMessage, maxFieldChars: number): ChatMessage;
-export declare function retainedChatMessageBytes(message: ChatMessage): number;
 export declare function retainWebChatMessages(messages: readonly ChatMessage[], budget?: ChatRetentionBudget): ChatMessage[];
 export declare function indexToolMessages(messages: readonly ChatMessage[]): Map<string, string>;
+export declare function indexToolExecutions(messages: readonly ChatMessage[]): Map<string, ToolExecution>;
 //# sourceMappingURL=chat-retention.d.ts.map

package/dist/stores/chat-store-types.d.ts

@@ -102,5 +102,6 @@ export interface ChatState {
     clearThinking: () => void;
     flushThinkingLog: (iteration: number) => void;
     clearThinkingLog: () => void;
+    switchSession: (newSessionId: string) => void;
 }
 //# sourceMappingURL=chat-store-types.d.ts.map

package/dist/stores/chat-store.d.ts

@@ -1,30 +1,51 @@
+/**
+ * chat-store.ts — Foreground view over the lane registry.
+ *
+ * The chat surface's real state lives in `chat-lanes.ts`, one lane per session
+ * tab. This module is the read/write facade the FOREGROUND components use: it
+ * projects `lanes[activeSessionId]` behind the historical `useChatStore` API so
+ * a component that renders the tab in front keeps working unchanged.
+ *
+ * Rules that keep the four tabs from bleeding into each other:
+ *
+ *  - WS handlers MUST NOT use this facade. They route by `payload.sessionId`
+ *    through `chatFor(msg)` / `chatLane(sessionId)`. Writing through the facade
+ *    from a handler is exactly the "wrote to whichever tab happened to be in
+ *    front" bug; `tests/hooks/ws-handlers-lane-routing.test.ts` fails the build
+ *    if a handler reaches for it.
+ *  - The facade has no cross-lane reach. `useChatStore.getState()` can only see
+ *    and touch the active lane; there is no path from here to lane 2.
+ */
+import { useChatLanes } from './chat-lanes';
 import type { ChatState } from './chat-store-types';
 export declare const MAX_CHAT_MESSAGES = 1000;
 export declare const MAX_PERSISTED_MESSAGES = 200;
-export * from './chat-store-types';
-export { boundChatField, dedupeRepeatedBlocks, indexToolMessages, MAX_CHAT_FIELD_CHARS, MAX_CHAT_RETAINED_BYTES, retainWebChatMessages, } from './chat-retention';
+export { activeChatLane, activeLaneId, adoptDefaultLane, type ChatLaneActions, type ChatLaneData, chatLane, DEFAULT_LANE_ID, disposeLane, ensureLane, hasLane, laneIds, MAX_LANES, readLane, setActiveLane, useChatLanes, } from './chat-lanes';
 export { BTW_DISPATCH_GRACE_MS } from './chat-queue-helpers';
-export declare const useChatStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<ChatState>, "persist" | "setState"> & {
-    setState(partial: ChatState | Partial<ChatState> | ((state: ChatState) => ChatState | Partial<ChatState>), replace?: false | undefined): unknown;
-    setState(state: ChatState | ((state: ChatState) => ChatState), replace: true): unknown;
-    persist: {
-        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<ChatState, {
-            messages: ChatState['messages'];
-            queue: ChatState['queue'];
-            boundSessionId: string | null;
-            thinkingLogBuffer: string;
-        }, unknown>>) => void;
-        clearStorage: () => void;
-        rehydrate: () => Promise<void> | void;
-        hasHydrated: () => boolean;
-        onHydrate: (fn: (state: ChatState) => void) => () => void;
-        onFinishHydration: (fn: (state: ChatState) => void) => () => void;
-        getOptions: () => Partial<import("zustand/middleware").PersistOptions<ChatState, {
-            messages: ChatState['messages'];
-            queue: ChatState['queue'];
-            boundSessionId: string | null;
-            thinkingLogBuffer: string;
-        }, unknown>>;
-    };
-}>;
+export { boundChatField, dedupeRepeatedBlocks, indexToolExecutions, indexToolMessages, MAX_CHAT_FIELD_CHARS, MAX_CHAT_RETAINED_BYTES, retainWebChatMessages, } from './chat-retention';
+export * from './chat-store-types';
+declare function getState(): ChatState;
+/**
+ * Merge a patch into the ACTIVE lane. Kept for components and tests that drive
+ * the store directly; `boundSessionId` is honoured as a lane switch.
+ */
+declare function setState(partial: Partial<ChatState> | ((state: ChatState) => Partial<ChatState>)): void;
+declare function subscribe(listener: (state: ChatState, prev: ChatState) => void): () => void;
+interface ChatStoreFacade {
+    <T>(selector: (state: ChatState) => T): T;
+    getState: typeof getState;
+    getInitialState: typeof getState;
+    setState: typeof setState;
+    subscribe: typeof subscribe;
+    /** The lane registry's own persist API (rehydrate/flush/clearStorage). */
+    persist: (typeof useChatLanes)['persist'];
+}
+/**
+ * Foreground chat state. Reads and writes the ACTIVE lane only.
+ *
+ * Not a real Zustand store — a projection over `useChatLanes`. Everything a
+ * component needs (selector subscription, `getState`, `setState`, `subscribe`)
+ * is here; what is deliberately absent is any way to name another session.
+ */
+export declare const useChatStore: ChatStoreFacade;
 //# sourceMappingURL=chat-store.d.ts.map