@wrongstack/tui 0.73.1 → 0.82.6

package/README.md

@@ -31,7 +31,6 @@ const exitCode = await runTui({
   family: 'anthropic',
   keyTail: '…ABC',
   effectiveMaxContext: 200_000,
-  altScreen: true,
 });
 
 process.exit(exitCode);
@@ -76,24 +75,16 @@ process.exit(exitCode);
 | `Esc` | Close any picker / dialog / agents monitor |
 | `Ctrl+L` | Clear screen (TUI keeps state — equivalent to scrolling) |
 
-Keyboard shortcuts (always available in managed/alt-screen mode):
-- **PgUp/PgDn** — page scroll through chat history.
-- **Home/End** — jump to top/bottom of chat history (when input is empty); move cursor to start/end of line (when typing).
-- **Ctrl+Home/End** — jump to top/bottom of chat history (always, even when typing).
-- **↑/↓** — navigate input history when buffer is empty.
-
 ## Options worth knowing
 
-- **`altScreen: true`** (default) — render into the terminal's alternate screen buffer (vim/less/htop style). The TUI owns the whole viewport, native scrollback is untouched, and the live region cannot leak into terminal history. Raw mode plus alt-screen also means every keystroke — including Ctrl+S, Ctrl+Q, Ctrl+Z, Ctrl+\\ — reaches Ink instead of being consumed by the terminal driver (`runTui` additionally registers no-op handlers for `SIGTSTP`/`SIGQUIT`/`SIGTTIN`/`SIGTTOU` as belt-and-suspenders). Set `false` (or pass `--no-alt-screen`) to render into normal scrollback if you specifically want completed chat to survive after exit; the trade-off is the documented live-region leak on resize / overlay-close / picker-submit, and that some shortcuts may fall through to the terminal.
 - **`effectiveMaxContext`** — the context-bar denominator. Pass the model-specific value resolved via `ModelsRegistry`, not the family baseline; the 1M Opus variant has a much larger window than the 200k default.
 - **`queueStore`** — if set, queued input survives a crash. Without it, queued lines are in-memory only.
 - **`onClearHistory`** — invoked from the `/clear` slash command so the TUI can wipe its rendered history entries (keeping just the banner) while `Agent`/memory reset happens elsewhere.
-- **`onAfterExit`** — called once the alt-screen has been restored on clean shutdown. Use it to print "session saved" hints into the user's normal terminal (alt-screen exit erases the TUI view).
 
 ## Architecture
 
 ```
-runTui                — entry; sets up bracketed paste, alt-screen, signal handlers
+runTui                — entry; sets up bracketed paste, signal handlers
   ↓
 App (React component) — useReducer-driven state machine
   ↓ dispatches events to ↓
@@ -102,6 +93,11 @@ EventBus              — agent.run() emits these, the TUI subscribes
 
 State is a single `useReducer` `State` shape with discriminated-union `Action`s. The reducer is exported (`reducer`) and unit-tested.
 
+## React Version
+
+TUI remains on React 18 because ink v5 does not yet fully support React 19.
+WebUI uses React 19. This is a known divergence tracked in this codebase.
+
 ## License
 
 MIT

package/dist/index.d.ts

@@ -10,7 +10,29 @@ interface ProviderOption {
     /** Model ids the picker offers in step 2 for this provider. */
     models: string[];
     /** Optional dim hint shown next to the model list (e.g. "from saved config"). */
-    modelsLabel?: string;
+    modelsLabel?: string | undefined;
+}
+
+interface Settings {
+    mode: 'off' | 'suggest' | 'auto';
+    delayMs: number;
+    titleAnimation: boolean;
+    yolo: boolean;
+    streamFleet: boolean;
+    chime: boolean;
+    confirmExit: boolean;
+    nextPrediction: boolean;
+    featureMcp: boolean;
+    featurePlugins: boolean;
+    featureMemory: boolean;
+    featureSkills: boolean;
+    featureModelsRegistry: boolean;
+    contextAutoCompact: boolean;
+    contextStrategy: 'hybrid' | 'intelligent' | 'selective';
+    logLevel: 'error' | 'warn' | 'info' | 'debug' | 'trace';
+    auditLevel: 'minimal' | 'standard' | 'full';
+    indexOnStart: boolean;
+    maxIterations: number;
 }
 
 interface RunTuiOptions {
@@ -18,57 +40,57 @@ interface RunTuiOptions {
     slashRegistry: SlashCommandRegistry;
     attachments: AttachmentStore;
     events: EventBus;
-    tokenCounter?: TokenCounter;
-    visionAdapters?: VisionAdapters;
+    tokenCounter?: TokenCounter | undefined;
+    visionAdapters?: VisionAdapters | undefined;
     /** Resolve current model vision support. Falls back to provider capability when omitted. */
-    supportsVision?: () => boolean | Promise<boolean>;
+    supportsVision?: (() => boolean | Promise<boolean>) | undefined;
     model: string;
-    banner?: boolean;
+    banner?: boolean | undefined;
     /** Persists the input queue across crashes; if omitted, the queue is in-memory only. */
-    queueStore?: QueueStore;
+    queueStore?: QueueStore | undefined;
     /** Surfaces the "⚠ YOLO" chip in the status bar. */
-    yolo?: boolean;
+    yolo?: boolean | undefined;
     /** Query live YOLO state from the permission policy. */
-    getYolo?: () => boolean;
+    getYolo?: (() => boolean) | undefined;
     /** Query the live autonomy mode. */
-    getAutonomy?: () => 'off' | 'suggest' | 'auto' | 'eternal' | 'eternal-parallel';
+    getAutonomy?: (() => 'off' | 'suggest' | 'auto' | 'eternal' | 'eternal-parallel') | undefined;
     /**
      * Access the eternal-autonomy engine. When autonomy mode flips to
      * 'eternal' the TUI drives `runOneIteration()` from the post-slash hook
      * so the engine and TUI never race for the shared Context.
      */
-    getEternalEngine?: () => _wrongstack_core.EternalAutonomyEngine | null;
+    getEternalEngine?: (() => _wrongstack_core.EternalAutonomyEngine | null) | undefined;
     /**
      * Access the parallel-eternal engine. When autonomy mode flips to
      * 'eternal-parallel' the TUI drives `runOneIteration()` from the post-slash
      * hook so the engine and TUI never race for the shared Context.
      */
-    getParallelEngine?: () => _wrongstack_core.ParallelEternalEngine | null;
+    getParallelEngine?: (() => _wrongstack_core.ParallelEternalEngine | null) | undefined;
     /**
      * Subscribe to live per-iteration events from the eternal engine.
      * Returns an unsubscribe function. TUI uses this to render each
      * iteration as a live timeline entry as it lands.
      */
-    subscribeEternalIteration?: (fn: (entry: _wrongstack_core.JournalEntry) => void) => () => void;
+    subscribeEternalIteration?: ((fn: (entry: _wrongstack_core.JournalEntry) => void) => () => void) | undefined;
     /**
      * Subscribe to per-iteration stage transitions from the autonomy engines.
      * TUI uses this to render live status in the status bar.
      */
-    subscribeEternalStage?: (fn: (stage: AutonomyStage) => void) => () => void;
+    subscribeEternalStage?: ((fn: (stage: AutonomyStage) => void) => () => void) | undefined;
     /** Renders in the startup banner. Read from the CLI's package.json. */
-    appVersion?: string;
+    appVersion?: string | undefined;
     /** Provider id for the startup banner ("openai", "anthropic", ...). */
-    provider?: string;
+    provider?: string | undefined;
     /** Wire family — shown beneath provider in the banner. */
-    family?: string;
+    family?: string | undefined;
     /** Last 3 chars of the active API key — shown in the banner for visual key-pick verification. */
-    keyTail?: string;
+    keyTail?: string | undefined;
     /** Snapshot of keyed providers + their model lists for the `/model` picker. Async — the catalog fetch may need to hit disk/network. */
-    getPickableProviders?: () => Promise<ProviderOption[]>;
+    getPickableProviders?: (() => Promise<ProviderOption[]>) | undefined;
     /** Apply a (provider, model) pair after the picker confirms. Returns an error string on failure. */
-    switchProviderAndModel?: (providerId: string, modelId: string) => string | null;
+    switchProviderAndModel?: ((providerId: string, modelId: string) => string | null) | undefined;
     /** Apply an autonomy mode after the picker confirms. Returns an error string on failure. */
-    switchAutonomy?: (mode: 'off' | 'suggest' | 'auto' | 'eternal' | 'eternal-parallel') => string | null;
+    switchAutonomy?: ((mode: 'off' | 'suggest' | 'auto' | 'eternal' | 'eternal-parallel') => string | null) | undefined;
     /**
      * Model-specific maxContext (tokens), resolved by the CLI via the
      * ModelsRegistry. When omitted, the TUI falls back to the provider
@@ -76,46 +98,43 @@ interface RunTuiOptions {
      * for variants like the 1M-context Opus build. The status bar's
      * context chip uses this for its progress denominator.
      */
-    effectiveMaxContext?: number;
+    effectiveMaxContext?: number | undefined;
     /** Absolute project root for goal.json loading. */
-    projectRoot?: string;
-    /** Render into the terminal's alternate screen buffer (like vim/less/htop).
-     * Default: false — native scrollback stays live so chat history is
-     * scrollable (wheel / Shift+PgUp), which matches the user's
-     * "this is a chat app, let me scroll the chat" intuition. Pass true
-     * (or run with `--alt-screen`) for the full-screen mode that owns the
-     * terminal and prevents resize/overlay leaks of the live region —
-     * trade-off is that the terminal's native scrollback is suspended
-     * while the TUI is up and only what's currently on screen is visible.
-     */
-    altScreen?: boolean;
-    /**
-     * Called right after we exit the alt-screen on a clean shutdown. The
-     * CLI uses this to print a one-line "session saved to …" hint into
-     * the user's normal terminal, since alt-screen exit erases the whole
-     * TUI view.
-     */
-    onAfterExit?: () => void;
+    projectRoot?: string | undefined;
+    /**
+     * Terminal title animation on/off. Defaults to true. When false, the
+     * OSC-0 window/tab title stays static (the app name only, no spinner).
+     * Controlled via /settings → Terminal title animation.
+     */
+    titleAnimation?: boolean | undefined;
+    /** Play terminal bell (\\x07) when agent run completes. */
+    chime?: boolean | undefined;
+    /** Show "confirm exit" message on first Ctrl+C instead of "exit". */
+    confirmExit?: boolean | undefined;
+    /** Active agent mode label shown in the status bar (e.g. "teach", "brief"). */
+    modeLabel?: string | undefined;
+    /** Live getter for the agent mode label so the status bar updates after /mode. */
+    getModeLabel?: (() => string) | undefined;
     /** Called from /clear so the TUI can wipe its history entries while agent.ctx + memory are cleared separately. */
-    onClearHistory?: (dispatch: React.Dispatch<{
+    onClearHistory?: ((dispatch: React.Dispatch<{
         type: 'clearHistory';
     } | {
         type: 'resetContextChip';
-    }>) => void;
+    }>) => void) | undefined;
     /**
      * Live director instance. When set, the TUI renders a fleet panel
      * showing every spawned subagent, its current task, streaming output,
      * and runtime cost — updated live from the FleetBus. Pass null or omit
      * when multi-agent / director mode is disabled.
      */
-    director?: Director | null;
+    director?: Director | null | undefined;
     /**
      * Optional roster reference for resolving subagent role ids to
      * human-readable names. Same value passed to director.tools().
      */
     fleetRoster?: Record<string, {
         name: string;
-    }>;
+    }> | undefined;
     /**
      * Shared controller for the `/fleet stream on|off` toggle. The slash
      * command runs in the CLI process and needs to flip TUI reducer state;
@@ -131,7 +150,17 @@ interface RunTuiOptions {
     fleetStreamController?: {
         enabled: boolean;
         setEnabled: (enabled: boolean) => void;
-    };
+    } | undefined;
+    /**
+     * Controller for the `/enhance on|off` prompt-refinement toggle. The App
+     * installs a dispatch-backed `setEnabled` here on mount so the slash command
+     * (run in the CLI process) flips the TUI's reducer flag. Mirrors
+     * `fleetStreamController`.
+     */
+    enhanceController?: {
+        enabled: boolean;
+        setEnabled: (enabled: boolean) => void;
+    } | undefined;
     /**
      * Controller for status bar hidden items. App installs a dispatch-backed
      * setter on mount so the /statusline slash command can update the TUI's
@@ -148,7 +177,7 @@ interface RunTuiOptions {
     agentsMonitorController?: {
         visible: boolean;
         setVisible: (visible: boolean) => void;
-    };
+    } | undefined;
     /**
      * If set, the App boots straight into goal mode — the text is wrapped
      * in the GOAL preamble and submitted as the first turn. Lets users
@@ -157,62 +186,56 @@ interface RunTuiOptions {
      * The chat shows a one-line "🎯 Goal locked: …" hint; the actual
      * preamble is hidden from the visible history (same as `/goal`).
      */
-    initialGoal?: string;
+    initialGoal?: string | undefined;
     /**
      * If set, submitted as the first turn verbatim (no preamble). Mainly
      * for scripted shell aliases — `wstack --tui --ask "summarize foo.md"`
      * — that want one turn pre-populated without the goal-mode framing.
      * Ignored when `initialGoal` is also set.
      */
-    initialAsk?: string;
+    initialAsk?: string | undefined;
     /**
      * Directory containing session JSONL files. Required for rewind
      * functionality. When provided the TUI can list checkpoints and
      * trigger a rewind via `/rewind` or Ctrl+R.
      */
-    sessionsDir?: string;
+    sessionsDir?: string | undefined;
     /**
      * SDD session context getter. When an SDD session is active, returns
      * the AI prompt context to inject into user messages.
      */
-    getSDDContext?: () => string | null;
+    getSDDContext?: (() => string | null) | undefined;
     /**
      * Process AI output for SDD auto-detection (spec, tasks, plan).
      * Returns displayable status messages.
      */
-    onSDDOutput?: (output: string) => Promise<string[]>;
+    onSDDOutput?: ((output: string) => Promise<string[]>) | undefined;
     /**
      * Subscribe to AutoPhase phase/graph events from the PhaseOrchestrator.
      * Returns an unsubscribe function. The TUI uses this to drive the
      * PhaseMonitor and PhasePanel live views via dispatch actions.
      */
-    subscribeAutoPhase?: (handler: (event: string, payload: unknown) => void) => () => void;
+    subscribeAutoPhase?: ((handler: (event: string, payload: unknown) => void) => () => void) | undefined;
     /**
      * Read the persisted autonomy settings (defaultMode, autoProceedDelayMs).
      * Used by the SettingsPicker in the TUI on mount and after Ctrl+S toggle.
      */
-    getSettings?: () => {
-        mode: 'off' | 'suggest' | 'auto';
-        delayMs: number;
-    };
+    getSettings?: (() => Settings) | undefined;
     /**
-     * Persist autonomy settings changes. Returns null on success, or an
+     * Persist settings changes. Returns null on success, or an
      * error string on failure (so the TUI can display it as a hint).
      */
-    saveSettings?: (s: {
-        mode: 'off' | 'suggest' | 'auto';
-        delayMs: number;
-    }) => string | null | Promise<string | null>;
+    saveSettings?: ((s: Settings) => string | null | Promise<string | null>) | undefined;
     /**
      * Predict likely next steps after a completed turn. The CLI wires this from
      * the session provider and the `/next` toggle; it returns [] when prediction
      * is disabled or autonomy isn't 'off'. Display-only — never executed.
      */
-    predictNext?: (input: {
+    predictNext?: ((input: {
         userRequest: string;
         assistantSummary: string;
-    }) => Promise<string[]>;
+    }) => Promise<string[]>) | undefined;
 }
 declare function runTui(opts: RunTuiOptions): Promise<number>;
 
-export { type RunTuiOptions, runTui };
+export { type RunTuiOptions, type Settings, runTui };