@wrongstack/webui 1.0.24 → 1.0.27

package/dist/components/SettingsPanel/brain-section-options.d.ts

@@ -14,8 +14,7 @@ export declare function councilPersonaOptions(catalog: BrainConfigWire['personaC
 export declare const DECISION_TIMEOUTS: BrainOption[];
 export declare const HUMAN_TIMEOUTS: BrainOption[];
 export declare const FRACTIONS: BrainOption[];
-/** Effective-valued numbers: the snapshot always carries a resolved number, so
- *  the default is a LABELLED concrete option rather than a `default` sentinel. */
+/** `default` = no cap: the model's own output ceiling. */
 export declare const LLM_MAX_TOKENS: BrainOption[];
 export declare const MIN_CONFIDENCE: BrainOption[];
 export declare const DECISION_LOG_SIZES: BrainOption[];

package/dist/components/SettingsPanel/provider-section-types.d.ts

@@ -0,0 +1,79 @@
+import type { WrongStackWebSocketClient } from '@/lib/ws-client';
+export interface CatalogProvider {
+    id: string;
+    name: string;
+    family: string;
+    apiBase?: string | undefined;
+    envVars: string[];
+    modelCount: number;
+    hasApiKey: boolean;
+}
+export interface SavedProvider {
+    id: string;
+    type?: string | undefined;
+    family?: string | undefined;
+    baseUrl?: string | undefined;
+    /** Saved model allowlist, in the order the user pinned them. */
+    models?: string[] | undefined;
+    /** Per-model metadata (display name, output limits, capability overrides). */
+    customModels?: Record<string, {
+        name?: string | undefined;
+        maxOutput?: number | undefined;
+        capabilities?: {
+            maxContext?: number | undefined;
+            tools?: boolean | undefined;
+            vision?: boolean | undefined;
+            reasoning?: boolean | undefined;
+            streaming?: boolean | undefined;
+            jsonMode?: boolean | undefined;
+        } | undefined;
+    }> | undefined;
+    /** First entry of `models`, surfaced for the panel's "Using" line. */
+    pickedModelId?: string | undefined;
+    apiKeys: Array<{
+        label: string;
+        maskedKey: string;
+        isActive: boolean;
+        createdAt: string;
+    }>;
+}
+export type ProviderTab = 'catalog' | 'saved';
+export interface ProviderSectionProps {
+    /** Currently selected provider id. */
+    activeProvider: string;
+    /** Catalog providers list. */
+    catalogProviders: CatalogProvider[];
+    /** Loading flag. */
+    isLoadingCatalog: boolean;
+    /** Saved providers list. */
+    savedProviders: SavedProvider[];
+    /** Loading flag. */
+    isLoadingSaved: boolean;
+    /** Which sub-tab is active. */
+    providerTab: ProviderTab;
+    setProviderTab: (v: ProviderTab) => void;
+    /** Called when a catalog provider is selected. */
+    onSelectProvider: (id: string) => void;
+    /** Called to add an API key. */
+    onAddKey: (providerId: string, label: string, value: string) => Promise<boolean> | void;
+    /** Called to delete an API key. */
+    onDeleteKey: (providerId: string, label: string) => Promise<boolean> | void;
+    /** Called to set a key as active. */
+    onSetActiveKey: (providerId: string, label: string) => Promise<boolean> | void;
+    /** Called to add a custom provider. */
+    onAddProvider: (id: string, family: string, baseUrl?: string | undefined, apiKey?: string, models?: string[] | undefined, customModels?: Record<string, {
+        name?: string | undefined;
+        maxOutput?: number | undefined;
+        capabilities?: Record<string, unknown> | undefined;
+    }> | undefined, providerType?: string | undefined) => Promise<boolean> | void;
+    /** Called to remove a saved provider. */
+    onRemoveProvider: (providerId: string) => Promise<boolean> | void;
+    /** Called when a saved provider model is picked. */
+    onPickProviderModel: (providerId: string, modelId: string) => void;
+    /** WebSocket client used for saved-provider model probing/clearing. */
+    ws: WrongStackWebSocketClient;
+    /** Search filter text. */
+    catalogQuery: string;
+    setCatalogQuery: (v: string) => void;
+}
+//# sourceMappingURL=provider-section-types.d.ts.map

package/dist/components/SidePanel/SessionList.d.ts

@@ -1,7 +1,6 @@
 import type { useWebSocket } from '@/hooks/useWebSocket';
 import type { SessionHistoryEntry } from '@/stores';
-type HistoryFilter = 'all' | 'favorites' | 'active' | 'completed' | 'issues';
-type HistorySort = 'recent' | 'tokens' | 'activity';
+export { filterAndSortSessions, formatCompactNumber, formatRelative, formatSessionDuration, getEmptySessionIds, getSessionHistoryStats, groupSessionHistory, splitSessionHistoryColumns, } from './session-history.js';
 type HistoryListVariant = 'sidebar' | 'workspace';
 interface SessionListProps {
     historyQuery: string;
@@ -16,37 +15,5 @@ interface SessionListProps {
     renameSession: ReturnType<typeof useWebSocket>['renameSession'];
     variant?: HistoryListVariant | undefined;
 }
-interface HistoryViewOptions {
-    query: string;
-    filter: HistoryFilter;
-    sort: HistorySort;
-    favoriteIds: readonly string[];
-}
-interface SessionHistoryGroup {
-    label: 'favorites' | 'today' | 'yesterday' | 'thisWeek' | 'earlier';
-    rows: SessionHistoryEntry[];
-    favorite?: boolean | undefined;
-}
-interface SessionHistoryStats {
-    sessions: number;
-    active: number;
-    tokens: number;
-    tools: number;
-    files: number;
-    errors: number;
-}
-export declare const formatRelative: (iso: string) => string;
-export declare function formatSessionDuration(entry: SessionHistoryEntry): string;
-export declare function formatCompactNumber(value: number): string;
-/** Pure function: returns empty non-active sessions that are safe to offer for cleanup. */
-export declare function getEmptySessionIds(entries: Array<{
-    id: string;
-    tokenTotal: number;
-    isCurrent: boolean;
-}>, protectedIds?: Iterable<string>): string[];
-export declare function filterAndSortSessions(entries: readonly SessionHistoryEntry[], options: HistoryViewOptions): SessionHistoryEntry[];
-export declare function groupSessionHistory(entries: readonly SessionHistoryEntry[], favoriteIds: readonly string[], now?: number): SessionHistoryGroup[];
-export declare function getSessionHistoryStats(entries: readonly SessionHistoryEntry[]): SessionHistoryStats;
 export declare function SessionList({ historyQuery, setHistoryQuery, historyEntries, historyLoading, historyError, wsConnected, listSessions, resumeSession, deleteSession, renameSession, variant, }: SessionListProps): import("react").JSX.Element;
-export {};
 //# sourceMappingURL=SessionList.d.ts.map

package/dist/components/SidePanel/session-history.d.ts

@@ -0,0 +1,61 @@
+import { Activity } from 'lucide-react';
+import type { SessionHistoryEntry } from '@/stores';
+export type HistoryFilter = 'all' | 'favorites' | 'active' | 'completed' | 'issues';
+export type HistorySort = 'recent' | 'tokens' | 'activity';
+export interface HistoryViewOptions {
+    query: string;
+    filter: HistoryFilter;
+    sort: HistorySort;
+    favoriteIds: readonly string[];
+}
+export interface SessionHistoryGroup {
+    label: 'favorites' | 'today' | 'yesterday' | 'thisWeek' | 'earlier';
+    rows: SessionHistoryEntry[];
+    favorite?: boolean | undefined;
+}
+export interface SessionHistoryStats {
+    sessions: number;
+    active: number;
+    tokens: number;
+    tools: number;
+    files: number;
+    errors: number;
+}
+export declare const timestamp: (iso: string | undefined) => number;
+export declare const activityScore: (entry: SessionHistoryEntry) => number;
+export declare const formatRelative: (iso: string) => string;
+export declare const sessionActivityAt: (entry: SessionHistoryEntry) => string;
+export declare function formatSessionDuration(entry: SessionHistoryEntry): string;
+export declare function formatCompactNumber(value: number): string;
+/** Pure function: returns empty non-active sessions that are safe to offer for cleanup. */
+export declare function getEmptySessionIds(entries: Array<{
+    id: string;
+    tokenTotal: number;
+    isCurrent: boolean;
+}>, protectedIds?: Iterable<string>): string[];
+export declare function filterAndSortSessions(entries: readonly SessionHistoryEntry[], options: HistoryViewOptions): SessionHistoryEntry[];
+export declare function groupSessionHistory(entries: readonly SessionHistoryEntry[], favoriteIds: readonly string[], now?: number): SessionHistoryGroup[];
+export interface SessionHistoryColumns {
+    left: SessionHistoryGroup[];
+    right: SessionHistoryGroup[];
+}
+/**
+ * Balance a page of time-ordered groups across the workspace page's two
+ * columns: rows fill the left column down to the midpoint, then continue
+ * down the right, so each column reads chronologically and neither towers
+ * over an empty sibling. A group straddling the midpoint is sliced at it —
+ * that keeps the page one continuous timeline even when a single bucket
+ * (e.g. "Today") dominates, which is the common case on early pages.
+ */
+export declare function splitSessionHistoryColumns(groups: readonly SessionHistoryGroup[]): SessionHistoryColumns;
+export declare function getSessionHistoryStats(entries: readonly SessionHistoryEntry[]): SessionHistoryStats;
+export declare function outcomeMeta(entry: SessionHistoryEntry): {
+    icon: typeof Activity;
+    label: 'active' | 'completed' | 'error' | 'timeout' | 'aborted' | 'saved';
+    defaultLabel: string;
+    className: string;
+};
+export declare function HistoryStats({ stats }: {
+    stats: SessionHistoryStats;
+}): import("react").JSX.Element;
+//# sourceMappingURL=session-history.d.ts.map

package/dist/components/SystemPromptPresetEditor.d.ts

@@ -0,0 +1,9 @@
+type Variant = 'lite' | 'default' | 'pro';
+/** Profile-wide prompt copies. The runtime still owns tool and environment layers. */
+export declare function SystemPromptPresetEditor({ currentVariant, onBusyChange, onDirtyChange, }: {
+    currentVariant: Variant;
+    onBusyChange?: (busy: boolean) => void;
+    onDirtyChange?: (dirty: boolean) => void;
+}): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=SystemPromptPresetEditor.d.ts.map

package/dist/components/TechStackView/AnalyzeControls.d.ts

@@ -0,0 +1,25 @@
+/**
+ * TechStackView — analyze controls.
+ *
+ * The control bar the user picks depth (Inventory / +Advisories / +AI) and
+ * the model id for the next analyze run, before they click "Analyze with AI".
+ *
+ * The depth/model choices live on the store (`selectedDepth` / `selectedModel`)
+ * so a refresh keeps them and so the same controls work in both the empty
+ * "no snapshot" state and the populated state.
+ *
+ * `availableModels` is lazy-loaded via `GET /api/techstack/models`; until the
+ * response lands, the model picker is disabled with a hint that no provider
+ * is wired yet.
+ */
+interface AnalyzeControlsProps {
+    /** Disabled while a job is in flight. */
+    readonly busy: boolean;
+    /** Kick off an `analyze` run with the current depth/model selection. */
+    readonly onAnalyze: () => void;
+    /** Kick off an `inventory`-only run regardless of the depth selector. */
+    readonly onInventory: () => void;
+}
+export declare function AnalyzeControls({ busy, onAnalyze, onInventory }: AnalyzeControlsProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=AnalyzeControls.d.ts.map

package/dist/components/TechStackView/RemediationTab.d.ts

@@ -0,0 +1,20 @@
+/**
+ * TechStackView — Remediation tab.
+ *
+ * Fetches the upgrade plan from `GET /api/techstack/remediation` (which also
+ * returns the dry-run `preview` already executed server-side as `dryRun: true`)
+ * and renders per-item cards:
+ *
+ * - **Executable ecosystems** (npm, python, rust, go, php, dotnet): the card
+ *   has an "Apply" button. Applying calls `POST /api/techstack/remediation/apply`
+ *   with the selected item ids — that endpoint goes through the WebUI server's
+ *   permission-gated `language_package` bridge, the same trust boundary the
+ *   existing remediation-apply handler already enforces.
+ * - **Manual ecosystems** (ruby, dart, maven, gradle, swift, elixir, c/cpp):
+ *   the card shows the suggested shell command and a "Copy" button instead.
+ *
+ * Dry-run is always safe to invoke: `applyPlan()` defaults to `dryRun: true`
+ * (r28 truthfulness) and the server's `preview` is a dry-run by definition.
+ */
+export declare function RemediationTab(): import("react").JSX.Element;
+//# sourceMappingURL=RemediationTab.d.ts.map

package/dist/components/TechStackView/TrendsTab.d.ts

@@ -0,0 +1,17 @@
+/**
+ * TechStackView — Trends tab.
+ *
+ * Renders the cross-snapshot trend report from `GET /api/techstack/trends`:
+ *
+ * - The dependency/outdated/vulnerable curve over the last N snapshots
+ *   (small SVG line chart, no charting library — three series, hand-drawn
+ *   so the file stays dependency-free).
+ * - The top-flickering dependencies: which packages changed versions the
+ *   most across snapshots, with the locked-version age.
+ *
+ * The page is intentionally read-only here: the heavy lifting
+ * (`TrendStore.analyze`) lives server-side, the handler ships a serialized
+ * payload, and the tab renders it.
+ */
+export declare function TrendsTab(): import("react").JSX.Element;
+//# sourceMappingURL=TrendsTab.d.ts.map

package/dist/components/TerminalPanel.d.ts

@@ -4,9 +4,16 @@ import '@xterm/xterm/css/xterm.css';
  * sessions (see server/terminal-ws-handler.ts). It now manages multiple PTYs
  * per project WebUI connection through tabs while keeping the dock itself in
  * the normal flex layout, so the main app remains scrollable.
+ *
+ * Hiding the dock (`hidden`) keeps its terminals running; the composer strip
+ * shows them meanwhile. Closing the last one, or all, disposes the dock.
  */
-export declare function TerminalPanel({ desktopShell, onClose, }: {
+export declare function TerminalPanel({ desktopShell, hidden, onClose, onDispose, }: {
     desktopShell?: boolean | undefined;
+    hidden?: boolean | undefined;
+    /** Hide the dock; its terminals keep running. */
     onClose: () => void;
+    /** Every terminal is closed: the dock can go. */
+    onDispose: () => void;
 }): import("react").JSX.Element;
 //# sourceMappingURL=TerminalPanel.d.ts.map

package/dist/components/WorkspaceDock.d.ts

@@ -1,7 +1,7 @@
 /**
- * WorkspaceDock — the strip between the chat header and the transcript.
+ * WorkspaceDock — session workspace controls in the left Session panel.
  *
- * The dock itself stays compact above chat. Selecting Goal, Fleet, Work,
+ * The dock itself stays compact. Selecting Goal, Fleet, Work,
  * Worktrees, or Collab opens its content in WorkspaceDockInspector on the
  * right, so the transcript never loses vertical space.
  *

package/dist/components/review/ReviewDiff.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ReviewDiff — the Changes view's unified diff with line comments.
+ *
+ * Same row model and look as DiffView (shared `computeLineDiff`), plus a
+ * line-number gutter and a per-line "+" that opens an inline comment editor.
+ * Comments live in the project-scoped review store; a comment whose line no
+ * longer reads the same is listed above the diff as outdated instead of being
+ * pinned to whatever text now occupies that line number.
+ */
+import { type ReviewComment } from '@/stores/review-store';
+export declare function CommentCard({ comment, outdated, }: {
+    comment: ReviewComment;
+    outdated?: boolean | undefined;
+}): import("react").JSX.Element;
+export declare const ReviewDiff: import("react").MemoExoticComponent<({ path, scope, oldText, newText, }: {
+    path: string;
+    scope: string;
+    oldText: string;
+    newText: string;
+}) => import("react").JSX.Element>;
+//# sourceMappingURL=ReviewDiff.d.ts.map

package/dist/components/review/ReviewTray.d.ts

@@ -0,0 +1,15 @@
+/**
+ * ReviewTray — every review comment in the project, grouped by file, with the
+ * two ways out: send the whole review to the chat composer as one message, or
+ * discard it.
+ *
+ * "Send to chat" inserts into the composer rather than submitting, so the
+ * user picks how it goes out (a normal send when idle; queue or `btw` while a
+ * run is going) through the composer's existing send-mode handling.
+ */
+export declare function useScopedReviewComments(scope: string): import("@/stores/review-store").ReviewComment[];
+export declare function ReviewTray({ scope, onOpenFile, }: {
+    scope: string;
+    onOpenFile: (path: string) => void;
+}): import("react").JSX.Element;
+//# sourceMappingURL=ReviewTray.d.ts.map

package/dist/components/review/review-diff-model.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The pure model behind ReviewDiff: line numbers for diff rows, where a
+ * comment anchors, and which comments still sit on the line they were
+ * written against.
+ */
+import type { DiffRow } from '@wrongstack/tools/tool-diff';
+import type { ReviewComment } from '@/stores/review-store';
+export interface NumberedDiffRow extends DiffRow {
+    oldLine?: number | undefined;
+    newLine?: number | undefined;
+}
+/**
+ * Attach 1-based line numbers: context lines advance both sides, removals the
+ * old side, additions the new side.
+ */
+export declare function numberDiffRows(rows: readonly DiffRow[]): NumberedDiffRow[];
+/** Where a comment on this row anchors: removed lines on the old side, the rest on the new. */
+export declare function anchorFor(row: NumberedDiffRow): {
+    side: 'old' | 'new';
+    line: number;
+} | null;
+export declare const anchorKey: (side: 'old' | 'new', line: number) => string;
+/**
+ * Split a file's comments into those still sitting on an identical line
+ * (keyed by anchor) and those whose line changed underneath them.
+ */
+export declare function placeComments(rows: readonly NumberedDiffRow[], comments: readonly ReviewComment[]): {
+    byAnchor: Map<string, ReviewComment[]>;
+    outdated: ReviewComment[];
+};
+//# sourceMappingURL=review-diff-model.d.ts.map

package/dist/components/use-code-map-flow.d.ts

@@ -0,0 +1,25 @@
+import '@xyflow/react/dist/style.css';
+export declare function useCodeMapFlow({ positionedNodes, deferredActiveOperations, deferredPulseActivities, selectedId, connected, incomingCounts, outgoingCounts, handleSelectNode, handleOpenNode, setHistoryFile, setFlowNodes, canvasGraph, deferredRecentActivities, setAgentTrailCount, setFlowEdges, fitSignature, lastFlowStructuralKey, flowRebuildTimer, lastFitSignature, fitView, activityFlowKey, }: {
+    positionedNodes: ReturnType<typeof import('./codemap-model.js').layoutGraph>;
+    deferredActiveOperations: import('../stores/codemap-activity-store.js').FileActivity[];
+    deferredPulseActivities: import('../stores/codemap-activity-store.js').FileActivity[];
+    selectedId: string | null;
+    connected: Set<string>;
+    incomingCounts: Map<string, number>;
+    outgoingCounts: Map<string, number>;
+    handleSelectNode: (node: import('./codemap-model.js').GraphNodeData) => void;
+    handleOpenNode: (node: import('./codemap-model.js').GraphNodeData) => void;
+    setHistoryFile: React.Dispatch<React.SetStateAction<string | null>>;
+    setFlowNodes: React.Dispatch<React.SetStateAction<import('@xyflow/react').Node[]>>;
+    canvasGraph: import('./codemap-model.js').CodeMapGraphResponse;
+    deferredRecentActivities: import('../stores/codemap-activity-store.js').FileActivity[];
+    setAgentTrailCount: React.Dispatch<React.SetStateAction<number>>;
+    setFlowEdges: React.Dispatch<React.SetStateAction<import('@xyflow/react').Edge[]>>;
+    fitSignature: string;
+    lastFlowStructuralKey: React.RefObject<string>;
+    flowRebuildTimer: React.RefObject<number | null>;
+    lastFitSignature: React.RefObject<string>;
+    fitView: import('@xyflow/react').FitView<import('@xyflow/react').Node>;
+    activityFlowKey: string;
+}): void;
+//# sourceMappingURL=use-code-map-flow.d.ts.map

package/dist/components/use-office-map-canvas.d.ts

@@ -1,6 +1,6 @@
 import { type Connection, type Edge, type Node } from '@xyflow/react';
 import '@xyflow/react/dist/style.css';
-import { type OfficeNodeData } from './OfficeMapCanvas/utils.js';
+import type { OfficeNodeData } from './OfficeMapCanvas/utils.js';
 export declare function useOfficeMapCanvas(): {
     canvasRef: import("react").RefObject<HTMLDivElement | null>;
     showHud: boolean;

package/dist/components/use-office-map-topology.d.ts

@@ -0,0 +1,31 @@
+import type { TFunction } from 'i18next';
+import '@xyflow/react/dist/style.css';
+export declare function useOfficeMapTopology({ clients, canvasSize, mailboxMessages, t, leaderId, fleetAgents, prevAgentStatsRef, activeNodesRef, ACTIVE_MS, vizActivityRef, edgeIntensitiesRef, layoutPosRef, setNodes, setEdges, prevNodeSigRef, fitView, session, }: {
+    clients: import('./OfficeMapCanvas/resolve.js').ResolvedClient[];
+    canvasSize: {
+        width: number;
+        height: number;
+    };
+    mailboxMessages: import('../stores/mailbox-store.js').MailboxMessage[];
+    t: TFunction<'translation', undefined>;
+    leaderId: string | undefined;
+    fleetAgents: Map<string, import('../stores/types.js').SubagentView>;
+    prevAgentStatsRef: React.RefObject<Map<string, {
+        toolCalls: number;
+        iteration: number;
+    }>>;
+    activeNodesRef: React.RefObject<Map<string, number>>;
+    ACTIVE_MS: 4000;
+    vizActivityRef: React.RefObject<Map<string, number>>;
+    edgeIntensitiesRef: React.RefObject<Map<string, number>>;
+    layoutPosRef: React.RefObject<Map<string, {
+        x: number;
+        y: number;
+    }>>;
+    setNodes: React.Dispatch<React.SetStateAction<import('@xyflow/react').Node<import('./OfficeMapCanvas/utils.js').OfficeNodeData>[]>>;
+    setEdges: React.Dispatch<React.SetStateAction<import('@xyflow/react').Edge[]>>;
+    prevNodeSigRef: React.RefObject<string>;
+    fitView: import('@xyflow/react').FitView<import('@xyflow/react').Node>;
+    session: import('../stores/types.js').SessionInfo | null;
+}): void;
+//# sourceMappingURL=use-office-map-topology.d.ts.map

package/dist/hooks/use-live-browser.d.ts

@@ -0,0 +1,7 @@
+export interface LiveBrowserSession {
+    id: string;
+    url: string;
+    title: string;
+}
+export declare function useLiveBrowserSessions(): LiveBrowserSession[];
+//# sourceMappingURL=use-live-browser.d.ts.map

package/dist/hooks/useWebSocket.d.ts

@@ -21,7 +21,7 @@ export declare function useWebSocketBootstrap(): void;
 export declare function useWebSocket(): {
     client: WrongStackWebSocketClient;
     sendMessage: (content: string, images?: import('@/types').WSUserMessageImage[], freshContext?: boolean) => string | null;
-    adviseTopic: (prompt: string) => Promise<import("@/types").SessionScopedPayload & {
+    adviseTopic: (prompt: string) => Promise<import("@wrongstack/webui-protocol").SessionScopedPayload & {
         requestId: string;
         suggestNewContext: boolean;
         confidence: number;
@@ -131,7 +131,6 @@ export declare function useWebSocket(): {
     }) => void;
     deleteContextMode: (id: string) => void;
     repairContext: () => void;
-    toggleGoalAutonomous: (autonomous: boolean) => void;
     startGoal: (title: string, phases?: unknown[] | undefined, autonomous?: boolean) => void;
     pauseGoal: () => void;
     resumeGoal: () => void;

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

@@ -1,5 +1,17 @@
 import type { WSServerMessage } from '@/types';
 export declare const chatHandlerMap: Partial<Record<string, (msg: WSServerMessage) => void>>;
+/**
+ * A run a provider killed after its own retries, on a failure a later attempt
+ * usually gets through: a `PROVIDER_*` code the provider marked recoverable
+ * (rate limit, overload, 5xx, dropped connection). The only run failure the
+ * Continue countdown may auto-fire for. A recoverable non-provider failure is
+ * not one — a context overflow would overflow again, and the loop guard or
+ * iteration limit stopped the run on purpose.
+ */
+export declare function isAutoContinuableRunError(error: {
+    code?: string | undefined;
+    recoverable?: boolean | undefined;
+} | undefined): boolean;
 /** Forget a retired lane's run bookkeeping. */
 export declare function forgetLaneRunState(sessionId: string): void;
 export declare function handleIterationStarted(msg: WSServerMessage): void;

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

@@ -4,4 +4,6 @@ export declare function handleGoalProgress(msg: WSServerMessage): void;
 export declare function handleGoalLifecycle(msg: WSServerMessage): void;
 export declare function handleGoalList(msg: WSServerMessage): void;
 export declare function handleGoalUpdated(msg: WSServerMessage): void;
+export declare function handleGoalRefining(msg: WSServerMessage): void;
+export declare function handleGoalStateError(msg: WSServerMessage): void;
 //# sourceMappingURL=goal-handlers.d.ts.map

package/dist/hooks/ws-handlers/mcp-status-handlers.d.ts

@@ -0,0 +1,6 @@
+import type { WSServerMessage } from '@/types';
+export declare function handleMcpServerDisconnected(msg: WSServerMessage): void;
+export declare function handleMcpServerUp(msg: WSServerMessage): void;
+/** Test seam: forget which servers were reported down. */
+export declare function _resetMcpStatusHandlersForTests(): void;
+//# sourceMappingURL=mcp-status-handlers.d.ts.map

package/dist/hooks/ws-handlers/prompt-queue-handlers.d.ts

@@ -0,0 +1,18 @@
+import type { WSServerMessage } from '@/types';
+export declare function removeServerQueuedPrompt(sessionId: string, id: string): void;
+export declare function clearServerQueue(sessionId: string): void;
+/**
+ * Ask for a session's queue when the session starts on this connection — the
+ * moment the capability is known. Opening the session is also the server's cue
+ * to run whatever a previous host left queued.
+ */
+export declare function requestPromptQueue(msg: WSServerMessage): void;
+declare function handleQueueState(msg: WSServerMessage): void;
+/** A queued prompt started its turn: it becomes the user's message in the transcript. */
+declare function handleQueueDrained(msg: WSServerMessage): void;
+export declare const promptQueueHandlerMap: {
+    'queue.state': typeof handleQueueState;
+    'queue.drained': typeof handleQueueDrained;
+};
+export {};
+//# sourceMappingURL=prompt-queue-handlers.d.ts.map

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

@@ -6,5 +6,12 @@ export declare function handleTechStackSnapshotUpdated(msg: WSServerMessage): vo
 export declare function handleTechStackReportReady(msg: WSServerMessage): void;
 export declare function handleTechStackJobFailed(msg: WSServerMessage): void;
 export declare function handleTechStackJobCancelled(msg: WSServerMessage): void;
+/**
+ * `techstack.research.partial` — the server forwards dependency-scoped
+ * research progress (not cluster-level updates) as a streaming event.
+ * Valid partials update the store's deep-dive progress; general job progress
+ * continues to arrive separately on `techstack.job.progress`.
+ */
+export declare function handleTechStackResearchPartial(msg: WSServerMessage): void;
 export declare const techStackHandlerMap: Partial<Record<WSServerMessage['type'], (msg: WSServerMessage) => void>>;
 //# sourceMappingURL=techstack-handlers.d.ts.map