@wrongstack/tui 1.0.19 → 1.0.26

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-fleet-generation-gate.d.ts

@@ -3,9 +3,10 @@
  *
  * Fleet event bridges must discard events from subagents that were spawned
  * before the last `/clear`. This shared hook encapsulates that logic so any
- * bridge can apply it consistently. Currently consumed by
- * `useDirectorFleetBridge` (Director FleetBus streaming); `useSubagentEvents`
- * (EventBus lifecycle) does not gate on generation today.
+ * bridge can apply it consistently. Both consumers wire it: `useDirectorFleetBridge`
+ * (Director FleetBus streaming) and `useSubagentEvents` (EventBus lifecycle —
+ * instantiated at use-subagent-events.ts:126, `gate.track` on spawn, `gate.isLive`
+ * on every subagent event handler, `gate.forget` on removal).
  *
  * Usage:
  * ```ts

package/dist/hooks/use-panel-controllers.d.ts

@@ -14,7 +14,7 @@ interface PanelControllersOptions {
     openAuthPanel: (view?: 'list' | 'oauth') => boolean;
     openModePicker: () => void | Promise<void>;
     openBrainPanel: () => void | Promise<void>;
-    openShadowPanel: () => void | Promise<void>;
+    openShadowPanel: () => void | boolean;
     /** Opens the `/subagent-models` lane panel; omitted when the host wires no plan. */
     openSubagentModelsPanel?: (() => void) | undefined;
     openHelpPanel: () => void | Promise<void>;

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

@@ -43,6 +43,7 @@ export interface PickerKeysHost {
     onResumePickerEnter: (() => Promise<void>) | undefined;
     onSessionsPanelEnter: (() => Promise<void>) | undefined;
     onProjectPickerEnter: (() => Promise<void>) | undefined;
+    onSkillMentionPick?: ((name: string) => void) | undefined;
     onSlashPickerEnter: (() => void) | undefined;
     onSettingsPickerEnter: (() => void) | undefined;
     onPluginPickerToggle: (() => Promise<void> | void) | undefined;

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-shadow-panel.d.ts

@@ -10,7 +10,7 @@ interface ShadowPanelHost {
     onShadowStop?: (() => Promise<string | undefined>) | undefined;
 }
 export declare function useShadowPanel(dispatch: React.Dispatch<Action>, host: ShadowPanelHost): {
-    openShadowPanel: () => void;
+    openShadowPanel: () => boolean;
     handleShadowStart: () => Promise<void>;
     handleShadowStop: () => Promise<void>;
 };

package/dist/hooks/use-sidebar-panel-data.d.ts

@@ -9,10 +9,10 @@
  * Each hook is self-contained: it manages its own refresh interval and
  * cleanup. The hooks must be called unconditionally (rules of hooks), but
  * polling is gated by the `enabled` flag — app-view passes whether the
- * twin currently occupies a visible sidebar slot. While a panel is closed
- * or routed to the bottom region no polling runs (the bottom panels run
- * their own polling when open), so the session pays no IPC probes or disk
- * reads for panels nobody is looking at. Each hook performs an immediate
+ * twin currently occupies a visible sidebar slot. Connections also supplies
+ * the persistent icon strip, so it polls whenever the sidebar is visible.
+ * Hidden surfaces do not poll (bottom panels run their own polling when open).
+ * Each hook performs an immediate
  * first read when enabled, so data is fresh the moment the twin mounts.
  */
 interface SidebarProcess {
@@ -30,7 +30,9 @@ export declare function useSidebarProcessList(enabled?: boolean): {
     totalCount: number;
     processes: readonly SidebarProcess[];
 };
-interface SidebarConnection {
+export interface SidebarConnection {
+    id?: import('../connections-health.js').ConnectionHealthServiceId | undefined;
+    healthStatus?: import('../connections-health.js').ConnectionHealthStatus | undefined;
     name: string;
     status: 'ok' | 'warn' | 'down' | 'unknown';
     latencyMs?: number | undefined;

package/dist/hooks/use-skill-mention-picker.d.ts

@@ -0,0 +1,6 @@
+import type { SkillLoader } from '@wrongstack/core/types';
+import { type Dispatch } from 'react';
+import type { Action } from '../app-action-type.js';
+import type { State } from '../app-state.js';
+export declare function useSkillMentionPicker(state: State, loader: SkillLoader | undefined, dispatch: Dispatch<Action>): void;
+//# sourceMappingURL=use-skill-mention-picker.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-statusbar-view-model.d.ts

@@ -34,12 +34,12 @@ interface StatusbarViewModelOptions {
      */
     tokenRefresh?: TokenRefreshData;
 }
-interface PlanCounts {
+export interface PlanCounts {
     open: number;
     inProgress: number;
     done: number;
 }
-interface TaskCounts {
+export interface TaskCounts {
     pending: number;
     inProgress: number;
     completed: number;

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';
 } | {

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

@@ -61,7 +61,7 @@ export interface UseWindowedPickerOptions {
      * 24-row terminal even when the input bar or status bar grows.
      */
     readonly maxRows?: number | undefined;
-    /** Minimum visible options even on a tiny terminal. Defaults to 3. */
+    /** Legacy minimum without a measured maxRows budget. Defaults to 3. */
     readonly minVisible?: number | undefined;
 }
 export interface WindowedPickerSlice {
@@ -82,9 +82,8 @@ export interface WindowedPickerSlice {
  * Behavior contract:
  *   - Visible count is `floor((available - chrome - markers) / rowSpan)`
  *     where `available` is either `maxRows` (measured) or
- *     `rows - shellReservedRows` (guessed), clamped to `[minVisible, total]`.
- *     A 1-row terminal always shows at least `minVisible` options even if
- *     that overflows — better to bleed than to hide the focused row.
+ *     `rows - shellReservedRows` (guessed). Measured budgets show at least
+ *     one focused option; only the legacy guessed budget uses minVisible.
  *   - The window stays centered on `selected` once the picker is past the
  *     first page; on the first page it stays top-aligned so the user sees
  *     the list start. `selected < 0 || selected >= total` is treated as no