@wrongstack/webui 0.313.0 → 0.316.1

package/dist/components/ui/event-timeline.d.ts

@@ -5,11 +5,12 @@
  * fleet event timeline for the Fleet Monitor overlay.
  */
 import type { FleetTimelineEvent } from '@/stores';
-export interface EventTimelineProps {
+interface EventTimelineProps {
     events: FleetTimelineEvent[];
     /** Max events to render (default 20). */
     max?: number;
     className?: string;
 }
 export declare function EventTimeline({ events, max, className }: EventTimelineProps): import("react").JSX.Element;
+export {};
 //# sourceMappingURL=event-timeline.d.ts.map

package/dist/components/ui/fleet-agent-row.d.ts

@@ -8,17 +8,12 @@
  * original FleetMonitor implementation.
  */
 import type { SubagentView } from '@/stores';
-export declare const FLEET_ROW_STATUS_META: Record<SubagentView['status'], {
-    led: string;
-    labelKey: string;
-    pulse: boolean;
-    color: string;
-}>;
-export interface FleetAgentRowProps {
+interface FleetAgentRowProps {
     agent: SubagentView;
     isSelected: boolean;
     isLeader: boolean;
     onClick: () => void;
 }
 export declare function FleetAgentRow({ agent, isSelected, isLeader, onClick }: FleetAgentRowProps): import("react").JSX.Element;
+export {};
 //# sourceMappingURL=fleet-agent-row.d.ts.map

package/dist/components/ui/scroll-area.d.ts

@@ -1,6 +1,6 @@
 import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
 import * as React from 'react';
 declare const ScrollArea: React.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const ScrollBar: React.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-export { ScrollArea, ScrollBar };
+export declare const ScrollBar: React.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { ScrollArea };
 //# sourceMappingURL=scroll-area.d.ts.map

package/dist/components/ui/sheet.d.ts

@@ -14,7 +14,7 @@ import * as React from 'react';
  * is full-height, matching the existing FleetMonitor / AgentsMonitor UX.
  */
 declare const Sheet: React.FC<DialogPrimitive.DialogProps>;
-declare const SheetTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+export declare const SheetTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
 declare const SheetClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
 declare const sheetVariants: (props?: ({
     side?: "bottom" | "left" | "right" | "top" | null | undefined;
@@ -34,5 +34,5 @@ declare namespace SheetHeader {
 }
 declare const SheetTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
 declare const SheetDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
-export { Sheet, SheetClose, SheetContent, SheetDescription, SheetHeader, SheetTitle, SheetTrigger };
+export { Sheet, SheetClose, SheetContent, SheetDescription, SheetHeader, SheetTitle };
 //# sourceMappingURL=sheet.d.ts.map

package/dist/components/ui/sparkline.d.ts

@@ -4,7 +4,7 @@
  * Renders a Unicode sparkline: ▁▃▅▇▆▄▂▁▃▅
  * Each bin represents a time bucket; height is normalized to 0-8 display chars.
  */
-export interface SparklineChartProps {
+interface SparklineChartProps {
     /** 12-element array of event counts per bucket. Index 0 = most recent. */
     bins: number[];
     /** Optional CSS class for the wrapper. */
@@ -13,4 +13,5 @@ export interface SparklineChartProps {
     width?: number;
 }
 export declare function SparklineChart({ bins, className }: SparklineChartProps): import("react").JSX.Element;
+export {};
 //# sourceMappingURL=sparkline.d.ts.map

package/dist/components/vector-memory-panel/model.d.ts

@@ -1,4 +1,4 @@
-export interface VectorMemoryCacheStats {
+interface VectorMemoryCacheStats {
     entries: number;
     providers: number;
     totalUseCount: number;
@@ -55,10 +55,5 @@ export declare function forgetVectorMemory(id: string, opts?: {
 }): Promise<{
     removed: boolean;
 }>;
-/** Hook: track the live status, re-fetching on focus. */
-export declare function useVectorMemoryStatus(baseUrl?: string): {
-    status: VectorMemoryStatus | undefined;
-    error: string | undefined;
-    reload: () => void;
-};
+export {};
 //# sourceMappingURL=model.d.ts.map

package/dist/hooks/index.d.ts

@@ -1,3 +1,4 @@
 export { useWebSocket } from './useWebSocket';
 export { useMemoryForFile } from './useMemoryForFile';
+export { useWrongProxyStatus, useHqStatus } from './useIntegrationStatus';
 //# sourceMappingURL=index.d.ts.map

package/dist/hooks/useDesktopBridge.d.ts

@@ -1,4 +1,4 @@
-export interface UseDesktopBridgeOptions {
+interface UseDesktopBridgeOptions {
     setPaletteOpen: (open: boolean) => void;
     setSearchOpen: (open: boolean) => void;
     setShortcutsOpen: (open: boolean) => void;
@@ -26,4 +26,5 @@ export interface UseDesktopBridgeOptions {
  *    view/nav/overlay/tool actions the native sidebar sends.
  */
 export declare function useDesktopBridge(options: UseDesktopBridgeOptions): void;
+export {};
 //# sourceMappingURL=useDesktopBridge.d.ts.map

package/dist/hooks/useF5Resilience.d.ts

@@ -1,16 +1,2 @@
-/**
- * F5 / tab-close resilience.
- *
- * Two concerns, both mounted once on app boot:
- *
- * 1. **Persist flush** — zustand's `persist` middleware writes asynchronously,
- *    so in-flight mutations can be lost on page teardown (F5, tab close,
- *    navigation). This effect hooks `pagehide` and `beforeunload` to force a
- *    synchronous flush of every persisted store before the page disappears.
- *
- * 2. **View fallback** — if the persisted `currentView` was an exotic overlay
- *    (debug, analytics, design-gallery, setup), auto-navigate to `chat` so
- *    the user lands on a usable surface instead of a stale debug screen.
- */
 export declare function useF5Resilience(): void;
 //# sourceMappingURL=useF5Resilience.d.ts.map

package/dist/hooks/useFleetPolling.d.ts

@@ -11,7 +11,7 @@
  * mounting its own setInterval.
  */
 import type { SubagentView, FleetSummary } from '@/stores';
-export interface FleetPollingResult {
+interface FleetPollingResult {
     /** Derived fleet-wide summary (running/completed/failed/total/cost/tokens). */
     summary: FleetSummary;
     /** Agent list sorted leader-first, running-first, then by startedAt. */
@@ -32,4 +32,5 @@ export interface FleetPollingResult {
  *                 only when visible.
  */
 export declare function useFleetPolling(enabled?: boolean): FleetPollingResult;
+export {};
 //# sourceMappingURL=useFleetPolling.d.ts.map

package/dist/hooks/useGlobalKeyboardShortcuts.d.ts

@@ -1,4 +1,4 @@
-export interface UseGlobalKeyboardShortcutsOptions {
+interface UseGlobalKeyboardShortcutsOptions {
     toggleSidebar: () => void;
     setSearchOpen: (open: boolean) => void;
     toggleInspector: () => void;
@@ -20,6 +20,9 @@ export interface UseGlobalKeyboardShortcutsOptions {
  * Bound in App.tsx's root so they fire anywhere, but skip while the user
  * is typing in a text input/textarea/content-editable (except Ctrl+F which
  * searches the chat and Ctrl+/ which focuses the textarea).
+ *
+ * Disabled when `useLocalPrefs.keyboardShortcuts` is false.
  */
 export declare function useGlobalKeyboardShortcuts(options: UseGlobalKeyboardShortcutsOptions): void;
+export {};
 //# sourceMappingURL=useGlobalKeyboardShortcuts.d.ts.map

package/dist/hooks/useIntegrationStatus.d.ts

@@ -0,0 +1,10 @@
+export type IntegrationHealthStatus = 'disabled' | 'checking' | 'connected' | 'error';
+export interface IntegrationProbeState {
+    status: IntegrationHealthStatus;
+    latencyMs: number | null;
+    url: string;
+    error?: string | undefined;
+}
+export declare function useWrongProxyStatus(): IntegrationProbeState;
+export declare function useHqStatus(): IntegrationProbeState;
+//# sourceMappingURL=useIntegrationStatus.d.ts.map

package/dist/hooks/useKanbanMeta.d.ts

@@ -1,13 +1,13 @@
-export interface KanbanToolOption {
+interface KanbanToolOption {
     name: string;
     description?: string | undefined;
 }
-export interface KanbanSkillOption {
+interface KanbanSkillOption {
     name: string;
     description?: string | undefined;
     source?: string | undefined;
 }
-export interface KanbanMeta {
+interface KanbanMeta {
     /** Real registered tools from the live agent runtime (not hardcoded). */
     tools: KanbanToolOption[];
     /** Installed skills available for explicit task-level force loading. */
@@ -29,4 +29,5 @@ export interface KanbanMeta {
  * does not answer `kanban.meta`.
  */
 export declare function useKanbanMeta(active: boolean): KanbanMeta;
+export {};
 //# sourceMappingURL=useKanbanMeta.d.ts.map

package/dist/hooks/useLiveContextDebug.d.ts

@@ -3,7 +3,7 @@
  * Kept loose (the modal re-types the fields it cares about) so a future
  * server-side addition does not break every consumer of the hook.
  */
-export interface LiveContextDebugPayload {
+interface LiveContextDebugPayload {
     total: number;
     mode?: string | undefined;
     policy?: unknown | undefined;
@@ -27,7 +27,7 @@ export interface LiveContextDebugPayload {
         }>;
     };
 }
-export interface UseLiveContextDebugOptions {
+interface UseLiveContextDebugOptions {
     /**
      * When `false`, the hook idles: no subscription, no polling, no
      * requests. Defaults to `true` so a typical modal consumer can call
@@ -47,7 +47,7 @@ export interface UseLiveContextDebugOptions {
      */
     pauseWhenHidden?: boolean | undefined;
 }
-export interface UseLiveContextDebugResult<T extends LiveContextDebugPayload> {
+interface UseLiveContextDebugResult<T extends LiveContextDebugPayload> {
     /**
      * Latest snapshot, or `null` until the first response arrives. Each
      * incoming payload overwrites the prior one — the most recent server
@@ -94,4 +94,5 @@ export interface UseLiveContextDebugResult<T extends LiveContextDebugPayload> {
  *   });
  */
 export declare function useLiveContextDebug<T extends LiveContextDebugPayload = LiveContextDebugPayload>(wsUrl: string, options?: UseLiveContextDebugOptions): UseLiveContextDebugResult<T>;
+export {};
 //# sourceMappingURL=useLiveContextDebug.d.ts.map

package/dist/hooks/useMemoryForFile.d.ts

@@ -1,6 +1,6 @@
 import { type WSSendOptions } from '@/lib/ws-client';
 import type { MemoryForFileResponse } from '@/types';
-export interface UseMemoryForFileOptions {
+interface UseMemoryForFileOptions {
     /** Project-relative file path. When null the hook stays idle. */
     filePath: string | null;
     /** Optional cursor range — symbol anchors overlapping get a boost. */
@@ -20,11 +20,12 @@ export interface UseMemoryForFileOptions {
     /** Optional WS send options (correlation id, abort, …). */
     sendOptions?: WSSendOptions;
 }
-export interface UseMemoryForFileResult {
+interface UseMemoryForFileResult {
     data: MemoryForFileResponse | null;
     loading: boolean;
     error: string | null;
     refetch: () => void;
 }
 export declare function useMemoryForFile(options: UseMemoryForFileOptions): UseMemoryForFileResult;
+export {};
 //# sourceMappingURL=useMemoryForFile.d.ts.map

package/dist/hooks/usePagination.d.ts

@@ -1,4 +1,4 @@
-export interface PaginationState<T> {
+interface PaginationState<T> {
     page: number;
     pageSize: number;
     totalItems: number;
@@ -7,4 +7,5 @@ export interface PaginationState<T> {
 }
 /** Shared client-side pagination for dynamic WebUI collections. */
 export declare function usePagination<T>(items: readonly T[], pageSize?: number, resetKey?: string | number | boolean | null): PaginationState<T>;
+export {};
 //# sourceMappingURL=usePagination.d.ts.map

package/dist/hooks/useProviderModels.d.ts

@@ -5,6 +5,7 @@ export interface ModelCandidate {
     description?: string | undefined;
     contextWindow?: number | undefined;
     outputModalities?: string[] | undefined;
+    isFavorite?: boolean | undefined;
 }
 /**
  * Load the flat list of {provider, model} the user can assign to an SDD worker.

package/dist/hooks/useSessionSubscription.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Tell the server which sessions this page is displaying.
+ *
+ * Four tabs share ONE WebSocket, so the server cannot infer the open set from
+ * the last message's `sessionId`. Without this declaration its broadcast
+ * filter delivers only the foreground tab's events and drops the other three
+ * at the wire — the client-side lane routing never even sees them, and a
+ * background tab looks like it stopped working.
+ *
+ * The set is re-sent in full on every change (it replaces, it does not merge,
+ * so a closed tab actually stops receiving) and re-declared on reconnect,
+ * because the server forgets it with the connection.
+ */
+export declare function useSessionSubscription(): void;
+//# sourceMappingURL=useSessionSubscription.d.ts.map

package/dist/hooks/useViewport.d.ts

@@ -10,7 +10,7 @@
  * - `tablet`: 641px–768px (between `sm` and `md`)
  * - `desktop`: > 768px (at or above `md`)
  */
-export interface ViewportState {
+interface ViewportState {
     /** True when viewport width ≤ 768px (Tailwind `md` breakpoint). */
     isMobile: boolean;
     /** True when viewport width ≤ 640px (Tailwind `sm` breakpoint). */
@@ -19,7 +19,6 @@ export interface ViewportState {
     width: number;
 }
 declare const MOBILE_BREAKPOINT = 768;
-declare const SMALL_BREAKPOINT = 640;
 /**
  * React hook that tracks the viewport breakpoint state.
  * Re-renders on viewport resize. SSR-safe (returns desktop defaults
@@ -34,5 +33,5 @@ declare const SMALL_BREAKPOINT = 640;
  */
 export declare function useViewport(): ViewportState;
 export declare function isMobileViewport(): boolean;
-export { MOBILE_BREAKPOINT, SMALL_BREAKPOINT };
+export { MOBILE_BREAKPOINT };
 //# sourceMappingURL=useViewport.d.ts.map

package/dist/hooks/useWebSocket.d.ts

@@ -30,7 +30,7 @@ export declare function useWebSocket(): {
         source: 'explicit' | 'model' | 'cache' | 'local';
     }>;
     sendAbort: () => void;
-    sendMailboxMessage: (opts: Parameters<(opts: import("@/lib/ws-client").WSMailboxSendOptions) => string>[0]) => string;
+    sendMailboxMessage: (opts: Parameters<(opts: import("@/lib/ws-client").WSMailboxSendOptions, sessionId?: string | undefined) => string>[0]) => string;
     sendConfirm: (id: string, decision: 'yes' | 'no' | 'always' | 'deny') => void;
     switchModel: (provider: string, model: string) => Promise<{
         requestId?: string | undefined;
@@ -55,6 +55,7 @@ export declare function useWebSocket(): {
     deleteSession: (id: string) => void;
     renameSession: (id: string, name: string) => void;
     resumeSession: (id: string) => void;
+    newSession: () => void;
     inspectSession: (id: string) => void;
     saveSession: () => void;
     listTools: (options?: WSSendOptions) => void;
@@ -143,5 +144,9 @@ export declare function useWebSocket(): {
         provider?: string | undefined;
         model?: string | undefined;
     }) => void;
+    stageGit: (paths: string | string[]) => void;
+    unstageGit: (paths: string | string[]) => void;
+    discardGit: (paths: string | string[]) => void;
+    commitGit: (message: string) => void;
 };
 //# sourceMappingURL=useWebSocket.d.ts.map

package/dist/hooks/ws-handlers/chat-handlers.d.ts

@@ -1,15 +1,7 @@
 import type { WSServerMessage } from '@/types';
-export declare const chatHandlers: {
-    handleIterationStarted: typeof handleIterationStarted;
-    handleTextDelta: typeof handleTextDelta;
-    handleThinkingDelta: typeof handleThinkingDelta;
-    handleToolStarted: typeof handleToolStarted;
-    handleToolProgress: typeof handleToolProgress;
-    handleToolExecuted: typeof handleToolExecuted;
-    handleToolConfirmNeeded: typeof handleToolConfirmNeeded;
-    handleRunResult: typeof handleRunResult;
-};
 export declare const chatHandlerMap: Partial<Record<string, (msg: WSServerMessage) => void>>;
+/** Forget a retired lane's run bookkeeping. */
+export declare function forgetLaneRunState(sessionId: string): void;
 export declare function handleIterationStarted(msg: WSServerMessage): void;
 export declare function handleTextDelta(msg: WSServerMessage): void;
 export declare function handleThinkingDelta(msg: WSServerMessage): void;
@@ -17,5 +9,25 @@ export declare function handleToolStarted(msg: WSServerMessage): void;
 export declare function handleToolProgress(msg: WSServerMessage): void;
 export declare function handleToolExecuted(msg: WSServerMessage): void;
 export declare function handleToolConfirmNeeded(msg: WSServerMessage): void;
+/**
+ * Reconcile one tab's spinner with the server's answer.
+ *
+ * Sent per declared tab in reply to `session.subscribe`, which the client
+ * re-sends on every reconnect. `run.result` — the message that stops a lane
+ * spinning — is broadcast exactly once, so a background tab whose run ended
+ * while the socket was down had no way to learn about it: it span forever,
+ * counted as busy, could not be recycled, and offered to abort a run that was
+ * long finished. Positive routing as usual: an answer for a session with no
+ * lane is dropped, never applied to the tab in front.
+ *
+ * On run-end this is a PARTIAL teardown only. The real reply finalization,
+ * chime, queue drain and message bookkeeping still arrive in `run.result`;
+ * the only fields that would otherwise drift across a reconnect gap are the
+ * per-run scratch ones that have no meaning without the run. Clearing them
+ * here stops the NEXT run from inheriting a stale `runStart` (which would
+ * inflate its `durationMs`/`costDelta`) and lets the spinner + thinking-log
+ * reset cleanly before the final `run.result` lands.
+ */
+export declare function handleSessionRunState(msg: WSServerMessage): void;
 export declare function handleRunResult(msg: WSServerMessage): void;
 //# sourceMappingURL=chat-handlers.d.ts.map

package/dist/hooks/ws-handlers/coordinator-handlers.d.ts

@@ -1,3 +1,10 @@
 import type { WSServerMessage } from '@/types';
+/**
+ * Exported as-is: each handler already routes to the lane its message names.
+ *
+ * The wrapper that used to sit here ran `isActiveSessionMessage` over the
+ * whole map and returned early — which is why a background tab's fleet left
+ * no trace. Positive routing replaces it; there is nothing left to gate.
+ */
 export declare const coordinatorHandlerMap: Partial<Record<string, (msg: WSServerMessage) => void>>;
 //# sourceMappingURL=coordinator-handlers.d.ts.map

package/dist/hooks/ws-handlers/files-mailbox-handlers.d.ts

@@ -15,14 +15,12 @@ export { debouncedRefresh, queryMailbox };
  * restored. Re-fetch responses route through `hydrateFileContent`, which
  * never steals focus and never overwrites mid-flight user edits.
  */
-export declare function reconcileFileTabsAfterEnvChange(projectRoot: string): void;
+export declare function reconcileFileTabsAfterEnvChange(projectRoot: string, sessionId?: string | null): void;
 export declare function handleFilesTree(msg: WSServerMessage): void;
 export declare function handleFilesRead(msg: WSServerMessage): void;
 export declare function handleFilesWritten(msg: WSServerMessage): void;
 export declare function handleFilesCreated(msg: WSServerMessage): void;
 export declare function handleFilesDeleted(msg: WSServerMessage): void;
-export declare function handleFilesRenamed(msg: WSServerMessage): void;
-export declare function handleFilesMoved(msg: WSServerMessage): void;
 export declare function handleFilesTreeChanged(_msg: WSServerMessage): void;
 export declare function handleMailboxEvent(msg: WSServerMessage): void;
 export declare function handleMailboxMessages(msg: WSServerMessage): void;

package/dist/hooks/ws-handlers/misc-handlers.d.ts

@@ -5,6 +5,7 @@ export declare function handleGoalLifecycle(msg: WSServerMessage): void;
 export declare function handleGoalList(msg: WSServerMessage): void;
 export declare function handleGoalUpdated(msg: WSServerMessage): void;
 export declare function handlePrefsUpdated(msg: WSServerMessage): void;
+export declare function handleSystemPromptInfo(msg: WSServerMessage): void;
 export declare function handleBrainStatus(msg: WSServerMessage): void;
 export declare function handleBrainAnswer(msg: WSServerMessage): void;
 /**
@@ -30,8 +31,29 @@ export declare function handleModelRefineResult(msg: WSServerMessage): void;
 export declare function handleGitInfo(msg: WSServerMessage): void;
 export declare function handleGitChanges(msg: WSServerMessage): void;
 export declare function handleGitDiff(msg: WSServerMessage): void;
+export declare function handleGitActionResult(msg: WSServerMessage): void;
 export declare function handleCronSnapshot(msg: WSServerMessage): void;
 export declare function handleCronJobFired(msg: WSServerMessage): void;
 export declare function handleChimeraReportAvailable(msg: WSServerMessage): void;
+/**
+ * Server answered `chimera.reports.list` — merge the session's persisted
+ * report list into the registry that feeds the Chimera panel and the reviews
+ * view.
+ *
+ * Deliberately writes NO transcript cards. This request fires whenever a tab
+ * becomes active, so on every resume and every tab switch it re-materialized
+ * review cards into a conversation that was replayed from the journal without
+ * them — the resumed session read as a wall of Chimera notices that were never
+ * part of it. Worse, it raced the replay it accompanied: the report list comes
+ * back in milliseconds while a large journal takes seconds, so the cards were
+ * either wiped by the transcript landing on top of them or (when the replay
+ * was discarded) the only thing left on screen.
+ *
+ * A report that arrives while the session is open still gets its card, from
+ * `handleChimeraReportAvailable` — that one is an event about THIS run and
+ * belongs in the transcript where it happened. Everything else is history, and
+ * history has a panel.
+ */
+export declare function handleChimeraReports(msg: WSServerMessage): void;
 export declare const miscHandlerMap: Partial<Record<string, (msg: WSServerMessage) => void>>;
 //# sourceMappingURL=misc-handlers.d.ts.map

package/dist/hooks/ws-handlers/session-context-handlers.d.ts

@@ -1,8 +1,29 @@
+import { type ChatLaneActions } from '@/stores/chat-lanes';
 import type { WSServerMessage } from '@/types';
-export declare const warnedCostModels: Set<string>;
-export declare function flushThinkingLogForCurrentIteration(): void;
+/**
+ * Models this conversation has already warned about, per conversation.
+ *
+ * One shared Set meant the first tab to hit an unpriced model silenced the
+ * warning for the other three — a tab's run reaching into process-wide state
+ * and changing what a different tab is told.
+ */
+export declare const warnedCostModels: Map<string, Set<string>>;
+/**
+ * Land the reasoning buffered for ONE lane's current iteration.
+ *
+ * Defaults to the lane in front, which is the only lane an untagged
+ * (deliberately fail-open) `error` event can legitimately be about.
+ */
+export declare function flushThinkingLogForCurrentIteration(lane?: ChatLaneActions): void;
 export declare function handleContextDebug(msg: WSServerMessage): void;
 export declare function handleKeyOperationResult(msg: WSServerMessage): void;
+/**
+ * A successful model switch is broadcast to every surface, so it has to be
+ * applied to the tab that ASKED for it. Applying it to whatever session was in
+ * front is why switching the model in tab 2 re-labelled tab 1. It now
+ * addresses the named lane; only the foreground's provider/model pickers,
+ * which describe the tab on screen, follow along.
+ */
 export declare function handleModelSwitchResult(msg: WSServerMessage): void;
 export declare function handleContextCompacted(msg: WSServerMessage): void;
 export declare function handleCompactionFailed(msg: WSServerMessage): void;
@@ -14,5 +35,6 @@ export declare function handleTokenThreshold(msg: WSServerMessage): void;
 export declare function handleTokenCostEstimateUnavailable(msg: WSServerMessage): void;
 export declare function handleContextModesList(msg: WSServerMessage): void;
 export declare function handleContextModeChanged(msg: WSServerMessage): void;
+export declare function handleSessionResumeProgress(msg: WSServerMessage): void;
 export declare function handleError(msg: WSServerMessage): void;
 //# sourceMappingURL=session-context-handlers.d.ts.map

package/dist/hooks/ws-handlers/session-execution-handlers.d.ts

@@ -1,14 +1,27 @@
 import type { WSServerMessage } from '@/types';
 export declare function truncateLine(text: string, max?: number): string;
+/**
+ * A provider response carries the run's usage AND its final text. Both belong
+ * to the session that produced them.
+ *
+ * There used to be an explicit "is this a background tab?" branch here that
+ * hand-folded usage into a parked snapshot and returned early. Lanes make that
+ * branch unnecessary: the write is addressed either way, so a background run's
+ * tokens, cost and reply land in its own tab and the foreground never sees
+ * them until the user switches to it.
+ */
 export declare function handleProviderResponse(msg: WSServerMessage): void;
 export declare function handleIterationCompleted(msg: WSServerMessage): void;
 export declare function handleIterationLimitReached(msg: WSServerMessage): void;
 export declare function handleProviderRetry(msg: WSServerMessage): void;
 export declare function handleProviderError(msg: WSServerMessage): void;
 export declare function handleProviderFallback(msg: WSServerMessage): void;
+export declare function handleProviderModelSwitched(msg: WSServerMessage): void;
 export declare function handleProviderFallbackPending(msg: WSServerMessage): void;
 export declare function handleProviderStatusChanged(msg: WSServerMessage): void;
 export declare function handleProviderStatusSnapshot(msg: WSServerMessage): void;
+/** `provider.audit.history` — durable block/open tail for the waiting room. */
+export declare function handleProviderAuditHistory(msg: WSServerMessage): void;
 export declare function handleProviderActiveBlocked(msg: WSServerMessage): void;
 export declare function handleProviderStreamError(msg: WSServerMessage): void;
 export declare function handleToolLoopDetected(msg: WSServerMessage): void;

package/dist/hooks/ws-handlers/session-handlers.d.ts

@@ -1,6 +1,6 @@
 import type { WSServerMessage } from '@/types';
-export { type ReplayMessage, replayTimestamp, replayMessageId, isRoutePinnedView, contentToToolResult, providerResponseText, sessionRouteIdentifier, hydrateReplayMessages, handleSessionStart, } from './session-replay-handlers';
-export { warnedCostModels, flushThinkingLogForCurrentIteration, handleContextDebug, handleKeyOperationResult, handleModelSwitchResult, handleContextCompacted, handleCompactionFailed, handleTrustPersisted, handleContextRepaired, handleContextPct, handleContextMaxContext, handleTokenThreshold, handleTokenCostEstimateUnavailable, handleContextModesList, handleContextModeChanged, handleError, } from './session-context-handlers';
-export { truncateLine, handleProviderResponse, handleIterationCompleted, handleIterationLimitReached, handleProviderRetry, handleProviderError, handleProviderFallback, handleProviderFallbackPending, handleProviderStatusChanged, handleProviderStatusSnapshot, handleProviderActiveBlocked, handleProviderStreamError, handleToolLoopDetected, handleDelegateStarted, handleDelegateCompleted, handleSessionDamaged, handleSessionRewound, handleCheckpointWritten, handleInFlightStarted, handleInFlightEnded, handleSessionEnd, handleSessionsList, } from './session-execution-handlers';
+export { flushThinkingLogForCurrentIteration, handleCompactionFailed, handleContextCompacted, handleContextDebug, handleContextMaxContext, handleContextModeChanged, handleContextModesList, handleContextPct, handleContextRepaired, handleError, handleKeyOperationResult, handleModelSwitchResult, handleSessionResumeProgress, handleTokenCostEstimateUnavailable, handleTokenThreshold, handleTrustPersisted, warnedCostModels, } from './session-context-handlers';
+export { handleCheckpointWritten, handleDelegateCompleted, handleDelegateStarted, handleInFlightEnded, handleInFlightStarted, handleIterationCompleted, handleIterationLimitReached, handleProviderActiveBlocked, handleProviderAuditHistory, handleProviderError, handleProviderFallback, handleProviderFallbackPending, handleProviderResponse, handleProviderRetry, handleProviderStatusChanged, handleProviderStatusSnapshot, handleProviderStreamError, handleSessionDamaged, handleSessionEnd, handleSessionRewound, handleSessionsList, handleToolLoopDetected, truncateLine, } from './session-execution-handlers';
+export { contentToToolResult, handleSessionStart, hydrateReplayMessages, isRoutePinnedView, providerResponseText, type ReplayMessage, replayMessageId, replayTimestamp, sessionRouteIdentifier, } from './session-replay-handlers';
 export declare const sessionHandlerMap: Partial<Record<string, (msg: WSServerMessage) => void>>;
 //# sourceMappingURL=session-handlers.d.ts.map

package/dist/hooks/ws-handlers/session-replay-handlers.d.ts

@@ -1,4 +1,4 @@
-import type { SessionMarker } from '@wrongstack/core/types';
+import type { SessionMarker, SessionToolMeta } from '@wrongstack/core/types';
 import type { ChatMessage } from '@/stores';
 import type { WSServerMessage } from '@/types';
 export interface ReplayMessage {
@@ -17,6 +17,35 @@ export declare function providerResponseText(content: unknown): string;
  * never stringify the full object because it may also contain credentials.
  */
 export declare function sessionRouteIdentifier(value: unknown): string;
-export declare function hydrateReplayMessages(replay: ReplayMessage[], markers?: readonly SessionMarker[]): ChatMessage[];
+/**
+ * Rebuild a lane's chat from a replayed session.
+ *
+ * Ordering, tool pairing and visibility come from core's
+ * {@link projectSessionTimeline} — the same function the TUI, SimpleUI and HQ
+ * project through — so a resumed session cannot read differently here than it
+ * does there. Everything below the projection is WebUI presentation: which
+ * `ChatMessage` shape a timeline entry becomes.
+ *
+ * `thinkingPlacement: 'merged-after'` is not a style choice. Live, the thinking
+ * bubble is transient and the archived log is only committed when the
+ * iteration completes — i.e. AFTER the prose and tool cards are already on
+ * screen. Replaying it inline would put the log somewhere it never appeared.
+ */
+export declare function hydrateReplayMessages(replay: ReplayMessage[], markers?: readonly SessionMarker[], toolMeta?: readonly SessionToolMeta[]): ChatMessage[];
+/**
+ * `session.start` is how EVERY tab change arrives: `session.new` and
+ * `session.resume` both answer with one, and the server also re-announces on
+ * model switch and at boot.
+ *
+ * Under the lane model this handler has one job — fill the NAMED session's
+ * lane — and one decision: does this session come to the front?
+ *
+ * What it deliberately no longer does is park, snapshot, restore or clear
+ * anybody else's state. Every lane keeps its own transcript whether or not it
+ * is on screen, so there is nothing to save on the way out and nothing to
+ * rebuild on the way in. That bookkeeping is where the cross-tab damage lived:
+ * a swap that cleared instead of parked lost the outgoing transcript, and one
+ * that restored under a stale key handed it to the wrong tab.
+ */
 export declare function handleSessionStart(msg: WSServerMessage): void;
 //# sourceMappingURL=session-replay-handlers.d.ts.map

package/dist/hooks/ws-handlers/techstack-handlers.d.ts

@@ -1,7 +1,4 @@
 import type { WSServerMessage } from '@/types';
-export type TechStackServerMessage = Extract<WSServerMessage, {
-    type: `techstack.${string}`;
-}>;
 export declare function handleTechStackJobStarted(msg: WSServerMessage): void;
 export declare function handleTechStackJobProgress(msg: WSServerMessage): void;
 export declare function handleTechStackWorkspaceCompleted(msg: WSServerMessage): void;