@wrongstack/tui 1.0.24 → 1.0.26

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/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/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>;
@@ -37,6 +39,6 @@ interface UseAppPickerKeysOptions {
     onThemePickerEnter?: () => 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, 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-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-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-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';
 } | {