@wrongstack/tui 1.0.24 → 1.0.27

package/dist/components/status-bar-types.d.ts

@@ -102,6 +102,19 @@ export interface StatusBarProps {
      * for callers that pass a combined string).
      */
     provider?: string | undefined;
+    /**
+     * Active reasoning-effort level (e.g. "high"), rendered as a suffix INSIDE
+     * the model chip (`provider/model · high`) rather than as a chip of its own:
+     * it qualifies the model, so the density ladder sheds it with the model at
+     * overflow instead of spending a separate statusline slot on it. Shown at
+     * the `full` and `short` density levels; `micro` drops it so the bottom rung
+     * stays strictly narrower than the one above it. NOT rendered in minimum
+     * mode — see `buildMinimumChips` for why that rail omits the qualifier.
+     *
+     * Omitted when the host has no effort to report — the chip then renders
+     * byte-for-byte as it did before, so legacy callers and tests are unaffected.
+     */
+    effort?: string | undefined;
     /**
      * App version string (e.g. "0.7.0"). Rendered as a right-anchored version
      * chip on the status bar (line 1, and the minimum-mode rail) so it stays
@@ -125,6 +138,12 @@ export interface StatusBarProps {
      * orange update notice on the status bar.
      */
     updateAvailable?: boolean | undefined;
+    /**
+     * A newer standalone build downloaded and waiting to be swapped in when
+     * the session exits. Replaces the "(update v…)" suffix, since there is
+     * nothing left to run: a restart picks it up.
+     */
+    updateReadyVersion?: string | undefined;
     state: 'idle' | 'running' | 'streaming' | 'aborting';
     /** Single word rendered in the rainbow working-state chip. */
     thinkingWord?: string | undefined;

package/dist/components/status-bar.d.ts

@@ -22,5 +22,5 @@ export type { BrainStatusChip, ContextWindow, FleetAgentDetail, FleetCounts, Mai
  * the rendered entries themselves, so an empty rail never renders and a
  * vanilla session keeps its two-line footprint.
  */
-export declare const StatusBar: React.MemoExoticComponent<({ model, provider, version, latestVersion, updateAvailable, state, thinkingWord, thinkingAnimationStyle, tokenCounter, hint, queueCount, yolo, autonomy, fleetWorkingTime, todos, plan, tasks, fleet, fleetAgents, git, subagentCount, brain, projectName, workingDir, processCount, context, estimatedContextTokens, Sage, memoryContextMonitor, contextStrategy, hiddenItems, statuslineLines, statuslineDensities, statuslineOrder, mode, events, sessionId, eternalStage, goalSummary, droppedTools, indexState, breakerCountdown, modeLabel, promptVariant, themeName, debugStreamStats, enhanceCountdown, nextStepsAutoSubmitCountdown, nextStepsAutoSubmitLabel, autoProceedCountdown, sessionCount, mailbox, tokenSavingMode, toolCount, visibleChips, sideEffectCount, maxWidth, clickMapRef, }: StatusBarProps) => React.ReactElement>;
+export declare const StatusBar: React.MemoExoticComponent<({ model, provider, effort, version, latestVersion, updateAvailable, updateReadyVersion, state, thinkingWord, thinkingAnimationStyle, tokenCounter, hint, queueCount, yolo, autonomy, fleetWorkingTime, todos, plan, tasks, fleet, fleetAgents, git, subagentCount, brain, projectName, workingDir, processCount, context, estimatedContextTokens, Sage, memoryContextMonitor, contextStrategy, hiddenItems, statuslineLines, statuslineDensities, statuslineOrder, mode, events, sessionId, eternalStage, goalSummary, droppedTools, indexState, breakerCountdown, modeLabel, promptVariant, themeName, debugStreamStats, enhanceCountdown, nextStepsAutoSubmitCountdown, nextStepsAutoSubmitLabel, autoProceedCountdown, sessionCount, mailbox, tokenSavingMode, toolCount, visibleChips, sideEffectCount, maxWidth, clickMapRef, }: StatusBarProps) => React.ReactElement>;
 //# sourceMappingURL=status-bar.d.ts.map

package/dist/components/statusline-picker-model.d.ts

@@ -0,0 +1,45 @@
+import { CHIP_DESCRIPTIONS, DEFAULT_LINES, STATUSLINE_FIELD_COUNT, STATUSLINE_ITEMS, type StatuslineDensity, type StatuslineItem, type StatuslineLines, type StatuslineOrder } from '@wrongstack/core/statusline';
+import type { ChipMeta } from '../ui-contracts.js';
+export type { StatuslineItem };
+export { CHIP_DESCRIPTIONS, DEFAULT_LINES, DEFAULT_LINES as ITEM_LINE, STATUSLINE_FIELD_COUNT, STATUSLINE_ITEMS, };
+/**
+ * Chips the composer's top rail already renders, so the status bar suppresses
+ * them to avoid a double display. They stay in `STATUSLINE_ITEMS` (the mouse
+ * hit-test indexes by position) and stay togglable — the picker just labels
+ * them so their "on" state doesn't read as a lie.
+ */
+export declare const COMPOSER_OWNED_CHIPS: StatuslineItem[];
+/**
+ * Metadata for a temporarily-visible chip (one that appeared due to data,
+ * not user toggle). Tracked so the chip can auto-expire.
+ *
+ * Declared in the `ui-contracts` leaf and re-exported here under the picker's
+ * historical name: `status-bar-types.ts` needs the type, and owning it in a
+ * `.tsx` view module put the contracts leaf and the view in one type cycle.
+ */
+export type { ChipMeta };
+/** Default expiration for stream-triggered chips (5 minutes). */
+export declare const STREAM_CHIP_EXPIRES_IN_MINUTES = 5;
+/**
+ * Returns true if a chip with the given metadata has expired.
+ * Chips with no `expiresIn` never expire on their own.
+ */
+export declare function isChipExpired(meta: ChipMeta, now?: number): boolean;
+/**
+ * Returns a human-readable countdown label for a chip with expiration.
+ * Returns null if the chip has no expiration or has already expired.
+ */
+export declare function getExpiresInLabel(meta: ChipMeta, now?: number): string | null;
+/** Stream-triggered chips — these auto-expire unless toggled on permanently. */
+export declare const STREAM_CHIP_KEYS: StatuslineItem[];
+/** Next density in the cycle: auto → full → short → micro → auto. */
+export declare function nextDensity(current: StatuslineDensity, delta?: number): StatuslineDensity;
+/**
+ * Whether `item` survives the picker's text filter. Matches the chip key and
+ * its description so "cost" finds `cost` and "cache" finds the cache chip by
+ * either its name or its blurb.
+ */
+export declare function matchesFilter(item: StatuslineItem, filter: string): boolean;
+/** Shared visual/keyboard order: effective line groups, then saved order within each line. */
+export declare function navigableFields(filter: string, order?: StatuslineOrder, lines?: StatuslineLines): number[];
+//# sourceMappingURL=statusline-picker-model.d.ts.map

package/dist/components/statusline-picker.d.ts

@@ -1,47 +1,8 @@
-import { CHIP_DESCRIPTIONS, DEFAULT_LINES, STATUSLINE_FIELD_COUNT, STATUSLINE_ITEMS, type StatuslineDensities, type StatuslineDensity, type StatuslineItem, type StatuslineLine, type StatuslineLines, type StatuslineOrder } from '@wrongstack/core/statusline';
+import { type StatuslineDensities, type StatuslineItem, type StatuslineLine, type StatuslineLines, type StatuslineOrder } from '@wrongstack/core/statusline';
 import type React from 'react';
 import type { ChipMeta } from '../ui-contracts.js';
 import type { StatusBarClickMap } from './status-bar-types.js';
-export type { StatuslineItem };
-export { CHIP_DESCRIPTIONS, DEFAULT_LINES, DEFAULT_LINES as ITEM_LINE, STATUSLINE_FIELD_COUNT, STATUSLINE_ITEMS, };
-/**
- * Chips the composer's top rail already renders, so the status bar suppresses
- * them to avoid a double display. They stay in `STATUSLINE_ITEMS` (the mouse
- * hit-test indexes by position) and stay togglable — the picker just labels
- * them so their "on" state doesn't read as a lie.
- */
-export declare const COMPOSER_OWNED_CHIPS: StatuslineItem[];
-/**
- * Metadata for a temporarily-visible chip (one that appeared due to data,
- * not user toggle). Tracked so the chip can auto-expire.
- *
- * Declared in the `ui-contracts` leaf and re-exported here under the picker's
- * historical name: `status-bar-types.ts` needs the type, and owning it in a
- * `.tsx` view module put the contracts leaf and the view in one type cycle.
- */
-export type { ChipMeta };
-/** Default expiration for stream-triggered chips (5 minutes). */
-export declare const STREAM_CHIP_EXPIRES_IN_MINUTES = 5;
-/**
- * Returns true if a chip with the given metadata has expired.
- * Chips with no `expiresIn` never expire on their own.
- */
-export declare function isChipExpired(meta: ChipMeta, now?: number): boolean;
-/**
- * Returns a human-readable countdown label for a chip with expiration.
- * Returns null if the chip has no expiration or has already expired.
- */
-export declare function getExpiresInLabel(meta: ChipMeta, now?: number): string | null;
-/** Next density in the cycle: auto → full → short → micro → auto. */
-export declare function nextDensity(current: StatuslineDensity, delta?: number): StatuslineDensity;
-/**
- * Whether `item` survives the picker's text filter. Matches the chip key and
- * its description so "cost" finds `cost` and "cache" finds the cache chip by
- * either its name or its blurb.
- */
-export declare function matchesFilter(item: StatuslineItem, filter: string): boolean;
-/** Shared visual/keyboard order: effective line groups, then saved order within each line. */
-export declare function navigableFields(filter: string, order?: StatuslineOrder, lines?: StatuslineLines): number[];
+export * from './statusline-picker-model.js';
 interface StatuslinePickerProps {
     /** Focused field index into STATUSLINE_ITEMS. */
     field: number;

package/dist/components/theme-picker.d.ts

@@ -1,5 +1,5 @@
 import type React from 'react';
-import type { ThemeName, ThemePickerOption } from '../theme.js';
+import { type ThemeName, type ThemePickerOption } from '../theme.js';
 interface ThemePickerProps {
     options: readonly ThemePickerOption[];
     selected: number;
@@ -22,6 +22,8 @@ interface ThemePickerProps {
      * budget is too small for it to be useful.
      */
     maxRows?: number | undefined;
+    /** Type-to-filter query. An empty string renders the full catalogue. */
+    filter?: string | undefined;
 }
 /**
  * Interactive theme picker. Mirrors the autonomy-picker visual pattern
@@ -30,17 +32,27 @@ interface ThemePickerProps {
  * highlighted with a `[active]` marker so the user can see whether
  * their selection will actually change anything.
  *
- * The list is windowed via {@link useWindowedPicker} so 15+ presets stay
- * usable on small terminals — a top-aligned `…` marker appears when the
- * focused row is below the start of the visible window.
- *
- * On wide terminals the picker splits into two panes: the windowed list on
+ * On wide terminals the picker splits into two panes: the list on
  * the left and a live {@link ThemePreview} on the right that renders the
  * *focused* preset's palette from its frozen snapshot. Navigating with ↑/↓
  * re-renders the preview; Enter alone applies the theme. The description
  * column is dropped from list rows in split mode — it moves into the
  * preview header, which is what frees the list to show more rows.
+ *
+ * Three things the flat-list version did not have:
+ *
+ *   - **Type-to-filter.** Printable keys narrow the list on name, id and
+ *     description. `selected` is an index into the FILTERED list, so the
+ *     window, the preview, and Enter all resolve through the same
+ *     `filterThemeOptions` call.
+ *   - **Family headers.** Related presets (Catppuccin ×4, Tokyo Night ×3)
+ *     sit under one header, so a family is reachable without scrolling past
+ *     60 unrelated rows. Headers are real rows and are counted against
+ *     `maxRows` by {@link windowThemeRows}.
+ *   - **Inline swatches.** Each row carries a six-chip palette sample, so
+ *     the list is still informative on the narrow terminals that get no
+ *     preview pane at all.
  */
-export declare function ThemePicker({ options, selected, activeId, hint, columns, maxRows, }: ThemePickerProps): React.ReactElement;
+export declare function ThemePicker({ options, selected, activeId, hint, columns, maxRows, filter, }: ThemePickerProps): React.ReactElement;
 export {};
 //# sourceMappingURL=theme-picker.d.ts.map

package/dist/connections-health.d.ts

@@ -17,6 +17,7 @@ export interface ConnectionHealthService {
     required: boolean;
     mode: string;
     detail: string;
+    versionMismatch?: boolean;
     ownerPid?: number | undefined;
     endpoint?: string | undefined;
     storage?: string | undefined;

package/dist/connections-slash.d.ts

@@ -5,8 +5,8 @@ interface ConnectionsSlashDeps {
     } | undefined;
 }
 /**
- * TUI `/connections` — panel-first. Bare `/connections` (and `open` / `--open`)
- * opens the interactive service health panel and emits nothing to chat history.
+ * Bare `/connections` opens the panel; `restart` runs the same daemon actions
+ * directly and reports each result in chat.
  */
 export declare function createConnectionsSlashCommand(deps: ConnectionsSlashDeps): SlashCommand;
 export {};

package/dist/hit-test.d.ts

@@ -41,9 +41,9 @@ type HitRegion =
 };
 /**
  * Columns at the right edge of the history viewport reserved for the rail.
- * Layout: copy · gap · inspect · selection band · scrollbar track.
+ * Layout: copy · gap · inspect · three-cell spacer · selection band · scrollbar track.
  */
-export declare const SCROLLBAR_HIT_WIDTH = 5;
+export declare const SCROLLBAR_HIT_WIDTH = 8;
 /** Rows available to managed history after reserving the measured bottom UI. */
 export declare function historyViewportRows(termRows: number, bottomHeight: number): number;
 /**

package/dist/hooks/failed-run-tracker.d.ts

@@ -0,0 +1,30 @@
+import type { AppProps } from '../app-props.js';
+/**
+ * The prompt the auto-proceed loop sends after a run an API error killed.
+ * The run's own work is still in the transcript, so it asks to carry on, not
+ * to start over, and to stop rather than guess when it cannot tell where it was.
+ */
+export declare const FAILED_RUN_CONTINUE_PROMPT: string;
+export interface FailedRunTracker {
+    /** True when the last leader run died on a retryable provider failure. */
+    pending(): boolean;
+    /** Take the pending failure (the auto-proceed loop is acting on it). */
+    consume(): boolean;
+    dispose(): void;
+}
+type Events = NonNullable<AppProps['agent']>['events'];
+/**
+ * Watches the leader's runs for the one ending auto-proceed can recover: a
+ * run that `failed` after a provider call gave up on a *retryable* error
+ * (overload, dropped connection, 5xx) — the kind a later attempt usually
+ * gets through. A non-retryable failure (bad request, auth, context overflow)
+ * would fail the same way again and is never offered. A successful response
+ * after the error (the fallback chain found a working model) clears it; so
+ * does every new run, manual or automatic.
+ *
+ * Events carrying another session's id (a subagent on the same bus) are
+ * ignored: only the leader's run decides what the leader does next.
+ */
+export declare function createFailedRunTracker(events: Events, leaderSessionId: () => string | undefined): FailedRunTracker;
+export {};
+//# sourceMappingURL=failed-run-tracker.d.ts.map

package/dist/hooks/fork-at-checkpoint.d.ts

@@ -0,0 +1,25 @@
+import type { Action } from '../app-action-type.js';
+export interface ForkAtCheckpointDeps {
+    /** Host fork: branches `sessionId` at the checkpoint and returns the new id. */
+    forkSession: (sessionId: string, checkpointPromptIndex: number) => Promise<{
+        id: string;
+    }>;
+    /** The prompt recorded for the checkpoint (see `DefaultSessionRewinder.promptAt`). */
+    promptAt: (sessionId: string, checkpointPromptIndex: number) => Promise<string | undefined>;
+    /** The resume flow the /resume picker runs. */
+    resume: (sessionId: string, label: string) => Promise<void>;
+    /** The session the agent is on now; tells whether the resume attached the fork. */
+    currentSessionId: () => string | undefined;
+    dispatch: (action: Action) => void;
+}
+/**
+ * Fork the current session at a checkpoint and switch to the fork: the
+ * conversation up to that prompt continues in a new session, the original
+ * stays as it was, and the prompt is back in the composer to edit and send.
+ */
+export declare function forkAtCheckpoint(deps: ForkAtCheckpointDeps, request: {
+    sessionId: string;
+    promptIndex: number;
+    draft: string;
+}): Promise<void>;
+//# sourceMappingURL=fork-at-checkpoint.d.ts.map

package/dist/hooks/tui-slash-command-options.d.ts

@@ -26,5 +26,14 @@ export interface TuiSlashCommandOptions {
     switchAutonomy: AppProps['switchAutonomy'];
     listSessions: AppProps['listSessions'];
     openPromptPicker: () => Promise<void>;
+    /**
+     * Live ConfigStore + the persist callback, threaded here so `/theme <preset>`
+     * can apply a named preset directly instead of only opening the picker. Both
+     * are optional: without them the command still opens the picker, it just
+     * cannot persist an immediate apply.
+     */
+    configStore?: import('@wrongstack/core/types').ConfigStore | undefined;
+    saveThemePreset?: AppProps['saveThemePreset'];
+    applyThemePreset?: ((preset: import('@wrongstack/core/types').ThemePresetId) => void) | undefined;
 }
 //# sourceMappingURL=tui-slash-command-options.d.ts.map

package/dist/hooks/use-app-execution-pipeline.d.ts

@@ -12,7 +12,7 @@ export interface AppExecutionPipelineArgs {
         current: ReturnType<typeof createRunBlocksController>;
     };
     submitRef: {
-        current: any;
+        current: (text?: string) => void;
     };
 }
 export declare function useAppExecutionPipeline(args: AppExecutionPipelineArgs): {

package/dist/hooks/use-app-picker-keys.d.ts

@@ -1,4 +1,4 @@
-import type { PromptUsageStore } from '@wrongstack/core/storage';
+import { type PromptUsageStore } from '@wrongstack/core/storage';
 import type { Dispatch, MutableRefObject } from 'react';
 import type { Action } from '../app-action-type.js';
 import type { AppProps } from '../app-props.js';
@@ -12,6 +12,8 @@ import type { useStatusbarViewModel } from './use-statusbar-view-model.js';
 import type { useTuiEnvironmentState } from './use-tui-environment-state.js';
 interface UseAppPickerKeysOptions {
     sessionGenerationRef?: MutableRefObject<number> | undefined;
+    /** Move the input queue to a resumed session (see `useQueueManager`). */
+    switchQueueSession?: ((sessionId: string) => void) | undefined;
     host: AppProps;
     state: State;
     dispatch: Dispatch<Action>;
@@ -35,8 +37,9 @@ interface UseAppPickerKeysOptions {
     statuslineHiddenForPicker: () => StatuslineItem[];
     onPickerEnter: () => Promise<void>;
     onThemePickerEnter?: () => void;
+    onThemePickerUndo?: () => void;
     setPromptFavorite: (slug: string, favorite: boolean) => Promise<void>;
 }
-export declare function useAppPickerKeys({ sessionGenerationRef, host, state, dispatch, environment, statusbar, panelControllers, authPanelController, brainController, lastEnterAtRef, inputGateRef, submitRef, promptUsageRef, setDraft, acceptSlashPickerSelection, changeBrainRisk, handleModelPicked, handleShadowStart, handleShadowStop, subagentModelsController, statuslineHiddenForPicker, onPickerEnter, onThemePickerEnter, setPromptFavorite, }: UseAppPickerKeysOptions): (input: string, key: import("../components/input.js").KeyEvent, isEnter: boolean) => boolean;
+export declare function useAppPickerKeys({ sessionGenerationRef, switchQueueSession, host, state, dispatch, environment, statusbar, panelControllers, authPanelController, brainController, lastEnterAtRef, inputGateRef, submitRef, promptUsageRef, setDraft, acceptSlashPickerSelection, changeBrainRisk, handleModelPicked, handleShadowStart, handleShadowStop, subagentModelsController, statuslineHiddenForPicker, onPickerEnter, onThemePickerEnter, onThemePickerUndo, setPromptFavorite, }: UseAppPickerKeysOptions): (input: string, key: import("../components/input.js").KeyEvent, isEnter: boolean) => boolean;
 export {};
 //# sourceMappingURL=use-app-picker-keys.d.ts.map

package/dist/hooks/use-chip-staleness-guard.d.ts

@@ -41,6 +41,12 @@ interface UseChipStalenessGuardOptions {
     agentState: 'idle' | 'running' | 'streaming' | 'aborting';
     /** Current spinner phase index (advances every SPINNER_INTERVAL_MS while active). */
     spinnerPhase: number;
+    /**
+     * False while the spinner is deliberately still (the `static` animation
+     * style / reduced motion): a still spinner is then not a frozen one.
+     * Default true.
+     */
+    spinnerAnimated?: boolean;
     /** Token usage fingerprint — changes when new token events arrive. */
     tokenFingerprint: string;
     /** Context usage ratio (0..1) — changes as context grows. */

package/dist/hooks/use-core-tui-commands.d.ts

@@ -1,10 +1,12 @@
 import type { Director } from '@wrongstack/core/coordination';
+import type { RedoRewindResult } from '@wrongstack/core/storage';
 import { type Dispatch, type MutableRefObject, type SetStateAction } from 'react';
 import type { Action } from '../app-action-type.js';
 import type { AppProps } from '../app-props.js';
 import type { State } from '../app-state.js';
 import { createCronJobsGetter } from '../cron-slash.js';
 import type { MemoryContextMonitorState } from '../memory-context-monitor.js';
+import type { RewindOutcome } from './use-session-rewind.js';
 interface CoreTuiCommandsOptions {
     agent: AppProps['agent'];
     slashRegistry: AppProps['slashRegistry'];
@@ -25,10 +27,13 @@ interface CoreTuiCommandsOptions {
     liveDirector: () => Director | null | undefined;
     streamingTextRef: MutableRefObject<string>;
     director: AppProps['director'];
-    handleRewindTo: (index: number) => Promise<void>;
+    handleRewindTo: (index: number) => Promise<RewindOutcome>;
+    /** `/rewind redo`: undo the newest rewind. */
+    handleRewindRedo: () => Promise<RedoRewindResult | null>;
+    getSettings?: AppProps['getSettings'] | undefined;
 }
 /** Registers process/context/kanban/steer/rewind/agents commands. */
-export declare function useCoreTuiCommands({ agent, slashRegistry, memoryStore, onPanelOpen, memoryContextMonitorRef, memoryRecordTotalRef, stateRef, boardFocusRef, setFocusedBoardId, terminalWidth, getModeLabel, activeCtrlRef, clearPendingConfirms, dispatch, liveDirector, streamingTextRef, director, handleRewindTo, }: CoreTuiCommandsOptions): {
+export declare function useCoreTuiCommands({ agent, slashRegistry, memoryStore, onPanelOpen, memoryContextMonitorRef, memoryRecordTotalRef, stateRef, boardFocusRef, setFocusedBoardId, terminalWidth, getModeLabel, activeCtrlRef, clearPendingConfirms, dispatch, liveDirector, streamingTextRef, director, handleRewindTo, handleRewindRedo, getSettings, }: CoreTuiCommandsOptions): {
     getCronJobs: ReturnType<typeof createCronJobsGetter>;
     runSteerSequence: (text: string) => {
         preamble: string;

package/dist/hooks/use-file-search.d.ts

@@ -19,6 +19,16 @@ export declare function detectAtToken(buffer: string, cursor: number): {
     end: number;
     query: string;
 } | null;
+export declare function isFileSelectionCurrent(current: {
+    buffer: string;
+    cursor: number;
+}, original: {
+    buffer: string;
+    cursor: number;
+}, token: {
+    start: number;
+    end: number;
+}): boolean;
 interface UseFileSearchOptions {
     state: State;
     dispatch: React.Dispatch<Action>;

package/dist/hooks/use-mcp-status-bridge.d.ts

@@ -0,0 +1,18 @@
+import { type Dispatch } from 'react';
+import type { Action } from '../app-action-type.js';
+import type { AppProps } from '../app-props.js';
+/**
+ * Tells the person when an MCP server is down for good, and when it is back.
+ *
+ * The model learns about a failed server through its tool list; the person
+ * learned nothing — the registry only logged it. Only a `terminal` disconnect
+ * is shown: connect attempts or reconnect cycles are exhausted and nothing
+ * retries by itself. A stop, an idle sleep or a drop that an automatic
+ * reconnect follows stays quiet. Each failure is shown once; the recovery line
+ * appears only for a server this bridge reported down.
+ */
+export declare function useMcpStatusBridge({ events, dispatch, }: {
+    events: AppProps['events'];
+    dispatch: Dispatch<Action>;
+}): void;
+//# sourceMappingURL=use-mcp-status-bridge.d.ts.map

package/dist/hooks/use-next-steps-auto-submit.d.ts

@@ -26,15 +26,17 @@ interface AutoProceedCandidateInput {
     autoSuggestions?: readonly string[] | undefined;
     yolo?: boolean | undefined;
     autonomyNextPrompt?: string | undefined;
+    /** The last run died on a retryable provider failure (see failed-run-tracker). */
+    failedRun?: boolean | undefined;
 }
 interface AutoProceedCandidate {
-    source: 'todo' | 'suggestion' | 'auto-suggestion';
+    source: 'todo' | 'suggestion' | 'auto-suggestion' | 'failed-run';
     prompt: string;
     label: string;
     todoId?: string | undefined;
 }
 /** Resolve one grounded automatic turn without mutating either suggestion store. */
-export declare function selectAutoProceedCandidate({ todos, suggestions, autoSuggestions, yolo, autonomyNextPrompt, }: AutoProceedCandidateInput): AutoProceedCandidate | null;
+export declare function selectAutoProceedCandidate({ todos, suggestions, autoSuggestions, yolo, autonomyNextPrompt, failedRun, }: AutoProceedCandidateInput): AutoProceedCandidate | null;
 /** Owns grounded next-step countdowns and automatic-turn loop guards. */
 export declare function useNextStepsAutoSubmit({ state, autonomyLive, agent, getAutonomy, getSettings, getSuggestions, getAutoSuggestions, getYolo, setSuggestions, autonomyNextPrompt, dispatch, clearDraft, runBlocksRef, }: NextStepsAutoSubmitOptions): {
     nextStepsAutoSubmitCountdown: number | null;

package/dist/hooks/use-picker-keys-brain-statusline.d.ts

@@ -0,0 +1,4 @@
+import type { KeyEvent } from '../components/input.js';
+import type { PickerKeysHost } from './use-picker-keys-types.js';
+export declare function tryBrainStatuslinePickerKeys(host: PickerKeysHost, input: string, key: KeyEvent, isEnter: boolean, debouncedEnter: (host: PickerKeysHost) => boolean): boolean;
+//# sourceMappingURL=use-picker-keys-brain-statusline.d.ts.map

package/dist/hooks/use-picker-keys-types.d.ts

@@ -74,6 +74,11 @@ export interface PickerKeysHost {
      * leave Enter as a no-op (the picker still navigates, just doesn't apply).
      */
     onThemePickerEnter?: (() => void) | undefined;
+    /**
+     * Restores the preset that was live when the picker opened, keeping the
+     * picker open. Optional — omitted hosts leave `u` inert.
+     */
+    onThemePickerUndo?: (() => void) | undefined;
     onSlashPickerTab: (() => void) | undefined;
 }
 //# sourceMappingURL=use-picker-keys-types.d.ts.map

package/dist/hooks/use-provider-quota.d.ts

@@ -27,6 +27,11 @@ export interface ProviderQuotaChip {
     resetIn?: string | undefined;
     /** True when this window is the one currently cutting the account off. */
     reached: boolean;
+    /**
+     * `1h 40m`, when the pace of the last hour fills the window before it
+     * resets. Absent while the plan is not on course to run out.
+     */
+    exhaustsIn?: string | undefined;
 }
 export declare function useProviderQuota(): ProviderQuotaChip | undefined;
 //# sourceMappingURL=use-provider-quota.d.ts.map

package/dist/hooks/use-provider-warmup.d.ts

@@ -0,0 +1,9 @@
+import type { AppProps } from '../app-props.js';
+import type { State } from '../app-state.js';
+/**
+ * Warm the provider connection while the user types, so DNS and TLS are done
+ * by the time they press Enter (`Provider.warm`). Runs on every keystroke;
+ * the provider throttles to one small request per endpoint every few seconds.
+ */
+export declare function useProviderWarmup(agent: AppProps['agent'], buffer: string, status: State['status']): void;
+//# sourceMappingURL=use-provider-warmup.d.ts.map

package/dist/hooks/use-queue-manager.d.ts

@@ -5,6 +5,12 @@ import type { Settings } from '../app-state.js';
 export interface UseQueueManagerOptions {
     /** Optional persistent store — absent => in-memory only (no crash recovery). */
     queueStore?: QueueStore | undefined;
+    /**
+     * The store of another session. With it, resuming a session brings that
+     * session's queue along (the WebUI keeps its queue in the same file) and
+     * leaves the previous session's on disk; without it, the queue is dropped.
+     */
+    queueStoreFor?: ((sessionId: string) => QueueStore | undefined) | undefined;
     /** Called on every queue change so the host learns what's waiting. */
     onQueueChange?: ((items: string[]) => void) | undefined;
     /** Slash registry to register the /queue command. */
@@ -18,10 +24,14 @@ export interface UseQueueManagerOptions {
     /** Live mirror of the mid-run send-mode picker enabled flag. */
     midRunSendPickerRef: React.MutableRefObject<boolean>;
 }
+export interface QueueManager {
+    /** Move the queue to the session just resumed: its own queue replaces this one. */
+    switchSession(sessionId: string): void;
+}
 /**
  * Manages the TUI message queue: rehydration from persistent store,
  * persistence on every change, host mirroring, and the /queue slash
  * command. All side-effect wiring extracted from app.tsx.
  */
-export declare function useQueueManager({ queueStore, onQueueChange, slashRegistry, stateRef, dispatch, getSettings, saveSettings, midRunSendPickerRef, }: UseQueueManagerOptions): void;
+export declare function useQueueManager({ queueStore, queueStoreFor, onQueueChange, slashRegistry, stateRef, dispatch, getSettings, saveSettings, midRunSendPickerRef, }: UseQueueManagerOptions): QueueManager;
 //# sourceMappingURL=use-queue-manager.d.ts.map

package/dist/hooks/use-session-rewind.d.ts

@@ -1,6 +1,12 @@
 import type { Agent } from '@wrongstack/core/agent';
 import type { Director } from '@wrongstack/core/coordination';
+import { type RedoRewindResult, type RewoundConversation } from '@wrongstack/core/storage';
 import type { SessionInterruptController } from './use-session-interrupt-controller.js';
+/** What a rewind leaves for the screen: the prompt taken back, and the rest. */
+export interface RewindOutcome {
+    promptText?: string | undefined;
+    conversation?: RewoundConversation | undefined;
+}
 interface UseSessionRewindOptions {
     agent: Agent;
     sessionsDir?: string | undefined;
@@ -9,7 +15,8 @@ interface UseSessionRewindOptions {
     sessionGenerationRef: React.MutableRefObject<number>;
 }
 export declare function useSessionRewind({ agent, sessionsDir, interruptController, liveDirector, sessionGenerationRef, }: UseSessionRewindOptions): {
-    handleRewindTo: (checkpointIndex: number) => Promise<void>;
+    handleRewindTo: (checkpointIndex: number) => Promise<RewindOutcome>;
+    handleRewindRedo: () => Promise<RedoRewindResult | null>;
 };
 export {};
 //# sourceMappingURL=use-session-rewind.d.ts.map

package/dist/hooks/use-slash-picker.d.ts

@@ -1,6 +1,6 @@
 import { type Dispatch } from 'react';
-import type { AppProps } from '../app-props.js';
 import type { Action } from '../app-action-type.js';
+import type { AppProps } from '../app-props.js';
 import type { State } from '../app-state.js';
 interface SlashPickerOptions {
     state: State;

package/dist/hooks/use-stable-key-handler.d.ts

@@ -1,5 +1,12 @@
 import type { KeyEvent } from '../components/input.js';
 type AppKeyHandler = (input: string, key: KeyEvent) => Promise<void>;
-export declare function useStableKeyHandler(handleKey: AppKeyHandler): AppKeyHandler;
+/**
+ * Returns an identity-stable key handler that always calls the latest
+ * `handleKey`. A rejected key handler must never kill the process, but it
+ * must not vanish either: `onError` receives the failure so the host can
+ * surface it (an error entry in the transcript). Without `onError` the
+ * failure is still contained.
+ */
+export declare function useStableKeyHandler(handleKey: AppKeyHandler, onError?: (err: unknown) => void): AppKeyHandler;
 export {};
 //# sourceMappingURL=use-stable-key-handler.d.ts.map

package/dist/hooks/use-status-sync-interval.d.ts

@@ -1,6 +1,7 @@
 import type { Agent } from '@wrongstack/core/agent';
+import type { AutonomyStage } from './use-statusline-state.js';
 interface UseStatusSyncIntervalOptions {
-    getAutonomy?: (() => string) | undefined;
+    getAutonomy?: (() => AutonomyStage) | undefined;
     getYolo?: (() => boolean) | undefined;
     getModeLabel?: (() => string) | undefined;
     getEternalEngine?: unknown;
@@ -11,7 +12,7 @@ interface UseStatusSyncIntervalOptions {
     liveModeLabel: string;
     liveModel: string;
     liveProvider: string;
-    setAutonomyLive: (v: any) => void;
+    setAutonomyLive: (v: AutonomyStage) => void;
     setYoloLive: (v: boolean) => void;
     setLiveModeLabel: (v: string) => void;
     setLiveModel: (v: string) => void;

package/dist/hooks/use-theme-picker-handler.d.ts

@@ -1,4 +1,4 @@
-import type { ConfigStore } from '@wrongstack/core/types';
+import type { ConfigStore, ThemePresetId } from '@wrongstack/core/types';
 import type { Action } from '../app-reducer.js';
 import { type ThemeName } from '../theme.js';
 interface UseThemePickerHandlerOptions {
@@ -6,9 +6,14 @@ interface UseThemePickerHandlerOptions {
     saveThemePreset?: ((theme: ThemeName) => Promise<void>) | undefined;
     dispatch: React.Dispatch<Action>;
     selectedIndex: number;
+    /** Active type-to-filter query — `selectedIndex` indexes the FILTERED list. */
+    filter?: string | undefined;
+    /** Preset that was live when the picker opened — the undo target. */
+    previous?: ThemePresetId | undefined;
 }
-export declare function useThemePickerHandler({ configStore, saveThemePreset, dispatch, selectedIndex, }: UseThemePickerHandlerOptions): {
+export declare function useThemePickerHandler({ configStore, saveThemePreset, dispatch, selectedIndex, filter, previous, }: UseThemePickerHandlerOptions): {
     onThemePickerEnter: () => void;
+    onThemePickerUndo: () => void;
 };
 export {};
 //# sourceMappingURL=use-theme-picker-handler.d.ts.map

package/dist/hooks/use-tui-environment-state.d.ts

@@ -1,3 +1,4 @@
+import { getIndexState } from '@wrongstack/tools';
 import type { AppProps } from '../app-props.js';
 type EnvironmentProps = Omit<Pick<AppProps, 'events' | 'memoryStore' | 'model' | 'provider' | 'effectiveMaxContext' | 'yolo' | 'getAutonomy' | 'modeLabel' | 'statuslineHiddenItems' | 'statuslineLines' | 'statuslineDensities' | 'statuslineOrder' | 'toolCount' | 'getSettings' | 'setStatuslineHiddenItems' | 'saveStatuslineHiddenItems' | 'setStatuslineLines' | 'saveStatuslineLines' | 'setStatuslineDensities' | 'saveStatuslineDensities' | 'setStatuslineOrder' | 'saveStatuslineOrder'>, 'yolo'> & {
     yolo: boolean;
@@ -45,5 +46,7 @@ export declare function useTuiEnvironmentState({ events, memoryStore, model, pro
     };
     breakerCountdown: import("@wrongstack/tools").BreakerCountdown | null;
 };
+/** Everything the index status chip renders; equal keys draw an equal chip. */
+export declare function indexChipKey(state: ReturnType<typeof getIndexState>): string;
 export {};
 //# sourceMappingURL=use-tui-environment-state.d.ts.map

package/dist/hooks/use-tui-event-bridge.d.ts

@@ -4,6 +4,18 @@ type ClearHistoryDispatch = React.Dispatch<{
     type: 'clearHistory';
     model?: string | undefined;
     provider?: string | undefined;
+    /**
+     * When explicitly `null`, the reducer treats the boot-time restored
+     * transcript as discarded and resets `historyBudget`, `autoProceedHold`,
+     * and `nextId` to the fresh-boot values. `/clear` passes `null` for
+     * all three so the screen genuinely looks like first launch. Pass
+     * `undefined` (or omit) to preserve the existing resume-derived
+     * budget/hold — the behavior the bridge uses for `session.rewound` /
+     * `project.switched`.
+     */
+    restoredMessages?: readonly unknown[] | null | undefined;
+    restoredToolCalls?: readonly unknown[] | null | undefined;
+    restoredEvents?: readonly unknown[] | null | undefined;
 } | {
     type: 'resetContextChip';
 } | {