@wrongstack/tui 0.298.0 → 0.298.1

package/dist/components/scrollable-history.d.ts

@@ -1,339 +1,11 @@
 import type React from 'react';
-import { type MutableRefObject } from 'react';
-import { EntryHeightCache } from '../height-cache.js';
-import { type RenderGroup } from './history/tool-group.js';
-import { type HistoryEntry, type HistoryProps } from './history.js';
-/**
- * Imperative scroll surface owned by the ScrollableHistory component. The app
- * key/mouse handlers call these instead of dispatching reducer actions: all
- * scroll math needs the live height cache, which lives here, and routing it
- * through app state previously forced totals and offsets to travel through
- * separate commits — the root cause of an entire family of jump bugs.
- */
-export interface HistoryScrollController {
-    /** Scroll by `deltaUp` rows: positive = older content, negative = newer. */
-    scrollBy(deltaUp: number): void;
-    /** Scroll by one viewport page. */
-    scrollPage(dir: 'up' | 'down'): void;
-    /** Jump to the oldest retained entry. */
-    scrollToTop(): void;
-    /** Re-pin to the newest output. */
-    scrollToBottom(): void;
-    /** Jump to a 0-based cell clicked/dragged on the scrollbar track. */
-    scrollToTrackCell(cell: number): void;
-    /** True while the viewport is scrolled away from the newest output. */
-    isScrolled(): boolean;
-    /**
-     * True when the viewport cell lands on a copyable card's copy icon. Lets the
-     * mouse handler decide synchronously whether to consume the click before
-     * firing the async copy. See {@link copyAtViewportCell} for the `row`/`col`
-     * coordinate contract.
-     */
-    hasCopyTargetAt(row: number, col: number): boolean;
-    /**
-     * Handle a left-click inside the history viewport. `row` is 0-based from the
-     * viewport top; `col` is 0-based from the LEFT EDGE OF THE HISTORY BAND, not
-     * the raw terminal column. In the interactive mount the band renders flush at
-     * terminal column 0 (the scrollbar occupies the rightmost columns), so the
-     * caller passes the terminal column directly; a band that is inset from the
-     * left must subtract its left offset first. When the cell lands on a copyable
-     * card's copy icon, its content is written to the system clipboard and the
-     * entry id is returned; otherwise returns null.
-     */
-    copyAtViewportCell(row: number, col: number): Promise<number | null>;
-    /**
-     * Begin a drag-to-select gesture at `row`,`col` (history-band viewport cell).
-     * The cell must be inside a card's row range and inside the rendered band
-     * (`0 <= col < termWidth`); the mouse handler has already excluded the rail.
-     * Calls that don't satisfy that contract are silently ignored. Existing
-     * scrollbar/copy-icon/wheel paths remain intact because they call their own
-     * handlers; this only kicks in when the mouse layer explicitly routes a
-     * left-press into the card band.
-     */
-    beginSelection(row: number, col: number): void;
-    /**
-     * Extend an active selection to `row`,`col`. If no selection is in progress,
-     * the call is a no-op. Crossing into the gutter or below the viewport cancels
-     * the drag internally — leaving stale viewport-relative coords around after
-     * a mid-drag escape would let the next right-click paste from the wrong
-     * card, which is the worse failure mode than the selection disappearing.
-     */
-    extendSelection(row: number, col: number): void;
-    /**
-     * End an active drag (left-release). Does NOT write to the clipboard — the
-     * copy is performed by {@link commitSelection}, which is triggered by a
-     * separate right-click in the history band (per the drag-select-then-commit
-     * contract). If no selection is in progress, the call is a no-op.
-     */
-    endSelection(): void;
-    /** Drop any in-progress or committed selection without copying. */
-    clearSelection(): void;
-    /**
-     * Commit the active selection to the system clipboard. Returns true if a
-     * non-empty selection was resolved and the write succeeded. Returns false
-     * silently when there is no selection, the selection is empty (e.g. the drag
-     * never moved), or the write fails — the caller can show a transient notice
-     * on the truthy branch and stay silent on the falsy branch.
-     */
-    commitSelection(): Promise<boolean>;
-}
-/**
- * A clickable copy-icon target resolved in viewport coordinates during the
- * post-render measurement pass. `entryId` identifies a single card or the first
- * member of a compact tool group; `entryIds` contains every group member when
- * present. `startRow`/`endRow` bound the box's visible rows (0-based from the
- * viewport top, `endRow` exclusive); `iconCol` is the 0-based terminal column
- * the icon renders at on the box's first visible row.
- */
-export interface CopyHit {
-    entryId: number;
-    entryIds?: readonly number[] | undefined;
-    startRow: number;
-    endRow: number;
-    iconCol: number;
-}
-/** Sentinel returned after copying the active, non-retained tool-stream box. */
-export declare const LIVE_TOOL_STREAM_COPY_ID = -1;
-/** Sentinel returned after copying a drag-select-then-right-click selection.
- *  Distinct from any retained entry id so the host can render a different
- *  status-line notice ("Selected range copied") without flashing a specific
- *  card's copy icon (which only makes sense when a single entry was copied). */
-export declare const SELECTION_COPY_ID = -2;
-/**
- * Resolve the copy target under a viewport cell, or null. A cell matches when
- * its `row` is within the card's visible rows and its `col` is within the
- * icon's cell span. Iterates newest-first so overlapping row estimates favor
- * the most recently rendered card. Exported-shape pure helper for unit tests.
- */
-export declare function findCopyHit(hits: readonly CopyHit[], row: number, col: number): CopyHit | null;
-/** Resolve a hit to the complete current clipboard payload without performing I/O. */
-export declare function resolveCopyPayload(hit: CopyHit, entriesById: ReadonlyMap<number, HistoryEntry>, liveToolText?: string | undefined): {
-    entryId: number;
-    text: string;
-} | null;
-/**
- * Rows clipped from the top of the mounted history stack before it appears in
- * the viewport. Scrolled frames clip by the anchor's row offset; pinned frames
- * rely on Ink flex-end clipping, which hides top overflow from mounted groups
- * plus the live tool tail.
- */
-export declare function copyRegistryVisibleClip(opts: {
-    scrolled: boolean;
-    clip: number;
-    mountedRows: number;
-    tailRows: number;
-    viewportRows: number;
-}): number;
-/** Build the live tool-stream header hit, accounting for ToolStreamBox's top margin.
- *  The `pinnedSlack` offset must match {@link buildCopyRegistry}'s card-hit math so
- *  the live-stream icon stays visually aligned with its header row in underfilled
- *  pinned frames (flex-end parks the mounted stack at the bottom of the viewport). */
-export declare function liveToolStreamCopyHit(opts: {
-    visible: boolean;
-    mountedRows: number;
-    visibleClip: number;
-    viewportRows: number;
-    iconCol: number;
-    pinnedSlack?: number;
-}): CopyHit | null;
-/**
- * Selection rectangle in viewport cell coordinates, normalized so
- * `topLeft.row <= bottomRight.row` and the column pairs are likewise ordered.
- * Both endpoints are inclusive — the cell at `bottomRight` is selected.
- */
-export interface SelectionRect {
-    topLeft: {
-        row: number;
-        col: number;
-    };
-    bottomRight: {
-        row: number;
-        col: number;
-    };
-    /** True while the user is still dragging; false after left-release but
-     *  before either clearSelection or commitSelection runs. */
-    inProgress: boolean;
-}
-/** Canonicalize two viewport cells into a SelectionRect. Pure. */
-export declare function normalizeSelection(a: {
-    row: number;
-    col: number;
-}, b: {
-    row: number;
-    col: number;
-}, inProgress: boolean): SelectionRect;
-/** True when the column lies outside the rendered card band. Inside the band
- *  the layout reserves `SCROLLBAR_HIT_WIDTH` columns for the rail AFTER the
- *  band, so `0..termWidth-1` is always in-band and nothing inside needs to be
- *  excluded. The mouse handler must already have excluded the rail before
- *  calling into the controller — we only check the band bounds here. */
-export declare function isOutOfBand(col: number, termWidth: number): boolean;
-/**
- * One entry's contribution to a drag-selected range. Returned in document
- * (row-index-in-card) coordinates so the caller decides how to slice into
- * the entry's source text. `start` is the column inside the card (0-based
- * from the left edge of the card's visible rectangle, NOT the terminal
- * column — the gutter is excluded by the caller before reaching here).
- * `end` is inclusive. When `startRow === endRow`, the slice is one row; the
- * caller is responsible for translating text columns into source offsets.
- */
-export interface SelectionSlice {
-    entryId: number;
-    /** Inclusive row-in-card for the start of the slice. */
-    startRow: number;
-    /** Inclusive column, 0-based, inside the card's text area (gutter excluded). */
-    startCol: number;
-    /** Inclusive end row. */
-    endRow: number;
-    /** Inclusive end column, 0-based. */
-    endCol: number;
-}
-/**
- * Translate a viewport-cell selection into per-entry row/col slices, walking
- * the same mounted-group geometry the copy-hit registry uses so the two
- * systems share one row index. Entries wholly outside the selection return
- * nothing. Entries whose vertical span is wholly inside the selection are
- * returned as a single row-range; entries the selection clips at the top or
- * bottom are returned with row bounds matching the clip.
- *
- * `cardVisibleCols` is the number of columns inside the card the user can
- * see — the band width minus the right gutter (`viewportWidth - SCROLLBAR_HIT_WIDTH`).
- * Slices never include the gutter or any column to its right; the caller has
- * already validated that.
- *
- * Returned slices are in document (entry-local) coordinates: `startRow`/`endRow`
- * are rows inside the entry's own geometry, NOT viewport cells. This is what
- * the assembler needs to recover text — slicing into the raw entry text uses
- * per-row layout, which the caller resolves via the layout store.
- */
-export declare function selectionToSlices(opts: {
-    selection: SelectionRect;
-    cards: ReadonlyArray<{
-        entryId: number;
-        /** 0-based viewport row of the card's first visible row. */
-        viewportStartRow: number;
-        /** 0-based viewport row just past the card's last visible row. */
-        viewportEndRow: number;
-    }>;
-    cardVisibleCols: number;
-}): SelectionSlice[];
-export interface ScrollableHistoryProps extends HistoryProps {
-    /** Height of the viewport in rows, computed by App from the bottom region. */
-    viewportRows: number;
-    /** Receives the imperative scroll controller. The component assigns on
-     *  mount and clears on unmount. Optional for isolated renderers. */
-    controllerRef?: MutableRefObject<HistoryScrollController | null> | undefined;
-    /** Reports scroll-state transitions (scrolled away from / re-pinned to the
-     *  newest output) so the host can adjust key hints. */
-    onScrollInfo?: ((info: {
-        scrolled: boolean;
-    }) => void) | undefined;
-    /** Optional cap on the width used for entry wrapping (right panel mode). */
-    maxWidth?: number | undefined;
-    /** Layout store for persisting entry height data across renders and sessions.
-     *  When provided, the ScrollableHistory seeds its height cache from the
-     *  store's persisted measurements and marks entries as measured after render,
-     *  eliminating estimate-vs-actual scroll jumps on re-render. */
-    layoutStore?: import('../layout-store.js').LayoutStore | undefined;
-    /**
-     * Entry id of the card whose copy icon was just clicked. That card's icon
-     * renders in the success color for the brief window the host keeps this set,
-     * giving per-card visual feedback alongside the status-line "Copied" notice.
-     * `null` / undefined = no card highlighted.
-     */
-    copiedEntryId?: number | null | undefined;
-    /**
-     * Called when the user scrolls near the top of the currently loaded
-     * entries. The host should respond by loading older entries from the
-     * history archive and dispatching `archiveLoaded` to prepend them.
-     */
-    onRequestOlderEntries?: (() => void) | undefined;
-}
-/** Pure thumb geometry for the scrollbar: where the thumb starts and how many
- *  cells it spans, given the track height, scroll offset, and total content
- *  height. Exported for testing. */
-export declare function scrollbarThumb(rows: number, offset: number, total: number): {
-    top: number;
-    size: number;
-    scrollable: boolean;
-};
-/** Inverse of {@link scrollbarThumb}: given a clicked/dragged 0-based cell on a
- *  track of `rows` height, return the scroll offset (rows up from the bottom)
- *  that lands the visible window there. Cell 0 (top) → oldest content (max
- *  offset); cell rows-1 (bottom) → newest (offset 0). Exported for testing. */
-export declare function scrollOffsetForTrackRow(rows: number, total: number, cell: number): number;
-/**
- * Per-card viewport span for the currently-mounted groups. Mirrors
- * {@link buildCopyRegistry}'s visibleClip math so the drag-select gesture asks
- * the same geometry question the copy-hit registry already answers.
- */
-export interface MountedCardSpan {
-    entryId: number;
-    /** 0-based viewport row of the first VISIBLE row of the card. */
-    viewportStartRow: number;
-    /** 0-based viewport row one past the last VISIBLE row of the card. */
-    viewportEndRow: number;
-    /** Card's geometry in rows; visibleClip + scrolled-clip aware. */
-    totalRows: number;
-    entryIds?: readonly number[];
-}
-/**
- * Build per-card viewport spans for every mounted render group. Pure — given
- * the same render-group list, height cache, scroll state, and viewport size,
- * the result is deterministic and matches the copy-hit registry. Exported so
- * tests can verify the span map without mounting the full component.
- */
-export declare function buildMountedCardSpans(opts: {
-    renderGroups: readonly RenderGroup[];
-    heightCache: EntryHeightCache;
-    scrolled: boolean;
-    clip: number;
-    tailRows: number;
-    viewportRows: number;
-    showModelReasoning?: boolean | undefined;
-}): MountedCardSpan[];
-/**
- * Find the card whose viewport row range contains `row`. Pure.
- * Returns null when the row is in a blank gap or outside the viewport.
- */
-export declare function selectionHitAt(row: number, spans: readonly MountedCardSpan[]): {
-    entryId: number;
-    entryIds?: readonly number[];
-} | null;
-/**
- * Build the clipboard payload for a selection by slicing into each affected
- * entry's full renderable text. The v1 contract is line-then-column on the
- * entry's source text: each slice exposes `startRow`/`endRow` and
- * `startCol`/`endCol` in card-local coordinates; we split the entry's
- * text on `\n`, keep only the rows inside the row range, and within those
- * rows apply the column range. The matrix matches what the source line
- * index would be when no wrapping occurs — i.e. one card row maps to one
- * source line. Wrap-geometry translation is intentionally absent in v1
- * because the layout store does not yet expose per-card-row wrap segments;
- * it returns when those segments exist and a v1.1 test demands it.
- *
- * `toolGroupsByHeadId` lets a multi-member tool-group expand: when the
- * head id appears with `entryIds.length > 1`, the assembler copies via
- * `copyableTextForEntries` (raw ordered JSON of every member, matching
- * the existing copy-icon contract). A single-entry head falls through
- * to `copyableTextForEntry`.
- *
- * Multi-entry selections are joined with `\n---\n` so the user can see
- * where one card ends and the next begins. Empty selections and
- * selections that resolve to no text return `""` so the caller can fall
- * through silently.
- */
-export declare function assembleSelectionText(opts: {
-    slices: readonly SelectionSlice[];
-    entriesById: ReadonlyMap<number, HistoryEntry>;
-    /**
-     * For each tool-group head id present in `slices`, the ordered member list.
-     * When a head has a multi-member group, the assembler slices into the
-     * group's combined text via `copyableTextForEntries`. A single-entry
-     * head falls through to `copyableTextForEntry`.
-     */
-    toolGroupsByHeadId?: ReadonlyMap<number, readonly number[]> | undefined;
-}): string;
+import { type HistoryEntry } from './history.js';
+export type { HistoryScrollController, ScrollableHistoryProps, } from './history/scroll-controller-types.js';
+export { type CopyHit, LIVE_TOOL_STREAM_COPY_ID, SELECTION_COPY_ID, findCopyHit, resolveCopyPayload, copyRegistryVisibleClip, liveToolStreamCopyHit, } from './history/copy-geometry.js';
+export { type SelectionRect, type SelectionSlice, normalizeSelection, isOutOfBand, selectionToSlices, assembleSelectionText, } from './history/selection-helpers.js';
+export { type MountedCardSpan, scrollbarThumb, scrollOffsetForTrackRow, buildMountedCardSpans, selectionHitAt, } from './history/scrollbar-geometry.js';
+export { Scrollbar } from './history/scrollbar-rail.js';
+import type { ScrollableHistoryProps } from './history/scroll-controller-types.js';
 /**
  * Bounded history viewport with stable-anchor virtual scrolling.
  *

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

@@ -180,7 +180,7 @@ export type SettingsPickerPatch = Partial<{
     breakerEnabled: boolean;
     breakerAutoKillResetMs: number;
     showModelReasoning: boolean;
-    showAgentSwarmPanel: boolean;
+    showAgentSwarmPanel: import('../app-settings-type.js').AgentSwarmPanelMode;
     readSymbols: boolean;
     showSageMemoryInject: boolean;
     sageMemoryInjectThreshold: number;

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

@@ -64,11 +64,11 @@ export interface SettingsPickerProps {
     /** Show the "Model Reasoning" blocks in chat history. Default: true. */
     showModelReasoning: boolean;
     /**
-     * Show the persistent FleetPanel below the status bar, including AGENT SWARM
-     * activity and its todo mission queue. Full-screen agent/queue/goal overlays
-     * remain independently available through their panel shortcuts. Default: true.
+     * Show the Mission Queue section (todo items) in the right sidebar. The
+     * lower-region FleetPanel is always visible when there is fleet activity;
+     * this toggle controls only the sidebar mission queue. Default: 'bottom'.
      */
-    showAgentSwarmPanel: boolean;
+    showAgentSwarmPanel: import('../app-settings-type.js').AgentSwarmPanelMode;
     /** Show SAGE Memory Inject blocks in tool results. Default: false. */
     showSageMemoryInject: boolean;
     /** Minimum relation strength for SAGE memory injection. Default: 0.85. */

package/dist/components/sidebar-content.d.ts

@@ -0,0 +1,47 @@
+import type { ResumeSessionEntry } from '../app-state.js';
+import type { FleetEntry } from '../app-state-fleet.js';
+import type { TodoItem } from '@wrongstack/core/agent';
+import type React from 'react';
+import type { LiveSessionEntry } from './sessions-panel.js';
+export interface SidebarContentProps {
+    /** Live context window data from useStatusbarViewModel. */
+    contextWindow: {
+        used: number;
+        max: number;
+    } | undefined;
+    /** Fleet entries (leader + subagents) from useStatusbarViewModel. */
+    entries: Record<string, FleetEntry>;
+    /** Fleet counts summary. */
+    fleetCounts: {
+        running: number;
+        idle: number;
+        pending: number;
+        completed: number;
+    } | undefined;
+    /** Current provider label for display. */
+    provider?: string | undefined;
+    /** Current model label for display. */
+    model?: string | undefined;
+    /** Actual sidebar width in columns (including border+padding chrome).
+     *  Used to size the content area and truncate text appropriately. */
+    width: number;
+    /** Vertical scroll offset — number of rows scrolled from the top. */
+    scrollOffset?: number | undefined;
+    /** When true, the sidebar has keyboard focus (↑↓ scroll). */
+    focused?: boolean | undefined;
+    /** Live leader todo board — rendered as a compact mission queue. */
+    todos?: readonly TodoItem[] | undefined;
+    /** When true, show the agent-swarm + mission-queue section. Gated by the
+     *  effective agent-swarm panel mode being 'sidebar' (see app-view.tsx). */
+    showSwarmSection?: boolean | undefined;
+    /** Live sessions from the SessionRegistry — same data as the F10 panel.
+     *  Shown as compact "live" rows with project name + status + agent count. */
+    liveSessions?: readonly LiveSessionEntry[] | undefined;
+    /** Recent stored sessions for the `/resume` picker. Shown as compact rows
+     *  with title + last-activity + outcome badge. */
+    resumeSessions?: readonly ResumeSessionEntry[] | undefined;
+    /** The current session ID — used to highlight the active session row. */
+    currentSessionId?: string | undefined;
+}
+export declare function SidebarContent({ contextWindow, entries, fleetCounts, provider, model, width, scrollOffset, focused, todos, showSwarmSection, liveSessions, resumeSessions, currentSessionId, }: SidebarContentProps): React.ReactElement;
+//# sourceMappingURL=sidebar-content.d.ts.map

package/dist/components/sidebar.d.ts

@@ -0,0 +1,40 @@
+import type React from 'react';
+/** Terminal widths below this hide the sidebar entirely. */
+export declare const SIDEBAR_MIN_TERMINAL = 64;
+/** Smallest sidebar width (in columns) when visible. */
+export declare const SIDEBAR_MIN_WIDTH = 20;
+/** Largest sidebar width (in columns). */
+export declare const SIDEBAR_MAX_WIDTH = 48;
+/** Fraction of terminal width to allocate to the sidebar. */
+export declare const SIDEBAR_FRACTION = 0.25;
+/**
+ * Compute the sidebar width in columns for a given terminal width.
+ * Returns 0 when the terminal is too narrow for a sidebar.
+ *
+ * Pure — no React, no Ink — so callers can use the same value for layout
+ * math (e.g. narrowing the history column) without mounting the component.
+ */
+export declare function computeSidebarWidth(termCols: number): number;
+export interface RightSidebarProps {
+    /**
+     * Optional explicit width override (in columns). When omitted, the width
+     * is derived from the current terminal width via {@link computeSidebarWidth}.
+     */
+    width?: number | undefined;
+    /**
+     * Maximum height in rows. Content beyond this is clipped (scroll handled
+     * by the caller via scrollOffset). When omitted, no height cap is applied.
+     */
+    maxHeight?: number | undefined;
+    /**
+     * When true, the sidebar border is highlighted to indicate keyboard focus.
+     */
+    focused?: boolean | undefined;
+    /**
+     * Content to render inside the sidebar. When omitted, a dimmed placeholder
+     * label is shown so the reserved region is visually self-documenting.
+     */
+    children?: React.ReactNode | undefined;
+}
+export declare function RightSidebar({ width, maxHeight, focused, children }: RightSidebarProps): React.ReactElement | null;
+//# sourceMappingURL=sidebar.d.ts.map

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

@@ -58,6 +58,16 @@ export declare function stateChip(state: 'idle' | 'running' | 'streaming' | 'abo
 export declare function renderProgress(ratio: number, width: number): string;
 export declare function contextBarColor(ratio: number): string;
 export declare function renderMeter(ratio: number, width: number): string;
+/**
+ * Block-style meter for the sidebar — a solid fill (`█`) plus an empty track
+ * (`░`). Returned as two segments so the caller can color the fill (e.g. by
+ * context pressure via {@link contextBarColor}) independently of the dim track.
+ * Width-safe: `filled.length + empty.length === max(1, width)` always holds.
+ */
+export declare function blockMeter(ratio: number, width: number): {
+    filled: string;
+    empty: string;
+};
 export declare function fmtTok(n: number): string;
 export declare function fmtMemory(bytes: number): string;
 export declare function fmtElapsed(ms: number): string;

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

@@ -372,5 +372,12 @@ export interface StatusBarProps {
      * Clicking opens /audit (TUI) — in the REPL it's informational.
      */
     sideEffectCount?: number | undefined;
+    /**
+     * Optional cap on the column width used for layout adaptation. When set,
+     * the status bar treats this as its effective terminal width instead of
+     * `stdout.columns` — needed when the bar sits in a column narrower than
+     * the full terminal (e.g. beside a sidebar).
+     */
+    maxWidth?: number | undefined;
 }
 //# sourceMappingURL=status-bar-types.d.ts.map

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

@@ -11,5 +11,5 @@ export declare const COMPACT_THRESHOLD = 50;
  * to show — git branch, elapsed time, todo counts, YOLO marker — so a
  * vanilla session keeps the original single-line footprint.
  */
-export declare function StatusBar({ 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, processMemory, cpuPercent, context, estimatedContextTokens, Sage, memoryContextMonitor, contextStrategy, hiddenItems, mode, events, sessionId, eternalStage, goalSummary, droppedTools, indexState, breakerCountdown, modeLabel, debugStreamStats, enhanceCountdown, nextStepsAutoSubmitCountdown, nextStepsAutoSubmitLabel, autoProceedCountdown, sessionCount, mailbox, tokenSavingMode, toolCount, visibleChips, sideEffectCount, }: StatusBarProps): React.ReactElement;
+export declare function StatusBar({ 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, processMemory, cpuPercent, context, estimatedContextTokens, Sage, memoryContextMonitor, contextStrategy, hiddenItems, mode, events, sessionId, eternalStage, goalSummary, droppedTools, indexState, breakerCountdown, modeLabel, debugStreamStats, enhanceCountdown, nextStepsAutoSubmitCountdown, nextStepsAutoSubmitLabel, autoProceedCountdown, sessionCount, mailbox, tokenSavingMode, toolCount, visibleChips, sideEffectCount, maxWidth, }: StatusBarProps): React.ReactElement;
 //# sourceMappingURL=status-bar.d.ts.map

package/dist/hit-test.d.ts

@@ -40,9 +40,10 @@ export type HitRegion =
 };
 /**
  * Columns at the right edge of the history viewport reserved for the copy/scroll
- * rail. Copy icons use the first column and the scrollbar track uses the last.
+ * rail. Copy icons use the first column, a blank gap separates them from the
+ * scrollbar track in the last column.
  */
-export declare const SCROLLBAR_HIT_WIDTH = 2;
+export declare const SCROLLBAR_HIT_WIDTH = 3;
 /** Rows available to managed history after reserving the measured bottom UI. */
 export declare function historyViewportRows(termRows: number, bottomHeight: number): number;
 /**

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

@@ -1,6 +1,6 @@
 import { type Dispatch, type MutableRefObject, type SetStateAction } 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 MemoryContextMonitorState } from '../memory-context-monitor.js';
 interface ProviderEventBridgeOptions {
     events: AppProps['events'];