@wrongstack/webui 1.0.19 → 1.0.26

package/dist/lib/auth-operation.d.ts

@@ -0,0 +1,5 @@
+import type { WSClientMessage } from '@/types';
+import type { WrongStackWebSocketClient } from './ws-client';
+/** A matching server acknowledgment, never an unrelated operation result. */
+export declare function requestAuthOperation(client: WrongStackWebSocketClient, message: WSClientMessage, signal: AbortSignal, onTimeout: () => void): Promise<boolean>;
+//# sourceMappingURL=auth-operation.d.ts.map

package/dist/lib/compact-file-tree.d.ts

@@ -0,0 +1,30 @@
+/**
+ * A list of changed files as a directory tree, with chains of single-child
+ * directories folded into one node (`packages/webui/src`), the way editors
+ * show "compact folders". Directories come before files, each sorted by name;
+ * every directory carries its file count and line totals.
+ */
+export interface TreeFileLike {
+    path: string;
+    added: number;
+    deleted: number;
+}
+export interface CompactTreeDir<F extends TreeFileLike> {
+    kind: 'dir';
+    /** One or more path segments joined with `/`. */
+    name: string;
+    /** The full directory path, unique within the tree (a key and a collapse id). */
+    path: string;
+    children: CompactTreeNode<F>[];
+    fileCount: number;
+    added: number;
+    deleted: number;
+}
+export interface CompactTreeFile<F extends TreeFileLike> {
+    kind: 'file';
+    name: string;
+    file: F;
+}
+export type CompactTreeNode<F extends TreeFileLike> = CompactTreeDir<F> | CompactTreeFile<F>;
+export declare function buildCompactFileTree<F extends TreeFileLike>(files: readonly F[]): CompactTreeNode<F>[];
+//# sourceMappingURL=compact-file-tree.d.ts.map

package/dist/lib/project-image.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Load an image from the project for display (`files.image`): the server
+ * checks the path stays inside the project, sniffs the bytes, and answers
+ * with a data URL. Answers are cached for the page (a few dozen, newest kept);
+ * a miss is not cached, so a later look can succeed.
+ */
+export type ProjectImageState = {
+    status: 'loading';
+} | {
+    status: 'ready';
+    dataUrl: string;
+    bytes?: number | undefined;
+} | {
+    status: 'unavailable';
+    reason: 'tooLarge' | 'notImage' | 'error';
+    detail?: string;
+};
+/**
+ * `key` tells apart two looks at one path (the same file generated twice);
+ * it defaults to the path.
+ */
+export declare function loadProjectImage(filePath: string, key?: string): Promise<ProjectImageState>;
+export declare function useProjectImage(filePath: string | undefined, key?: string): ProjectImageState;
+/** `12.3 KiB`-style size for image captions. */
+export declare function formatImageBytes(bytes: number | undefined): string;
+//# sourceMappingURL=project-image.d.ts.map

package/dist/lib/provider-warm.d.ts

@@ -0,0 +1,3 @@
+/** Composer text changed in `sessionId` while no turn is running there. */
+export declare function warmProviderWhileTyping(sessionId: string, text: string, now?: number): void;
+//# sourceMappingURL=provider-warm.d.ts.map

package/dist/lib/sdd-theme.d.ts

@@ -8,8 +8,8 @@
 import { type LucideIcon } from 'lucide-react';
 type SddStatus = 'pending' | 'queued' | 'in_progress' | 'blocked' | 'review' | 'failed' | 'completed' | 'cancelled';
 interface SddStatusStyle {
-    /** Short label, e.g. "Running". */
-    label: string;
+    /** i18n key resolving to the short label, e.g. "Running". */
+    labelKey: string;
     /** Lucide icon for the status. */
     icon: LucideIcon;
     /** True for the running state (drives spin + glow). */

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

@@ -64,6 +64,7 @@ export interface WsClientActionMethods {
         allowedTools?: string[];
         url?: string;
         headers?: Record<string, string>;
+        bearerTokenEnv?: string;
         lazy?: boolean;
     }): void;
     removeMcpServer(name: string): void;
@@ -78,6 +79,7 @@ export interface WsClientActionMethods {
         allowedTools?: string[];
         url?: string;
         headers?: Record<string, string>;
+        bearerTokenEnv?: string;
         lazy?: boolean;
     }): void;
     wakeMcpServer(name: string): void;

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

@@ -73,7 +73,7 @@ declare const domainMethods: {
     updateKey(this: WsClientDomainHost, providerId: string, label: string, apiKey: string): void;
     deleteKey(this: WsClientDomainHost, providerId: string, label: string): void;
     setActiveKey(this: WsClientDomainHost, providerId: string, label: string): void;
-    addProvider(this: WsClientDomainHost, id: string, family: string, baseUrl?: string | undefined, apiKey?: string, models?: string[] | undefined, customModels?: Record<string, ProviderCustomModelWire> | undefined): void;
+    addProvider(this: WsClientDomainHost, id: string, family: string, baseUrl?: string | undefined, apiKey?: string, models?: string[] | undefined, customModels?: Record<string, ProviderCustomModelWire> | undefined, providerType?: string | undefined): void;
     removeProvider(this: WsClientDomainHost, providerId: string): void;
     listOAuthProviders(this: WsClientDomainHost): void;
     startOAuth(this: WsClientDomainHost, kind: string, providerId?: string): void;

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

@@ -1,4 +1,5 @@
 import type { WSClientMessage, WSModelSwitchResult, WSServerMessage, WSUserMessageImage } from '../types';
+import type { FrameResume } from '@wrongstack/webui-protocol';
 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
@@ -24,6 +25,7 @@ export interface WsClientSessionHost {
     pendingConfirms: Map<string, PendingConfirm>;
     subscribedSessionIds: string[];
     replayOnNextSubscribe: boolean;
+    frameResume: FrameResume<WSServerMessage>;
     armedResends: Map<string, {
         content: string;
         freshContext?: boolean | undefined;
@@ -41,7 +43,7 @@ export interface WsClientSessionMethods {
     sendAbort(sessionId?: string | undefined): void;
     subscribeSessions(sessionIds: string[]): void;
     clearSessionSubscription(): void;
-    sendConfirm(id: string, decision: 'yes' | 'no' | 'always' | 'deny'): void;
+    sendConfirm(id: string, decision: 'yes' | 'no' | 'always' | 'always-exact' | 'always-command' | 'always-tool' | 'deny'): void;
     switchModel(provider: string, model: string, timeoutMs?: number): Promise<WSModelSwitchResult['payload']>;
     shutdownCodebaseIndexServer(timeoutMs?: number): Promise<Extract<WSServerMessage, {
         type: 'codebase.index.server.shutdown_result';

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

@@ -1,3 +1,4 @@
+import { FrameResume } from '@wrongstack/webui-protocol';
 import type { WSClientMessage, WSServerMessage, WSUserMessageImage } from '../types';
 import { type WsClientActionMethods } from './ws-client-actions';
 import type { WSSendOptions } from './ws-client-contracts';
@@ -82,6 +83,8 @@ declare class WrongStackWebSocketClientBase {
     replayOnNextSubscribe: boolean;
     /** Last declared open-tab set — see `subscribeSessions`. */
     subscribedSessionIds: string[];
+    /** Reconnect catch-up: session frames in order, missed ones asked back. */
+    readonly frameResume: FrameResume<WSServerMessage>;
     /**
      * Auto-retry parking for a `session_not_ready` refusal: the message the
      * server refused while its session had no live writer, held until that
@@ -114,9 +117,6 @@ declare class WrongStackWebSocketClientBase {
      * 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;

package/dist/stores/chat-lane-data.d.ts

@@ -0,0 +1,153 @@
+import type { WSQueuedPromptView } from '@/types/prompt-queue';
+import type { QueuedItem, ToolExecution } from './chat-store-types';
+import type { ChatMessage } from './types.js';
+/** 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[];
+    /** Prompts queued on the server for this session (it owns and drains them). */
+    serverQueue: WSQueuedPromptView[];
+    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. */
+export 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;
+    deadlineAt?: number | undefined;
+}
+export declare function createLaneData(): ChatLaneData;
+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 serverQueue: WSQueuedPromptView[];
+    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;
+}
+//# sourceMappingURL=chat-lane-data.d.ts.map

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

@@ -1,31 +1,6 @@
-/**
- * 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 ChatLaneActions, type ChatLaneData } from './chat-lane-data.js';
+export type { ChatLaneActions, ChatLaneData, PendingConfirm } from './chat-lane-data.js';
+import type { QueuedItem } from './chat-store-types';
 import type { ChatMessage } from './types.js';
 /**
  * Hard ceiling on concurrent lanes. Four tabs, four lanes, no exceptions —
@@ -39,80 +14,6 @@ export declare const MAX_LANES = 4;
  * 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;
-    deadlineAt?: number | 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
@@ -171,77 +72,6 @@ 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
@@ -276,5 +106,4 @@ export declare function chatLane(sessionId: string): ChatLaneActions;
 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-queue-helpers.d.ts

@@ -6,4 +6,13 @@ export declare function setEnqueueSequence(seq: number): void;
 export declare function nextQueueItemId(): number;
 export declare function normalizeQueuedItem(value: unknown): QueuedItem | null;
 export declare const BTW_DISPATCH_GRACE_MS = 1800;
+/**
+ * Hands a `queue`-mode prompt to the server's session queue. Returns false
+ * when the server cannot take it (older server, disconnected, no session yet),
+ * and the lane then keeps it locally the way it always has.
+ */
+export type RemotePromptQueue = (sessionId: string, text: string, images: QueuedItem['images']) => boolean;
+/** Installed by the WebSocket layer, which knows whether the server has a queue. */
+export declare function setRemotePromptQueue(queue: RemotePromptQueue | null): void;
+export declare function getRemotePromptQueue(): RemotePromptQueue | null;
 //# sourceMappingURL=chat-queue-helpers.d.ts.map

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

@@ -1,3 +1,4 @@
+import type { WSQueuedPromptView } from '@/types/prompt-queue';
 import type { ChatMessage } from './types.js';
 export type QueueMode = 'btw' | 'steer' | 'queue';
 export interface QueuedItem {
@@ -39,6 +40,8 @@ export interface ChatState {
     executions: Map<string, ToolExecution>;
     toolMessageIdsByUseId: Map<string, string>;
     queue: QueuedItem[];
+    /** Prompts queued on the server for this session (it owns and drains them). */
+    serverQueue: readonly WSQueuedPromptView[];
     runStart: {
         at: number;
         cost: number;

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

@@ -20,7 +20,7 @@ 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 { activeChatLane, activeLaneId, adoptDefaultLane, type ChatLaneActions, type ChatLaneData, chatLane, DEFAULT_LANE_ID, disposeLane, ensureLane, hasLane, laneIds, MAX_LANES, readLane, setActiveLane, useChatLanes, } from './chat-lanes';
+export { activeChatLane, activeLaneId, adoptDefaultLane, chatLane, DEFAULT_LANE_ID, disposeLane, ensureLane, hasLane, laneIds, MAX_LANES, readLane, setActiveLane, useChatLanes, type ChatLaneActions, type ChatLaneData, } from './chat-lanes';
 export { BTW_DISPATCH_GRACE_MS } from './chat-queue-helpers';
 export { boundChatField, dedupeRepeatedBlocks, indexToolExecutions, indexToolMessages, MAX_CHAT_FIELD_CHARS, MAX_CHAT_RETAINED_BYTES, retainWebChatMessages, } from './chat-retention';
 export * from './chat-store-types';

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

@@ -1,4 +1,4 @@
-import type { ContextEditorMessage, ContextEditorMetrics, ContextEditorRemoval, ContextEditorRepairPreview, ContextEditorValidationError, ContextEditorWarning, ContextEditorConflict, ContextEditorDiagnostics } from '@/types/runtime';
+import type { ContextEditorConflict, ContextEditorDiagnostics, ContextEditorMessage, ContextEditorMetrics, ContextEditorRemoval, ContextEditorRepairPreview, ContextEditorValidationError, ContextEditorWarning } from '@/types/runtime';
 type ContextEditorPhase = 'closed' | 'loading_snapshot' | 'clean_snapshot' | 'dirty' | 'validating' | 'validated' | 'invalid' | 'conflicted' | 'applying' | 'applied_success' | 'apply_failed';
 interface ReadonlyContext {
     systemPromptTokens: number;

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

@@ -6,6 +6,8 @@ export interface CouncilPanelEntry {
     startedAt: number;
     resolvedAt?: number | undefined;
     seats: CouncilSeatVote[];
+    /** Final ballots supersede the live stream, including later failed rounds. */
+    hasFinalVotes?: boolean | undefined;
     /** Folded in from the matching `brain.decision_*` event, when it arrives. */
     question?: string | undefined;
     status?: string | undefined;
@@ -33,6 +35,8 @@ export declare const MAX_COUNCIL_PANELS = 50;
 interface CouncilLogState {
     /** Newest first. */
     panels: CouncilPanelEntry[];
+    /** Bounded, session-local questions received before the first ballot. */
+    questions: Map<string, string>;
     recordVote: (payload: Record<string, unknown>) => void;
     recordResolution: (payload: Record<string, unknown>) => void;
     noteQuestion: (requestId: string, question: string) => void;

package/dist/stores/fleet-transcript.d.ts

@@ -0,0 +1,14 @@
+import type { AgentTranscriptEntry, FleetTimelineEvent, SubagentView } from './types.js';
+export declare const SPARKLINE_BINS = 12;
+export declare const MAX_TIMELINE = 20;
+export declare const MAX_AGENT_TRANSCRIPT = 1000;
+export declare function blankAgent(id: string, name?: string, sessionId?: string): SubagentView;
+export declare function pushTimeline(timeline: FleetTimelineEvent[], event: FleetTimelineEvent): FleetTimelineEvent[];
+export declare function canMergeTranscriptEntry(a: AgentTranscriptEntry, b: AgentTranscriptEntry): boolean;
+export declare function appendTranscriptEntry(entries: AgentTranscriptEntry[], entry: AgentTranscriptEntry): AgentTranscriptEntry[];
+/** Update sparkline bins for an agent — bump bin 0 and shift left.
+ *  The bins array has index 0 as the most recent bucket.
+ *  Each event bumps bin 0, then the array is truncated to SPARKLINE_BINS. */
+export declare function bumpSparkline(bins: number[]): number[];
+export declare function clampContextPct(pct: number): number;
+//# sourceMappingURL=fleet-transcript.d.ts.map

package/dist/stores/git-changes-store.d.ts

@@ -1,3 +1,4 @@
+import type { GitImageDiff } from '@/types/server-message';
 /** One changed file row in the Changes (source-control) panel. */
 export interface GitChangedFile {
     path: string;
@@ -15,6 +16,8 @@ export interface GitDiffContent {
     binary?: boolean;
     tooLarge?: boolean;
     error?: string;
+    /** A changed image: both versions to show instead of a text diff. */
+    image?: GitImageDiff | undefined;
 }
 interface GitChangesSessionState {
     selectedPath: string | null;

package/dist/stores/goal-run-store.d.ts

@@ -13,6 +13,7 @@ interface GoalRunState {
     overallPercent: number;
     autonomous: boolean;
     title: string | null;
+    graphId: string | null;
     /** Full operator prompt that started the run (title is only a short heading). */
     goal: string | null;
     status: GoalRunStatus;
@@ -30,12 +31,18 @@ interface GoalRunState {
         completedTasks: number;
         failedTasks: number;
     } | null;
+    finalVerification: {
+        status: 'passed' | 'failed';
+        checkedAt: number;
+        error?: string | undefined;
+    } | null;
     setState: (s: {
         phases?: PhaseItem[] | undefined;
         activePhaseId?: string | null | undefined;
         overallPercent?: number | undefined;
         autonomous?: boolean | undefined;
         title?: string | null | undefined;
+        graphId?: string | null | undefined;
         goal?: string | null | undefined;
         status?: GoalRunStatus | undefined;
         multiBoard?: boolean | undefined;
@@ -43,6 +50,7 @@ interface GoalRunState {
         lastError?: string | null | undefined;
         graphs?: GoalRunBoardSummary[] | undefined;
         progress?: GoalRunState['progress'] | undefined;
+        finalVerification?: GoalRunState['finalVerification'] | undefined;
     }) => void;
     clear: () => void;
     /** Request state from server on mount. */

package/dist/stores/goal-state-store.d.ts

@@ -1,7 +1,10 @@
 import { type GoalJournalEntry, type GoalState } from '@/lib/goal';
 interface GoalStateStoreState {
     goal: GoalState | null;
+    missionId: string | null;
+    refiningMissionId: string | null;
     setGoal: (raw: Record<string, unknown> | null) => void;
+    setRefining: (missionId: string, active: boolean) => void;
     clear: () => void;
     appendJournalEntry: (entry: GoalJournalEntry) => void;
     /** Request the latest goal state from the server. Safe to call any time. */