@wrongstack/webui 1.0.24 → 1.0.27

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/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;

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

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/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. */

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

@@ -1,12 +1,10 @@
-import { type GoalJournalEntry, type GoalState } from '@/lib/goal';
-interface GoalStoreState {
-    goal: GoalState | null;
-    setGoal: (raw: Record<string, unknown> | null) => void;
-    clear: () => void;
-    appendJournalEntry: (entry: GoalJournalEntry) => void;
-    /** Request the latest goal state from the server. Safe to call any time. */
-    refresh: () => void;
-}
-export declare const useGoalStore: import("zustand").UseBoundStore<import("zustand").StoreApi<GoalStoreState>>;
-export {};
+/**
+ * Backward-compatible alias for the canonical persistent mission store.
+ *
+ * Goal state used to be represented by two independent Zustand stores, so a
+ * `goal-state.updated` frame could update the dock while legacy consumers kept
+ * rendering stale data. Keep the old import path without keeping a second
+ * source of truth.
+ */
+export { useGoalStateStore as useGoalStore } from './goal-state-store.js';
 //# sourceMappingURL=goal-store.d.ts.map

package/dist/stores/index.d.ts

@@ -48,7 +48,7 @@ export { memorySessionSnapshots, useSessionStore } from './session-store.js';
 export { isTabBusy, MAX_OPEN_TABS, slotOf, summarizeTab, type TabSummary, useSessionTabStore, } from './session-tab-store.js';
 export { type SideEffectEntry, useSideEffectStore } from './side-effect-store.js';
 export { type BoardTaskItem, type BoardTaskStatus, type SpecColumn, type SpecDetail, type SpecListItem, useSpecsStore, } from './specs-store.js';
-export { type TechStackCoverage, type TechStackDependency, type TechStackEvidence, type TechStackFinding, type TechStackFindingAction, type TechStackFindingSeverity, type TechStackFindingType, type TechStackJobKind, type TechStackJobStatus, type TechStackJobView, type TechStackProgress, type TechStackSnapshot, type TechStackWorkspace, useTechStackStore, } from './techstack-store.js';
+export { type TechStackAnalyzeDepth, type TechStackApplyPlanResult, type TechStackCoverage, type TechStackDependency, type TechStackEvidence, type TechStackFinding, type TechStackFindingAction, type TechStackFindingSeverity, type TechStackFindingType, type TechStackJobKind, type TechStackJobStatus, type TechStackJobView, type TechStackModelInfo, type TechStackProgress, type TechStackSnapshot, type TechStackTrendPoint, type TechStackTrendReport, type TechStackUpgradePlan, type TechStackUpgradePlanItem, type TechStackWorkspace, useTechStackStore, } from './techstack-store.js';
 export { bucketSuccessRatio, LEADER_AGENT_KEY, sessionInFlight, type ToolStatsBucket, type ToolStatsDelegation, type ToolStatsSession, useToolStatsStore, } from './tool-stats-store.js';
 export type { AgentTranscriptEntry, AgentTranscriptKind, BrainDecisionData, ChatMessage, ChatMessageAttachment, CouncilDecisionData, CouncilSeatVote, FleetTimelineEvent, SessionHistoryEntry, SessionInfo, SubagentEvent, SubagentView, ToolExecution, } from './types.js';
 export type { Activity, DockSection, InspectorTab, WorkDashboardTab } from './ui-store.js';