@wrongstack/tui 0.306.3 → 0.307.0

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

@@ -0,0 +1,45 @@
+export declare const STATUSLINE_ICONS: {
+    readonly auto_proceed: string;
+    readonly autonomy: string;
+    readonly brain: string;
+    readonly breaker: string;
+    readonly cache: string;
+    readonly context: string;
+    readonly cost: string;
+    readonly debug_stream: string;
+    readonly elapsed: string;
+    readonly enhance: string;
+    readonly eternal_stage: string;
+    readonly fleet: string;
+    readonly fleet_agents: string;
+    readonly git: string;
+    readonly goal: string;
+    readonly hint: string;
+    readonly index: string;
+    readonly mailbox: string;
+    readonly memory_context: string;
+    readonly mode: string;
+    readonly model: string;
+    readonly next_steps: string;
+    readonly plan: string;
+    readonly processes: string;
+    readonly project: string;
+    readonly queue: string;
+    readonly sessions: string;
+    readonly side_effects: string;
+    readonly state: string;
+    readonly tasks: string;
+    readonly token_saving: string;
+    readonly tokens: string;
+    readonly todos: string;
+    readonly tools: string;
+    readonly working_dir: string;
+    readonly yolo: string;
+};
+export declare const COMPACT_THRESHOLD = 50;
+export declare function chipColor(color: string, isNoColor: boolean): string | undefined;
+export declare const STACK_ORANGE = "#FD9F02";
+export declare const LINE_BG_COLORS: readonly [string, string, string, string];
+export declare const SPINNER_FRAMES: string[];
+export declare const SPINNER_INTERVAL_MS = 1000;
+//# sourceMappingURL=status-bar-icons.d.ts.map

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

@@ -0,0 +1,89 @@
+import type React from 'react';
+import type { AnimationStyle } from './animation-style.js';
+import type { RailSpanEntry } from './powerline-rail.js';
+import type { FleetAgentDetail, MailboxStatus, StatusBarProps } from './status-bar-types.js';
+import type { StatuslineItem } from './statusline-picker.js';
+export interface StatusBarRailBuildParams {
+    showChip: (item: StatuslineItem) => boolean;
+    isNoColor: boolean;
+    model: string;
+    provider?: string | undefined;
+    version?: string | undefined;
+    latestVersion?: string | undefined;
+    updateAvailable?: boolean | undefined;
+    yolo?: boolean | undefined;
+    autonomy?: StatusBarProps['autonomy'];
+    processCount?: number | undefined;
+    stateStatusChip: React.ReactElement | null;
+    fleetWorkingTime?: number | undefined;
+    primaryChips: React.ReactElement[];
+    context?: StatusBarProps['context'];
+    contextStrategy?: string | undefined;
+    showTokenDisplay: boolean;
+    displayTokens: {
+        input: number;
+        output: number;
+    };
+    cost?: {
+        total: number;
+    } | undefined;
+    cache?: {
+        hitRatio: number;
+    } | undefined;
+    queueCount?: number | undefined;
+    hint?: string | undefined;
+    breakerCountdown?: StatusBarProps['breakerCountdown'];
+    projectName?: string | undefined;
+    workingDir?: string | undefined;
+    git?: StatusBarProps['git'];
+    modeLabel?: string | undefined;
+    sessionCount?: number | undefined;
+    toolCount?: number | undefined;
+    tokenSavingMode?: string | undefined;
+    sideEffectCount?: number | undefined;
+    todos?: StatusBarProps['todos'];
+    todosCleared: boolean;
+    plan?: StatusBarProps['plan'];
+    tasks?: StatusBarProps['tasks'];
+    hasTaskActivity: boolean | null | undefined;
+    fleet?: StatusBarProps['fleet'];
+    fleetHasActivity: boolean | null | undefined;
+    subagentCount: number;
+    showBrain: boolean;
+    brain?: StatusBarProps['brain'];
+    showDebugStream: boolean;
+    debugStreamStats?: StatusBarProps['debugStreamStats'];
+    showEnhance: boolean;
+    enhanceCountdown?: StatusBarProps['enhanceCountdown'];
+    hasNextStepsAutoSubmit: boolean;
+    nextStepsAutoSubmitCountdown?: StatusBarProps['nextStepsAutoSubmitCountdown'];
+    nextStepsAutoSubmitLabel?: StatusBarProps['nextStepsAutoSubmitLabel'];
+    nextStepsColor: string;
+    showEternalStage: boolean;
+    eternalStage?: StatusBarProps['eternalStage'];
+    hasActiveGoal: boolean;
+    goalSummary?: StatusBarProps['goalSummary'];
+    hasAutoProceed: boolean;
+    autoProceedCountdown?: StatusBarProps['autoProceedCountdown'];
+    droppedTools?: number | undefined;
+    detailChips: React.ReactElement[];
+    minimalWorkParts: string[];
+    thinking: boolean;
+    statePrefix: string;
+    stateLabel: string;
+    stateColor: string;
+    animationStyle: AnimationStyle | 'cycle';
+    spinnerIdx: number;
+    cycleTick: number;
+    memoryContextMonitor?: StatusBarProps['memoryContextMonitor'];
+    Sage?: StatusBarProps['Sage'];
+    indexState?: StatusBarProps['indexState'];
+}
+export declare function buildPrimaryChips(p: StatusBarRailBuildParams): React.ReactElement[];
+export declare function buildModeChipEntries(p: StatusBarRailBuildParams, modelStatusChip: React.ReactElement | null): RailSpanEntry[];
+export declare function buildMinimumChips(p: StatusBarRailBuildParams): React.ReactElement[];
+export declare function buildMailboxDetailChips(mailbox: MailboxStatus | undefined, showMailbox: boolean, isNoColor: boolean, fleetAgents?: FleetAgentDetail[] | undefined, showFleetAgents?: boolean | undefined): React.ReactElement[];
+export declare function buildWorkRowEntries(p: StatusBarRailBuildParams): RailSpanEntry[];
+export declare function buildIndexStatusChip(indexState: StatusBarProps['indexState'], showChip: (item: StatuslineItem) => boolean, isNoColor: boolean): React.ReactElement | null;
+export declare function buildMemoryDetailChips(memoryContextMonitor: StatusBarProps['memoryContextMonitor'], Sage: StatusBarProps['Sage'], isNoColor: boolean): React.ReactElement[];
+//# sourceMappingURL=status-bar-rails.d.ts.map

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

@@ -1,9 +1,8 @@
 import type React from 'react';
 import type { StatusBarProps } from './status-bar-types.js';
 export { contextBarColor, fmtElapsed, hasTokenDisplay, nodeText, planChipFit, renderMeter, renderProgress, stateChip, type TokenDisplayTotals, tokenDisplayTotals, truncateChip, } from './status-bar-format.js';
+export { chipColor, COMPACT_THRESHOLD, LINE_BG_COLORS, SPINNER_FRAMES, SPINNER_INTERVAL_MS, STACK_ORANGE, STATUSLINE_ICONS, } from './status-bar-icons.js';
 export type { BrainStatusChip, ContextWindow, FleetAgentDetail, FleetCounts, MailboxStatus, PlanCounts, StatusBarProps, TaskCounts, TodoCounts, } from './status-bar-types.js';
-/** Minimum terminal width before we switch to ultra-compact mode. */
-export declare const COMPACT_THRESHOLD = 50;
 /**
  * Two-line status bar. The first line stays compact and shows the
  * workspace route followed by provider/model, context, tokens, cost, queue,

package/dist/hooks/use-active-theme.d.ts

@@ -10,5 +10,5 @@
  * but exposing it lets test code and stat panels introspect the active
  * palette without re-implementing the listener.
  */
-export declare function useActiveTheme(): import("../theme.js").Theme;
+export declare function useActiveTheme(): import("../theme-types.js").Theme;
 //# sourceMappingURL=use-active-theme.d.ts.map

package/dist/hooks/use-app-event-bridges.d.ts

@@ -0,0 +1,46 @@
+export declare function useAppEventBridges(params: {
+    events: any;
+    agent: any;
+    dispatch: any;
+    streamingTextRef: any;
+    streamSegmentsRef: any;
+    pendingDeltaRef: any;
+    flushTimerRef: any;
+    sessionGenerationRef: any;
+    activeRunGenerationRef: any;
+    assistantCommittedThisRunRef: any;
+    setMemoryContextMonitor: any;
+    clientId: any;
+    tokenCounter: any;
+    getAutonomy: any;
+    registerDebugStreamCallback: any;
+    restoreDebugStreamCallback: any;
+    stateRef: any;
+    setActiveMaxContext: any;
+    subscribeGoal: any;
+    onClearHistory: any;
+    fleetChat: any;
+    enhanceEnabled: boolean;
+    agentsMonitorOpen: boolean;
+    fleetStreamController: any;
+    enhanceController: any;
+    agentsMonitorController: any;
+    interruptController: any;
+    activeCtrlRef: any;
+    activeRunSettledRef: any;
+    eternalLoopRunningRef: any;
+    parallelLoopRunningRef: any;
+    tokenPreviewsRef: any;
+    clearPendingConfirms: () => void;
+    getEternalEngine: any;
+    getParallelEngine: any;
+    getSddRun: any;
+    switchAutonomy: any;
+    slashRegistry: any;
+    exitConfirm: any;
+    liveDirector: any;
+    director: any;
+}): {
+    getLeaderTranscript: () => import("@wrongstack/core/coordination").AgentTimelineEntry[];
+};
+//# sourceMappingURL=use-app-event-bridges.d.ts.map

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

@@ -0,0 +1,24 @@
+import { createAppKeyHandler } from '../app-key-handler.js';
+import { createRunBlocksController } from '../run-blocks-controller.js';
+import { createSubmitController } from '../submit-controller.js';
+export type KeyHandlerParams = Parameters<typeof createAppKeyHandler>[0];
+export type RunBlocksParams = Parameters<typeof createRunBlocksController>[0];
+export type SubmitParams = Parameters<typeof createSubmitController>[0];
+export interface AppExecutionPipelineArgs {
+    keyHandlerParams: KeyHandlerParams;
+    runBlocksParams: RunBlocksParams;
+    submitParams: SubmitParams;
+    runBlocksRef: {
+        current: ReturnType<typeof createRunBlocksController>;
+    };
+    submitRef: {
+        current: any;
+    };
+}
+export declare function useAppExecutionPipeline(args: AppExecutionPipelineArgs): {
+    handleKey: (input: string, key: import("../components/input.js").KeyEvent) => Promise<void>;
+    runBlocks: (blocks: import("@wrongstack/core/types").ContentBlock[]) => Promise<void>;
+    submit: (overrideRaw?: string) => Promise<void>;
+    stableOnKey: (input: string, key: import("../components/input.js").KeyEvent) => Promise<void>;
+};
+//# sourceMappingURL=use-app-execution-pipeline.d.ts.map

package/dist/hooks/use-app-panels-state.d.ts

@@ -0,0 +1,34 @@
+import type { Dispatch } from 'react';
+import type { AppProps } from '../app-props.js';
+import type { Action, State } from '../app-reducer.js';
+export declare function useAppPanelsState(params: {
+    projectRoot: string;
+    dispatch: Dispatch<Action>;
+    state: State;
+    getModes?: any;
+    getPickableProviders?: any;
+    getBrainData?: any;
+    brainPanelHost?: any;
+    onBrainRiskLevel?: any;
+    getShadowData?: any;
+    onShadowStart?: any;
+    onShadowStop?: any;
+    slashRegistry?: AppProps['slashRegistry'];
+    hiddenItems: any;
+    setHiddenItems: (items: any) => void;
+    subscribeCoordinatorEvents?: any;
+}): {
+    openPromptPicker: () => Promise<void>;
+    setPromptFavorite: (slug: string, favorite: boolean) => Promise<void>;
+    openModePicker: () => Promise<void>;
+    requestModelPick: (title: string) => Promise<import("./use-model-pick.js").ModelPickSelection>;
+    handleModelPicked: (providerId: string, modelId: string) => void;
+    brainCtl: import("./use-brain-panel.js").BrainPanelController;
+    openBrainPanel: () => void;
+    changeBrainRisk: (delta: number) => void;
+    openShadowPanel: () => void;
+    handleShadowStart: () => Promise<void>;
+    handleShadowStop: () => Promise<void>;
+    openHelpPanel: () => void;
+};
+//# sourceMappingURL=use-app-panels-state.d.ts.map

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

@@ -0,0 +1,101 @@
+import type { AppProps } from '../app-props.js';
+import type { State } from '../app-reducer.js';
+import type { AppExecutionPipelineArgs } from './use-app-execution-pipeline.js';
+export declare function buildAppPipelineArgs(params: {
+    props: AppProps;
+    state: State;
+    dispatch: any;
+    historyScrollRef: any;
+    runInterruptLadder: any;
+    enhanceCancelledRef: any;
+    enhanceAbortRef: any;
+    enhanceOriginalRef: any;
+    enhanceEnabledRef: any;
+    inputGateRef: any;
+    lastEscAtRef: any;
+    dismissedEscAtRef: any;
+    streamingTextRef: any;
+    streamSegmentsRef: any;
+    pendingDeltaRef: any;
+    flushTimerRef: any;
+    sessionGenerationRef: any;
+    activeRunGenerationRef: any;
+    activeRunSettledRef: any;
+    assistantCommittedThisRunRef: any;
+    confirmExitRef: any;
+    chimeRef: any;
+    activeCtrlRef: any;
+    clearPendingConfirms: any;
+    liveDirector: any;
+    openProjectPicker: any;
+    loadLiveSessions: any;
+    openStatuslinePicker: any;
+    statuslineHiddenItems: any;
+    lastEnterAtRef: any;
+    draftRef: any;
+    setDraft: any;
+    clearDraft: any;
+    mouseMode: any;
+    nativeMouse: any;
+    termRows: any;
+    terminalColumns: any;
+    terminalRows: any;
+    mainColumnWidth: any;
+    overlayOpen: any;
+    effectiveSwarmOnSidebar: any;
+    sidebarTwinRowCount: any;
+    statusBarWrapRef: any;
+    belowStatusBarRef: any;
+    statusBarClickMapRef: any;
+    openModelPicker: any;
+    nextStepsAutoSubmitTimerRef: any;
+    nextStepsAutoSubmitSuggestionRef: any;
+    nextStepsAutoSubmitLabel: any;
+    setNextStepsAutoSubmitCountdown: any;
+    setNextStepsAutoSubmitLabel: any;
+    cancelNextStepsCountdown: any;
+    pasteClipboardText: any;
+    pasteClipboardImage: any;
+    onHistoryCopy: any;
+    tryPickerKey: any;
+    pasteAccumRef: any;
+    pasteFlushTimerRef: any;
+    commitPaste: any;
+    builderRef: any;
+    tokenPreviewsRef: any;
+    interruptsSyncRef: any;
+    stateRef: any;
+    runBlocksRef: any;
+    submitRef: any;
+    liveModel: any;
+    liveProvider: any;
+    activeMaxContext: any;
+    yoloLive: any;
+    autonomyLive: any;
+    liveModeLabel: any;
+    setMouseMode: any;
+    setNativeMouse: any;
+    setLiveModel: any;
+    setLiveProvider: any;
+    setActiveMaxContext: any;
+    setYoloLive: any;
+    setAutonomyLive: any;
+    setLiveModeLabel: any;
+    setLiveToolCount: any;
+    autoSubmitStreakRef: any;
+    autoSubmitCapWarnedRef: any;
+    autoSubmitLoopGuardRef: any;
+    runEternalLoopRef: any;
+    runParallelLoopRef: any;
+    midRunSendPickerRef: any;
+    openPromptPicker: any;
+    refreshGoalSummary: any;
+    exit: any;
+    setMemoryContextMonitor: any;
+    runSteerSequence: any;
+    setEnhanceStartedAt: any;
+    setEnhanceDurationMs: any;
+    setRefineProviderId: any;
+    setRefineModel: any;
+}): AppExecutionPipelineArgs;
+//# sourceMappingURL=use-app-pipeline-builders.d.ts.map

package/dist/hooks/use-picker-keys-auth-model.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 tryAuthModelPickerKeys(host: PickerKeysHost, input: string, key: KeyEvent, isEnter: boolean, debouncedEnter: (host: PickerKeysHost) => boolean): boolean;
+//# sourceMappingURL=use-picker-keys-auth-model.d.ts.map

package/dist/hooks/use-picker-keys-tools-settings.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 tryToolsSettingsPickerKeys(host: PickerKeysHost, input: string, key: KeyEvent, isEnter: boolean, debouncedEnter: (host: PickerKeysHost) => boolean): boolean;
+//# sourceMappingURL=use-picker-keys-tools-settings.d.ts.map

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

@@ -0,0 +1,14 @@
+import type { Agent } from '@wrongstack/core/agent';
+import type { Director } from '@wrongstack/core/coordination';
+import type { SessionInterruptController } from './use-session-interrupt-controller.js';
+export interface UseSessionRewindOptions {
+    agent: Agent;
+    sessionsDir?: string | undefined;
+    interruptController?: SessionInterruptController | undefined;
+    liveDirector: () => Director | null;
+    sessionGenerationRef: React.MutableRefObject<number>;
+}
+export declare function useSessionRewind({ agent, sessionsDir, interruptController, liveDirector, sessionGenerationRef, }: UseSessionRewindOptions): {
+    handleRewindTo: (checkpointIndex: number) => Promise<void>;
+};
+//# sourceMappingURL=use-session-rewind.d.ts.map

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

@@ -0,0 +1,23 @@
+import type { Agent } from '@wrongstack/core/agent';
+export interface UseStatusSyncIntervalOptions {
+    getAutonomy?: (() => string) | undefined;
+    getYolo?: (() => boolean) | undefined;
+    getModeLabel?: (() => string) | undefined;
+    getEternalEngine?: unknown;
+    getParallelEngine?: unknown;
+    agent: Agent;
+    autonomyLive: string;
+    yoloLive: boolean;
+    liveModeLabel: string;
+    liveModel: string;
+    liveProvider: string;
+    setAutonomyLive: (v: any) => void;
+    setYoloLive: (v: boolean) => void;
+    setLiveModeLabel: (v: string) => void;
+    setLiveModel: (v: string) => void;
+    setLiveProvider: (v: string) => void;
+    runEternalLoopRef: React.MutableRefObject<() => Promise<void>>;
+    runParallelLoopRef: React.MutableRefObject<() => Promise<void>>;
+}
+export declare function useStatusSyncInterval({ getAutonomy, getYolo, getModeLabel, getEternalEngine, getParallelEngine, agent, autonomyLive, yoloLive, liveModeLabel, liveModel, liveProvider, setAutonomyLive, setYoloLive, setLiveModeLabel, setLiveModel, setLiveProvider, runEternalLoopRef, runParallelLoopRef, }: UseStatusSyncIntervalOptions): void;
+//# sourceMappingURL=use-status-sync-interval.d.ts.map

package/dist/hooks/use-statusbar-view-model.d.ts

@@ -1,7 +1,9 @@
+import type { CacheStats } from '@wrongstack/core/types';
 import { type ContextBreakdown } from '@wrongstack/core/utils';
 import type { AppProps } from '../app-props.js';
 import type { FleetEntry, State } from '../app-state.js';
 import type { StatuslineItem } from '../components/statusline-picker.js';
+import type { TokenRefreshData } from './use-token-counter-refresh.js';
 interface StatusbarViewModelOptions {
     agent: AppProps['agent'];
     tokenCounter: AppProps['tokenCounter'];
@@ -20,6 +22,17 @@ interface StatusbarViewModelOptions {
      * user-hidden, skip the poll entirely until it is visible again.
      */
     hiddenItems?: readonly StatuslineItem[] | undefined;
+    /**
+     * Live token-counter refresh snapshot — supplies per-request
+     * `currentRequestTokens` plus cumulative `cacheStats`. When omitted the
+     * view model falls back to reading the counter directly so existing
+     * callers stay correct (the older path was a render-time poll of
+     * mutable counters and lagged async provider responses).
+     *
+     * Typed as the exact `TokenRefreshData` shape so callers passing the
+     * hook's return value stay assignable under `exactOptionalPropertyTypes`.
+     */
+    tokenRefresh?: TokenRefreshData;
 }
 interface PlanCounts {
     open: number;
@@ -34,13 +47,24 @@ interface TaskCounts {
     failed: number;
 }
 /** Builds status-bar projections without coupling them to the root App render. */
-export declare function useStatusbarViewModel({ agent, tokenCounter, activeMaxContext, effectiveMaxContext, liveProvider, liveModel, liveTodos, sidebarVisible, state, hiddenItems, }: StatusbarViewModelOptions): {
+export declare function useStatusbarViewModel({ agent, tokenCounter, activeMaxContext, effectiveMaxContext, liveProvider, liveModel, liveTodos, sidebarVisible, state, hiddenItems, tokenRefresh, }: StatusbarViewModelOptions): {
     contextBreakdown: ContextBreakdown | undefined;
     currentContextTokens: number;
     contextWindow: {
         used: number;
         max: number;
     } | undefined;
+    cacheStats: CacheStats;
+    /**
+     * "Cache coverage" — how far the cached prefix reaches through the live
+     * request, expressed in tokens. Computed from the per-request
+     * `cacheRead` snapshot (the cached prefix of the current prompt) and
+     * the measured `used` total. Capped at `used` so the figure never
+     * overshoots the actual request size. Zero when no cache read was
+     * reported on the latest request — the indicator stays hidden instead
+     * of suggesting a meaningless 0.
+     */
+    cacheCoverageTokens: number;
     todos: {
         pending: number;
         inProgress: number;

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

@@ -0,0 +1,13 @@
+import type { ConfigStore } from '@wrongstack/core/types';
+import type { Action } from '../app-reducer.js';
+import { type ThemeName } from '../theme.js';
+export interface UseThemePickerHandlerOptions {
+    configStore?: ConfigStore | undefined;
+    saveThemePreset?: ((theme: ThemeName) => Promise<void>) | undefined;
+    dispatch: React.Dispatch<Action>;
+    selectedIndex: number;
+}
+export declare function useThemePickerHandler({ configStore, saveThemePreset, dispatch, selectedIndex, }: UseThemePickerHandlerOptions): {
+    onThemePickerEnter: () => void;
+};
+//# sourceMappingURL=use-theme-picker-handler.d.ts.map