@wrongstack/webui 0.306.4 → 0.307.1

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

@@ -1,6 +1,6 @@
 import { type Activity } from '@/stores/ui-store';
 export type PanelMainView = 'chat' | 'files' | 'skill' | 'officemap' | 'changes' | 'mailbox' | 'design-gallery';
-export type MainView = 'goal' | 'kanban' | 'sddhub' | 'settings' | 'memory' | 'roster' | 'codemap' | 'techstack' | 'chronicle' | 'intake';
+export type MainView = 'goal' | 'kanban' | 'sddhub' | 'settings' | 'memory' | 'roster' | 'codemap' | 'techstack' | 'chronicle' | 'intake' | 'prompts';
 export type AppView = PanelMainView | MainView | 'sessions' | 'session-inspect' | 'setup' | 'debug' | 'refresh-debug' | 'analytics';
 export declare const PANEL_VIEW_BY_ACTIVITY: Record<Activity, PanelMainView>;
 export declare const VIEW_ACTIVITY: Partial<Record<AppView, Activity>>;

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

@@ -0,0 +1,86 @@
+import type { WSClientMessage } from '../types';
+import type { ProviderCustomModelWire } from '../types/client-message';
+import type { ContextEditorMessage, ContextEditorRemoval } from '../types/runtime';
+import type { WSSendOptions } from './ws-client-contracts';
+export interface WsClientDomainHost {
+    send(message: WSClientMessage, options?: WSSendOptions): boolean;
+    withSession<T extends Record<string, unknown>>(payload: T): T & {
+        sessionId?: string;
+    };
+}
+export declare const domainMethods: {
+    getGitInfo(this: WsClientDomainHost): void;
+    getGitChanges(this: WsClientDomainHost): void;
+    getGitDiff(this: WsClientDomainHost, path: string): void;
+    getProviderStatus(this: WsClientDomainHost): void;
+    retryProviderModel(this: WsClientDomainHost, providerId: string, model: string): void;
+    clearProviderStatus(this: WsClientDomainHost, providerId: string, model: string): void;
+    newSession(this: WsClientDomainHost): void;
+    listProviders(this: WsClientDomainHost): void;
+    listProviderModels(this: WsClientDomainHost, providerId: string): void;
+    listSavedProviders(this: WsClientDomainHost): void;
+    searchProviderModels(this: WsClientDomainHost, query: string, limit?: number): void;
+    addKey(this: WsClientDomainHost, providerId: string, label: string, apiKey: string): void;
+    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;
+    removeProvider(this: WsClientDomainHost, providerId: string): void;
+    startOAuth(this: WsClientDomainHost, kind: 'chatgpt' | 'claude' | 'copilot', providerId?: string): void;
+    submitOAuthCode(this: WsClientDomainHost, kind: 'chatgpt' | 'claude' | 'copilot', input: string): void;
+    cancelOAuth(this: WsClientDomainHost, kind: 'chatgpt' | 'claude' | 'copilot'): void;
+    probeProvider(this: WsClientDomainHost, providerId: string, timeoutMs?: number): void;
+    clearProviderModels(this: WsClientDomainHost, providerId: string): void;
+    undoProviderClear(this: WsClientDomainHost, providerId: string, previousModels: string[]): void;
+    setCustomModel(this: WsClientDomainHost, providerId: string, modelId: string, customModel: ProviderCustomModelWire): void;
+    removeCustomModel(this: WsClientDomainHost, providerId: string, modelId: string): void;
+    updateProvider(this: WsClientDomainHost, payload: {
+        id: string;
+        family?: string | undefined;
+        baseUrl?: string | undefined;
+        envVars?: string[] | undefined;
+        models?: string[] | undefined;
+        customModels?: Record<string, ProviderCustomModelWire> | undefined;
+    }): void;
+    clearContext(this: WsClientDomainHost): void;
+    compactContext(this: WsClientDomainHost, aggressive?: boolean): void;
+    repairContext(this: WsClientDomainHost): void;
+    openContextEditor(this: WsClientDomainHost): void;
+    validateContextEditor(this: WsClientDomainHost, baseRevision: string, messages: ContextEditorMessage[], removals: ContextEditorRemoval[], allowRepair: boolean): void;
+    applyContextEditor(this: WsClientDomainHost, baseRevision: string, messages: ContextEditorMessage[], removals: ContextEditorRemoval[], allowRepair: boolean): void;
+    debugContext(this: WsClientDomainHost, options?: WSSendOptions): void;
+    listContextModes(this: WsClientDomainHost): void;
+    switchContextMode(this: WsClientDomainHost, id: string): void;
+    createContextMode(this: WsClientDomainHost, mode: {
+        id: string;
+        name: string;
+        description: string;
+        thresholds: {
+            warn: number;
+            soft: number;
+            hard: number;
+        };
+        preserveK: number;
+        eliseThreshold: number;
+    }): void;
+    updateContextMode(this: WsClientDomainHost, id: string, patch: {
+        name?: string | undefined;
+        description?: string | undefined;
+        thresholds?: {
+            warn?: number | undefined;
+            soft?: number | undefined;
+            hard?: number | undefined;
+        } | undefined;
+        preserveK?: number | undefined;
+        eliseThreshold?: number | undefined;
+    }): void;
+    deleteContextMode(this: WsClientDomainHost, id: string): void;
+    switchAutonomy(this: WsClientDomainHost, mode: string): void;
+    updatePrefs(this: WsClientDomainHost, prefs: Record<string, unknown>): void;
+    getPrefs(this: WsClientDomainHost): void;
+};
+export declare function installWsClientDomainMethods(ctor: {
+    prototype: any;
+}): void;
+export type WsClientDomainMethods = typeof domainMethods;
+//# sourceMappingURL=ws-client-domain-methods.d.ts.map

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

@@ -1,7 +1,6 @@
 import type { WSClientMessage, WSModelSwitchResult, WSServerMessage, WSUserMessageImage } from '../types';
-import type { ProviderCustomModelWire } from '../types/client-message';
-import type { ContextEditorMessage, ContextEditorRemoval } from '../types/runtime';
 import { type WsClientActionMethods } from './ws-client-actions';
+import { type WsClientDomainMethods } from './ws-client-domain-methods';
 import type { WSSendOptions } from './ws-client-contracts';
 import { type EventHandler, type WsStatus } from './ws-client-utils';
 export type { WSSendOptions } from './ws-client-contracts';
@@ -148,96 +147,16 @@ declare class WrongStackWebSocketClientBase {
      *  to a target agent/role. Returns the requestId for response tracking. */
     sendMailboxMessage(opts: WSMailboxSendOptions): string;
     sendAbort(): void;
-    getGitInfo(): void;
-    /** Request the working-tree change set (file list for the Changes panel). */
-    getGitChanges(): void;
-    /** Request the before/after content for one changed file. */
-    getGitDiff(path: string): void;
     sendConfirm(id: string, decision: 'yes' | 'no' | 'always' | 'deny'): void;
     switchModel(provider: string, model: string, timeoutMs?: number): Promise<WSModelSwitchResult['payload']>;
-    getProviderStatus(): void;
-    retryProviderModel(providerId: string, model: string): void;
-    clearProviderStatus(providerId: string, model: string): void;
-    newSession(): void;
     shutdownCodebaseIndexServer(timeoutMs?: number): Promise<Extract<WSServerMessage, {
         type: 'codebase.index.server.shutdown_result';
     }>['payload']>;
-    listProviders(): void;
-    listProviderModels(providerId: string): void;
-    listSavedProviders(): void;
-    searchProviderModels(query: string, limit?: number): void;
-    addKey(providerId: string, label: string, apiKey: string): void;
-    updateKey(providerId: string, label: string, apiKey: string): void;
-    deleteKey(providerId: string, label: string): void;
-    setActiveKey(providerId: string, label: string): void;
-    addProvider(id: string, family: string, baseUrl?: string | undefined, apiKey?: string, models?: string[] | undefined, customModels?: Record<string, ProviderCustomModelWire> | undefined): void;
-    removeProvider(providerId: string): void;
-    /** Begin a subscription sign-in; progress arrives as `auth.oauth.status`. */
-    startOAuth(kind: 'chatgpt' | 'claude' | 'copilot', providerId?: string): void;
-    /** Manual-paste fallback for loopback flows (port busy / remote browser). */
-    submitOAuthCode(kind: 'chatgpt' | 'claude' | 'copilot', input: string): void;
-    /** Cancel an in-flight subscription sign-in. */
-    cancelOAuth(kind: 'chatgpt' | 'claude' | 'copilot'): void;
-    /** Run a health probe against a saved provider's `/v1/models`. */
-    probeProvider(providerId: string, timeoutMs?: number): void;
-    /** Remove the saved model allowlist for a provider. */
-    clearProviderModels(providerId: string): void;
-    /** Restore a previously-cleared model allowlist (pairs with clear). */
-    undoProviderClear(providerId: string, previousModels: string[]): void;
-    /** Set/update a single custom model definition (ME-3). */
-    setCustomModel(providerId: string, modelId: string, customModel: ProviderCustomModelWire): void;
-    /** Remove a single custom model entry (ME-3). */
-    removeCustomModel(providerId: string, modelId: string): void;
-    /** Update a saved provider's wire config (family / baseUrl / envVars / models / customModels). */
-    updateProvider(payload: {
-        id: string;
-        family?: string | undefined;
-        baseUrl?: string | undefined;
-        envVars?: string[] | undefined;
-        models?: string[] | undefined;
-        customModels?: Record<string, ProviderCustomModelWire> | undefined;
-    }): void;
-    clearContext(): void;
-    compactContext(aggressive?: boolean): void;
-    repairContext(): void;
-    openContextEditor(): void;
-    validateContextEditor(baseRevision: string, messages: ContextEditorMessage[], removals: ContextEditorRemoval[], allowRepair: boolean): void;
-    applyContextEditor(baseRevision: string, messages: ContextEditorMessage[], removals: ContextEditorRemoval[], allowRepair: boolean): void;
-    debugContext(options?: WSSendOptions): void;
-    listContextModes(): void;
-    switchContextMode(id: string): void;
-    createContextMode(mode: {
-        id: string;
-        name: string;
-        description: string;
-        thresholds: {
-            warn: number;
-            soft: number;
-            hard: number;
-        };
-        preserveK: number;
-        eliseThreshold: number;
-    }): void;
-    updateContextMode(id: string, patch: {
-        name?: string | undefined;
-        description?: string | undefined;
-        thresholds?: {
-            warn?: number | undefined;
-            soft?: number | undefined;
-            hard?: number | undefined;
-        } | undefined;
-        preserveK?: number | undefined;
-        eliseThreshold?: number | undefined;
-    }): void;
-    deleteContextMode(id: string): void;
-    switchAutonomy(mode: string): void;
-    updatePrefs(prefs: Record<string, unknown>): void;
-    getPrefs(): void;
     disconnect(): void;
     get isConnected(): boolean;
     get currentSessionId(): string | null;
 }
-export type WrongStackWebSocketClient = WrongStackWebSocketClientBase & WsClientActionMethods;
+export type WrongStackWebSocketClient = WrongStackWebSocketClientBase & WsClientActionMethods & WsClientDomainMethods;
 interface WrongStackWebSocketClientConstructor {
     new (url?: string): WrongStackWebSocketClient;
     readonly prototype: WrongStackWebSocketClient;

package/dist/stores/chat-queue-helpers.d.ts

@@ -0,0 +1,9 @@
+import type { QueuedItem } from './chat-store-types';
+export declare const dispatchedGraceTimers: Map<number, NodeJS.Timeout>;
+export declare function cancelDispatchedGraceTimer(itemId: number): void;
+export declare let enqueueSequence: number;
+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;
+//# sourceMappingURL=chat-queue-helpers.d.ts.map

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

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

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

@@ -0,0 +1,106 @@
+import type { ChatMessage } from './types.js';
+export type QueueMode = 'btw' | 'steer' | 'queue';
+export interface QueuedItem {
+    text: string;
+    mode: QueueMode;
+    addedAt: number;
+    itemId: number;
+    alreadyDispatched?: boolean | undefined;
+    bubbleAdded?: boolean | undefined;
+    images?: Array<{
+        id: string;
+        dataUrl: string;
+        mediaType: string;
+        bytes: number;
+        name?: string | undefined;
+    }> | undefined;
+}
+export interface ToolExecution {
+    id: string;
+    name: string;
+    input?: unknown | undefined;
+    output?: string | undefined;
+    durationMs?: number | undefined;
+    ok: boolean;
+    startedAt: number;
+    completedAt?: number | undefined;
+}
+export interface ChatRetentionBudget {
+    maxMessages?: number;
+    maxBytes?: number;
+    maxFieldChars?: number;
+}
+export interface ChatState {
+    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: QueueMode;
+    } | null;
+    thinkingBuffer: string;
+    thinkingStartedAt: number | null;
+    thinkingLogBuffer: string;
+    thinkingLogStartedAt: number | null;
+    boundSessionId: string | 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;
+    setBoundSessionId: (id: string | null) => 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?: QueueMode, images?: QueuedItem['images'], alreadyDispatched?: boolean) => void;
+    dequeue: () => QueuedItem | null;
+    dequeueDrainable: () => QueuedItem | null;
+    removeQueued: (idx: number) => void;
+    clearQueue: () => void;
+    setRefining: (v: boolean) => void;
+    setPendingRefinement: (text: string | null, images?: Array<{
+        data: string;
+        mime: string;
+    }>, mode?: QueueMode) => 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;
+}
+//# sourceMappingURL=chat-store-types.d.ts.map

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

@@ -1,185 +1,9 @@
-import type { ChatMessage } from './types.js';
-export declare const MAX_CHAT_RETAINED_BYTES: number;
-/**
- * How long a `btw` chip stays visible after entering the "SENT" state
- * (i.e. after the wire-send succeeded at submit time). The chip is removed
- * from the queue automatically after this delay so the user sees the
- * queue → SENT → leave-screen transition instead of the chip getting
- * stuck until the next `run.result` lands. UX spec (2026-08): "shortly
- * after it is processed, the message should leave my screen".
- */
-export declare const BTW_DISPATCH_GRACE_MS = 1800;
-export declare const MAX_CHAT_FIELD_CHARS: number;
-interface ChatRetentionBudget {
-    maxMessages?: number;
-    maxBytes?: number;
-    maxFieldChars?: number;
-}
-export declare function boundChatField(text: string, maxChars?: number): string;
-/** Count limits alone do not protect against giant tool/replay/vision rows. */
-export declare function retainWebChatMessages(messages: readonly ChatMessage[], budget?: ChatRetentionBudget): ChatMessage[];
-/** Submit mode for a queued/typed message. Drives whether the message
- *  interrupts the running agent (`steer`), rides alongside without
- *  interrupting (`btw`), or is held for after the run completes (`queue`). */
-export type QueueMode = 'btw' | 'steer' | 'queue';
-/** One entry in the message queue — the text plus how it was added.
- *  `addedAt` powers the optional sort-by-newest toggle.
- *  `itemId` is a monotonic per-store counter stamped by `enqueue`;
- *  the dispatched-chip grace-timer map and queue-filter operations
- *  key on it instead of `addedAt` so two enqueues sharing the same
- *  millisecond cannot cross-cancel each other. */
-export interface QueuedItem {
-    text: string;
-    mode: QueueMode;
-    addedAt: number;
-    itemId: number;
-    /** True once a `btw` item has already been wire-sent via the mailbox
-     *  (immediate mid-run dispatch). The run.result drain must skip re-sending
-     *  these — they remain in the queue only as a visible "dispatched" chip. */
-    alreadyDispatched?: boolean | undefined;
-    /** Idempotency latch for the drain path. Set by
-     *  `addBubbleFor` in chat-handlers.handleRunResult (drain emits
-     *  a bubble for the popped front chip) and by `dequeueDrainable`
-     *  (drain emits bubbles for every leading dispatched chip it skips
-     *  past). The grace timer callback in `enqueue` *reads* this flag
-     *  to gate bubble emission (`target.bubbleAdded !== true`) — without
-     *  this gate, a second `run.result` landing inside the grace window
-     *  would call `addBubbleFor(front)` a second time and emit a duplicate
-     *  user bubble for the same chip. Reset implicitly on a fresh
-     * `enqueue` (the chip is constructed with `bubbleAdded` undefined).
-     * The flag is the idempotency latch for the drain path; the timer
-     * path reads it but does not write it. */
-    bubbleAdded?: boolean | undefined;
-    /** Image attachments riding with the queued message. Kept as full data
-     *  URLs so the drain path can rebuild the wire payload + local bubble. */
-    images?: Array<{
-        id: string;
-        dataUrl: string;
-        mediaType: string;
-        bytes: number;
-        name?: string | undefined;
-    }> | undefined;
-}
-interface ChatState {
-    messages: ChatMessage[];
-    currentAssistantMessageId: string | null;
-    currentToolId: string | null;
-    isLoading: boolean;
-    abortController: AbortController | null;
-    executions: Map<string, ToolExecution>;
-    toolMessageIdsByUseId: Map<string, string>;
-    /** Messages typed while the agent was running. Drained one-at-a-time
-     *  after run.result lands so the user can stack up follow-ups without
-     *  waiting for each turn to finish. Each item carries the submit mode
-     *  so the queue panel can render the appropriate label. */
-    queue: QueuedItem[];
-    /** Snapshot taken at the start of the current run (first iteration.started
-     *  after idle). Used by run.result to compute the per-turn summary —
-     *  duration is now-at minus this `at`, cost delta is the difference
-     *  between the session's current cost and the cost captured here. Null
-     *  while idle. */
-    runStart: {
-        at: number;
-        cost: number;
-    } | null;
-    /** True while a queued message is being refined (goal-refiner running).
-     *  The UI shows a "Refining..." indicator instead of "loading". */
-    refining: boolean;
-    /** Text and images of a message being refined before entering the queue.
-     *  Set by ChatInput.sendMsg before calling model.refine; consumed by
-     *  handleModelRefineResult to open the RefinePanel for user approval.
-     *  Null when idle or refinement completed. */
-    pendingRefinement: {
-        text: string;
-        images: Array<{
-            data: string;
-            mime: string;
-        }>;
-        mode: QueueMode;
-    } | null;
-    /** Transient extended-thinking buffer. Populated by provider.thinking_delta
-     *  events and shown as a soft, ephemeral bubble below the chat tail while
-     *  the model is reasoning. Cleared the moment the model produces user-
-     *  facing output (text_delta) or starts a tool — and at provider.response /
-     *  run.result. The archive buffer below is what eventually lands in
-     *  `messages`; this live buffer is only for the temporary bubble. */
-    thinkingBuffer: string;
-    /** Wall-clock ms when the current thinking burst started, for the chip's
-     *  elapsed timer. Reset alongside `thinkingBuffer`. */
-    thinkingStartedAt: number | null;
-    /** Full thinking text accumulated for the current iteration. Unlike the
-     *  live chip buffer, this survives text/tool events until iteration end. */
-    thinkingLogBuffer: string;
-    /** Wall-clock ms when the archived thinking text for this iteration began. */
-    thinkingLogStartedAt: number | null;
-    /** Id of the session whose transcript is currently in `messages`. The
-     *  verifier view compares this to the server-reported active session id
-     *  on every `session.start` — a mismatch means the user switched sessions
-     *  without an explicit clear, and we drop the local transcript rather
-     *  than render it. Persisted alongside `messages` so the cross-session
-     *  bleed check survives F5. */
-    boundSessionId: string | null;
-    addMessage: (msg: Omit<ChatMessage, 'id' | 'timestamp'> & {
-        timestamp?: number;
-    }) => string;
-    setMessages: (messages: ChatMessage[]) => void;
-    updateMessage: (id: string, updates: Partial<ChatMessage>) => void;
-    appendToMessage: (id: string, text: string) => void;
-    /** `opts.final` — whether this finalize ends the turn. Pass `false` when the
-     *  message is being closed because a tool call follows: the `<nextsteps>`
-     *  block is still stripped from the body, but the parsed steps are not
-     *  persisted, so no suggestion bar appears mid-turn. Defaults to `true`. */
-    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;
-    /** Bind the current transcript to a session id. See boundSessionId above
-     *  for why this is a separate action. */
-    setBoundSessionId: (id: string | null) => 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?: QueueMode, images?: QueuedItem['images'], alreadyDispatched?: boolean) => void;
-    dequeue: () => QueuedItem | null;
-    dequeueDrainable: () => QueuedItem | null;
-    removeQueued: (idx: number) => void;
-    clearQueue: () => void;
-    setRefining: (v: boolean) => void;
-    setPendingRefinement: (text: string | null, images?: Array<{
-        data: string;
-        mime: string;
-    }>, mode?: QueueMode) => 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;
-}
-interface ToolExecution {
-    id: string;
-    name: string;
-    input?: unknown | undefined;
-    output?: string | undefined;
-    durationMs?: number | undefined;
-    ok: boolean;
-    startedAt: number;
-    completedAt?: number | undefined;
-}
+import type { ChatState } from './chat-store-types';
+export declare const MAX_CHAT_MESSAGES = 1000;
+export declare const MAX_PERSISTED_MESSAGES = 200;
+export * from './chat-store-types';
+export { boundChatField, dedupeRepeatedBlocks, indexToolMessages, MAX_CHAT_FIELD_CHARS, MAX_CHAT_RETAINED_BYTES, retainWebChatMessages, } from './chat-retention';
+export { BTW_DISPATCH_GRACE_MS } from './chat-queue-helpers';
 export declare const useChatStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<ChatState>, "persist" | "setState"> & {
     setState(partial: ChatState | Partial<ChatState> | ((state: ChatState) => ChatState | Partial<ChatState>), replace?: false | undefined): unknown;
     setState(state: ChatState | ((state: ChatState) => ChatState), replace: true): unknown;
@@ -203,5 +27,4 @@ export declare const useChatStore: import("zustand").UseBoundStore<Omit<import("
         }, unknown>>;
     };
 }>;
-export {};
 //# sourceMappingURL=chat-store.d.ts.map

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

@@ -3,6 +3,10 @@ export interface TreeNode {
     path: string;
     type: 'file' | 'directory';
     children?: TreeNode[];
+    /** File size in bytes (files only; undefined for directories). */
+    size?: number;
+    /** Last-modified timestamp in milliseconds since epoch. */
+    lastModified?: number;
 }
 export interface OpenFile {
     path: string;
@@ -12,7 +16,7 @@ export interface OpenFile {
     /** The content last known to be on disk — used for dirty detection. */
     savedContent: string;
 }
-interface FileStoreState {
+export interface FileStoreState {
     /** The project root path as reported by the server. */
     projectRoot: string;
     /** The directory tree structure. */
@@ -25,16 +29,81 @@ interface FileStoreState {
     treeLoading: boolean;
     /** Last error message, if any. */
     error: string | null;
+    /** Target line to jump to in the active editor. */
+    targetLine: {
+        line: number;
+        col?: number | undefined;
+    } | null;
     setTree: (root: string, tree: TreeNode[]) => void;
     openFile: (filePath: string, content: string) => void;
     closeFile: (filePath: string) => void;
     setActiveFile: (filePath: string | null) => void;
+    jumpToLine: (line: number, col?: number) => void;
+    clearTargetLine: () => void;
     updateContent: (filePath: string, content: string) => void;
     /** Mark a file as saved (synced with disk). */
     markSaved: (filePath: string) => void;
     setTreeLoading: (loading: boolean) => void;
     setError: (error: string | null) => void;
+    /** Drop all open tabs (used when the server switches to a different project). */
+    clearOpenTabs: () => void;
+    /**
+     * Canonical absolute project root as reported by the server environment
+     * (working_dir.changed / session env). Distinct from `projectRoot`, which
+     * holds the tree-response display label and can be a cwd-relative label
+     * ("subdir", ".") when browsing a subdirectory — never use that for
+     * identity comparisons.
+     */
+    projectIdentity: string;
+    /** Record the canonical absolute project root (env events only). */
+    setProjectIdentity: (root: string) => void;
+    /** Paths whose rehydrated stub content is currently being fetched. */
+    hydratingPaths: ReadonlySet<string>;
+    /**
+     * Apply fetched content to a rehydrated stub tab. Only applies while the
+     * path is still hydrating AND the tab is still a pristine stub — never
+     * overwrites content the user has started editing, never steals focus.
+     * Returns true when the content was applied.
+     */
+    hydrateFileContent: (filePath: string, content: string) => boolean;
+    /**
+     * Handle a failed hydration read (file deleted or renamed on disk while
+     * the page was closed). Removes the path from hydration tracking and
+     * closes the tab when it is still a pristine stub — leaving it open would
+     * let the next save resurrect a deleted file. A tab the user has started
+     * editing is kept; its save recreates the file intentionally.
+     */
+    hydrateFileFailed: (filePath: string) => void;
 }
-export declare const useFileStore: import("zustand").UseBoundStore<import("zustand").StoreApi<FileStoreState>>;
-export {};
+/** Shape written to localStorage — tabs are paths only, never content. */
+export interface PersistedFileStoreState {
+    openFilePaths: string[];
+    activeFilePath: string | null;
+    /** Canonical absolute project root (env identity), not the display label. */
+    projectIdentity: string;
+}
+/**
+ * Merge persisted (path-only) tab state into the live store on rehydration.
+ *
+ * Tabs are restored as empty-content stubs: trusting cached content across a
+ * reload would silently overwrite changes made on disk while the page was
+ * closed the next time the user saves. The empty stubs are re-fetched via
+ * `files.read` once the server environment is known (see
+ * `reconcileFileTabsAfterEnvChange` in the ws handlers). Exported as a pure
+ * function so the merge contract is unit-testable without zustand internals.
+ */
+export declare function mergePersistedFileStore(persisted: unknown, current: FileStoreState): FileStoreState;
+export declare const useFileStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<FileStoreState>, "persist" | "setState"> & {
+    setState(partial: FileStoreState | Partial<FileStoreState> | ((state: FileStoreState) => FileStoreState | Partial<FileStoreState>), replace?: false | undefined): unknown;
+    setState(state: FileStoreState | ((state: FileStoreState) => FileStoreState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<FileStoreState, PersistedFileStoreState, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: FileStoreState) => void) => () => void;
+        onFinishHydration: (fn: (state: FileStoreState) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<FileStoreState, PersistedFileStoreState, unknown>>;
+    };
+}>;
 //# sourceMappingURL=file-store.d.ts.map