@wrongstack/tui 0.298.0 → 0.298.2

package/dist/app-action-type.d.ts

@@ -279,7 +279,8 @@ export type Action = {
     breakerEnabled: boolean;
     breakerAutoKillResetMs: number;
     showModelReasoning: boolean;
-    showAgentSwarmPanel: boolean;
+    showAgentSwarmPanel: import('./app-settings-type.js').AgentSwarmPanelMode;
+    panelPositions: import('./ui-contracts.js').PanelPositionMap;
     readSymbols: boolean;
     showSageMemoryInject: boolean;
     sageMemoryInjectThreshold: number;
@@ -929,6 +930,20 @@ export type Action = {
 /** Close every open panel/monitor/overlay at once. */
  | {
     type: 'closeAllPanels';
+}
+/** Toggle keyboard focus between input and the right sidebar. */
+ | {
+    type: 'toggleSidebarFocus';
+}
+/** Scroll the sidebar content by delta rows (clamped to >=0). */
+ | {
+    type: 'sidebarScroll';
+    delta: number;
+    viewportHeight?: number | undefined;
+}
+/** Reset sidebar scroll offset to 0. */
+ | {
+    type: 'sidebarScrollReset';
 } | {
     type: 'toggleKanbanPanel';
 } | {

package/dist/app-key-handler.d.ts

@@ -47,6 +47,10 @@ interface AppKeyHandlerOptions {
     termRows: number;
     terminalColumns: number;
     terminalRows: number;
+    /** Width of the main column (terminal width minus sidebar). When > 0,
+     *  scrollbar hit-tests use this instead of terminalColumns so the scrollbar
+     *  track is correctly positioned to the left of the sidebar. */
+    mainColumnWidth: number;
     statusBarWrapRef: MutableRefObject<DOMElement | null>;
     belowStatusBarRef: MutableRefObject<DOMElement | null>;
     liveStatuslineMode: string;

package/dist/app-settings-type.d.ts

@@ -1,5 +1,22 @@
 import type { FleetChatVerbosity, TokenSavingTier } from '@wrongstack/core/types';
 import type { CacheTtl, ContextMode, ReasoningEffort, StatuslineMode } from './settings-contracts.js';
+export type { PanelId, PanelPosition, PanelPositionMap } from './ui-contracts.js';
+export { coercePanelPositionMap, DEFAULT_PANEL_POSITIONS, PANEL_IDS, } from './ui-contracts.js';
+import type { PanelPositionMap } from './ui-contracts.js';
+/** Where to render the agent swarm panel: lower region, sidebar, or hidden. */
+export type AgentSwarmPanelMode = 'bottom' | 'sidebar' | 'off';
+/**
+ * Coerce a persisted showAgentSwarmPanel value (which may be a legacy boolean
+ * or the new tri-state string) into a valid AgentSwarmPanelMode.
+ * - true / undefined → 'bottom' (default)
+ * - false → 'off'
+ * - Valid string ('bottom' | 'sidebar' | 'off') → returned as-is
+ * - Any other string → 'bottom' (safe fallback)
+ *
+ * This is the single canonical coercion — all read sites should call this
+ * rather than re-implementing the mapping to avoid divergent defaults.
+ */
+export declare function coerceAgentSwarmMode(v: boolean | AgentSwarmPanelMode | string | undefined): AgentSwarmPanelMode;
 export type Settings = {
     mode: 'off' | 'suggest' | 'auto';
     delayMs: number;
@@ -56,8 +73,19 @@ export type Settings = {
     /** Single word shown in the TUI rainbow working-state chip. */
     thinkingWord: string;
     showModelReasoning: boolean;
-    /** Show the persistent AGENT SWARM and todo mission queue panel. Default: true. */
-    showAgentSwarmPanel: boolean;
+    /** Agent swarm panel placement: 'bottom' (lower region), 'sidebar' (right
+     *  sidebar, vertical), or 'off' (hidden). Default: 'bottom'.
+     *  Backward-compat: old boolean configs are coerced — true→'bottom', false→'off'. */
+    showAgentSwarmPanel: AgentSwarmPanelMode;
+    /**
+     * Per-panel position map. Each F-key panel can be set to 'bottom' (F-key
+     * behavior, the default) or 'sidebar' (rendered in the right sidebar).
+     * The map is always normalized to a full PanelPositionMap at boot via
+     * {@link coercePanelPositionMap}. Optional at the persisted-Settings
+     * boundary so older configs without the key don't typecheck-fail; the
+     * live-settings coercion always fills in a full map.
+     */
+    panelPositions?: Partial<PanelPositionMap>;
     /** Show SAGE Memory Inject blocks in tool results. Default: false (hidden). */
     showSageMemoryInject: boolean;
     /** Minimum relation strength for SAGE memory injection. Default: 0.85. */

package/dist/app-state.d.ts

@@ -7,7 +7,7 @@ import type { BrainLogEntry, BrainRiskLevel } from './brain-contracts.js';
 import type { BrainPanelSettings } from './brain-panel-model.js';
 import type { HistoryEntry } from './history-entry.js';
 import type { AuditLevel, CacheTtl, CompactorStrategy, ContextMode, LogLevel, ReasoningEffort, SettingsMode, StatuslineMode } from './settings-contracts.js';
-import type { AutonomyOption, ChipMeta, HelpEntry, LiveSessionEntry, McpPickerItem, ModeOption, PluginPickerItem, ProjectPickerItem, PromptPickEntry, ProviderOption, RefineFailureDecision, RefineFailureModel, SendMode, ShadowState, StatuslineItem, ToolPickerItem, WorktreeRow } from './ui-contracts.js';
+import type { AutonomyOption, ChipMeta, HelpEntry, LiveSessionEntry, McpPickerItem, ModeOption, PanelPositionMap, PluginPickerItem, ProjectPickerItem, PromptPickEntry, ProviderOption, RefineFailureDecision, RefineFailureModel, SendMode, ShadowState, StatuslineItem, ToolPickerItem, WorktreeRow } from './ui-contracts.js';
 export type { Settings } from './app-settings-type.js';
 export type { DraftEntry, GoalSummary, QueueItem, ResumeSessionEntry, SlashCommandMatch, } from './app-state-core-types.js';
 export type { FleetEntry } from './app-state-fleet.js';
@@ -273,9 +273,18 @@ export type State = {
          * (API-level provisioning). Default: true.
          */
         showModelReasoning: boolean;
-        /** Show the persistent AGENT SWARM and todo mission queue panel. Default: true. */
-        showAgentSwarmPanel: boolean;
-        /** Show SAGE Memory Inject blocks in tool results. Default: false. */
+        /** Agent swarm panel placement: 'bottom' (lower region), 'sidebar' (right sidebar), or 'off'. Default: 'bottom'. */
+        showAgentSwarmPanel: import('./app-settings-type.js').AgentSwarmPanelMode;
+        /**
+         * Per-panel position map mirrored from the persisted Settings shape.
+         * Each F-key panel can be set to 'bottom' (F-key behavior, the default)
+         * or 'sidebar' (rendered in the right sidebar). When a panel is set to
+         * 'sidebar' AND its F-key toggle is on, the bottom view hides and the
+         * sidebar shows the panel twin instead. When the F-key is off, neither
+         * surface shows the panel.
+         */
+        panelPositions: PanelPositionMap;
+        /** Show SAGE Memory Inject blocks in tool results. Default: false (hidden). */
         showSageMemoryInject: boolean;
         /** Minimum relation strength for SAGE memory injection. Default: 0.85. */
         sageMemoryInjectThreshold: number;
@@ -616,6 +625,10 @@ export type State = {
     connectionsPanelOpen: boolean;
     /** When true, the sessions panel is shown (F10). */
     sessionsPanelOpen: boolean;
+    /** When true, keyboard focus is on the right sidebar (↑↓ scrolls sidebar content). */
+    sidebarFocused: boolean;
+    /** Vertical scroll offset for the sidebar content (in rows). */
+    sidebarScrollOffset: number;
     /** Live session data for the sessions panel (F10). */
     sessionsPanel: {
         sessions: LiveSessionEntry[];

package/dist/app-status-region.d.ts

@@ -1,5 +1,10 @@
 import type React from 'react';
+import type { AgentSwarmPanelMode } from './app-settings-type.js';
 import type { AppViewProps } from './app-view-contract.js';
-export declare function resolveAgentSwarmPanelVisibility(settingsOpen: boolean, pickerValue: boolean, persistedValue: boolean | undefined): boolean;
-export declare function AppStatusRegion({ host, runtime }: AppViewProps): React.ReactElement;
+export declare function resolveAgentSwarmPanelVisibility(settingsOpen: boolean, pickerValue: AgentSwarmPanelMode, persistedValue: AgentSwarmPanelMode | undefined): AgentSwarmPanelMode;
+export interface AppStatusRegionProps extends AppViewProps {
+    /** Optional column width cap for the status bar (when beside a sidebar). */
+    mainColumnWidth?: number | undefined;
+}
+export declare function AppStatusRegion({ host, runtime, mainColumnWidth }: AppStatusRegionProps): React.ReactElement;
 //# sourceMappingURL=app-status-region.d.ts.map

package/dist/app-ui-state.d.ts

@@ -1,5 +1,29 @@
 import type { State } from './app-reducer.js';
 import type { StatuslineItem } from './components/statusline-picker.js';
+import { type PanelId, type PanelPositionMap } from './ui-contracts.js';
 export declare function mergeStatuslineHiddenItems(hookHidden: StatuslineItem[], reducerHidden: StatuslineItem[]): StatuslineItem[];
+/**
+ * True when any of the legacy picker overlays is open. Note: panel flags
+ * like `state.sessionsPanelOpen` are intentionally NOT included here so
+ * the local `overlayOpen` gate in app-view.tsx can apply its per-panel
+ * routing guard (`!anyRoutedToSidebar(id)`) and let the sidebar twin
+ * render. Adding a new panel-open flag to this list would silently
+ * collapse the sidebar to width 0 and prevent the twin from mounting.
+ */
 export declare function isPickerOverlayOpen(state: State): boolean;
+export interface SidebarLayoutState {
+    panelPositions: PanelPositionMap;
+    overlayOpen: boolean;
+    sidebarWidth: number;
+    /** Width AppView must pass to nested routed sidebar panel frames. */
+    sidebarContentWidth: number;
+    mainColumnWidth: number;
+}
+/**
+ * Resolve the TUI's right-sidebar layout once from the open-panel flags and
+ * persisted panel routing. Both the renderer and input/mouse hit-testing use
+ * this so a sidebar-routed panel narrows history consistently instead of
+ * being treated as a full-width overlay by one surface.
+ */
+export declare function resolveSidebarLayout(state: State, termCols: number, panelPositionsInput: Partial<Record<PanelId, 'bottom' | 'sidebar'>> | undefined, mailboxPanelOpen: boolean): SidebarLayoutState;
 //# sourceMappingURL=app-ui-state.d.ts.map

package/dist/auth-panel-model.d.ts

@@ -68,12 +68,37 @@ export interface AuthPanelHost {
     addKey(providerId: string, io: AuthFlowIo): Promise<AuthFlowResult>;
     updateKey(providerId: string, label: string, io: AuthFlowIo): Promise<AuthFlowResult>;
     editField(providerId: string, field: 'family' | 'baseUrl' | 'models', io: AuthFlowIo): Promise<AuthFlowResult>;
+    /**
+     * Edit a single model's detailed schema fields (ME-5). Opens a field-group
+     * prompt flow covering identity, limits, pricing, modalities, capability
+     * flags, and dates. Validates via the ME-1 zod schema.
+     *
+     * Shows the models.dev catalog reference values alongside the current
+     * values so the user can see what the upstream defaults are and reset
+     * individual fields back to them.
+     */
+    editModelDetails(providerId: string, modelId: string, io: AuthFlowIo): Promise<AuthFlowResult>;
+    /**
+     * Add a model to the provider's allowlist with optional full schema details
+     * (ME-5). When `fromCatalog` is true, prefills from the models.dev registry.
+     */
+    addModel(providerId: string, io: AuthFlowIo, opts?: {
+        fromCatalog?: boolean | undefined;
+    }): Promise<AuthFlowResult>;
+    /** Remove a single model from the provider's allowlist + customModels (ME-5). */
+    removeModel(providerId: string, modelId: string): Promise<string | null>;
+    /**
+     * Reset a model's customModels override back to the models.dev catalog
+     * values (ME-5). Drops the customModels entry for this modelId so the
+     * runtime falls back to the live catalog data.
+     */
+    resetModelToCatalog(providerId: string, modelId: string): Promise<string | null>;
     addCatalogProvider(catalogId: string, io: AuthFlowIo): Promise<AuthFlowResult>;
     addCustomProvider(io: AuthFlowIo): Promise<AuthFlowResult>;
     addLocal(presetId: string, io: AuthFlowIo): Promise<AuthFlowResult>;
     oauthLogin(kind: AuthOAuthKind, io: AuthFlowIo): Promise<AuthFlowResult>;
 }
-export type AuthPanelView = 'list' | 'provider' | 'catalog' | 'local' | 'oauth' | 'flow';
+export type AuthPanelView = 'list' | 'provider' | 'models' | 'catalog' | 'local' | 'oauth' | 'flow';
 export type AuthConfirmAction = {
     kind: 'delete-key';
     providerId: string;
@@ -81,6 +106,10 @@ export type AuthConfirmAction = {
 } | {
     kind: 'remove-provider';
     providerId: string;
+} | {
+    kind: 'remove-model';
+    providerId: string;
+    modelId: string;
 };
 export interface AuthPanelState {
     open: boolean;
@@ -125,7 +154,12 @@ export type AuthPanelRow = {
     keyRow: AuthKeyRow;
 } | {
     kind: 'provider-action';
-    action: 'add-key' | 'edit-family' | 'edit-base-url' | 'edit-models' | 'remove';
+    action: 'add-key' | 'edit-family' | 'edit-base-url' | 'edit-models' | 'edit-model-details' | 'add-model' | 'reset-model-to-catalog' | 'remove' | 'back-to-list';
+} | {
+    kind: 'model-row';
+    providerId: string;
+    modelId: string;
+    name: string;
 } | {
     kind: 'catalog-entry';
     entry: AuthCatalogRow;

package/dist/components/fleet-panel.d.ts

@@ -21,6 +21,8 @@ export interface FleetPanelProps {
         planCount: number;
         evalCount: number;
     } | null;
+    /** Optional column width cap (when rendered beside a sidebar). */
+    maxWidth?: number | undefined;
 }
 type SwarmColor = 'blue' | 'cyan' | 'green' | 'gray' | 'red' | 'yellow';
 export interface SwarmCell {
@@ -69,6 +71,6 @@ export declare function buildTodoPreviewRows(todos: readonly TodoItem[] | undefi
  * monitor owns transcripts and drill-down; this panel stays compact and makes
  * the fleet's current shape readable at a glance.
  */
-export declare function FleetPanel({ entries, totalCost, roster, todos, nowTick, collabSession, }: FleetPanelProps): React.ReactElement | null;
+export declare function FleetPanel({ entries, totalCost, roster, todos, nowTick, collabSession, maxWidth, }: FleetPanelProps): React.ReactElement | null;
 export {};
 //# sourceMappingURL=fleet-panel.d.ts.map

package/dist/components/history/copy-geometry.d.ts

@@ -0,0 +1,61 @@
+import type { HistoryEntry } from './index.js';
+/**
+ * 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;
+//# sourceMappingURL=copy-geometry.d.ts.map

package/dist/components/history/sage-output-format.d.ts

@@ -20,12 +20,13 @@ export interface ParsedSageMemoryLine {
     tags?: string[] | undefined;
 }
 /**
- * Strict counterpart to `SAGE_MEMORY_LINE`. The gate above only decides "does
- * this line belong to a SAGE block?" and stays permissive (greedy body, opaque
- * `(?: .*)?` trailer) so block extraction survives future format additions.
- * This one captures named groups and therefore requires the exact `(anchor)` /
- * `[meta]` shapes the producer emits today; a line that passes the gate but
- * fails here falls back to a literal render row, so the memory is still shown.
+ * Strict counterpart to the canonical gate regex (kept private in
+ * `sage-output-block.ts`). The gate only decides "does this line belong to a
+ * SAGE block?" and stays permissive (greedy body, opaque `(?: .*)?` trailer)
+ * so block extraction survives future format additions. This one captures
+ * named groups and therefore requires the exact `(anchor)` / `[meta]` shapes
+ * the producer emits today; a line that passes the gate but fails here falls
+ * back to a literal render row, so the memory is still shown.
  */
 export declare const SAGE_MEMORY_DETAIL: RegExp;
 export declare function parseSageMemoryLine(line: string): ParsedSageMemoryLine | null;

package/dist/components/history/scroll-controller-types.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Public types for the scrollable history viewport.
+ *
+ * Extracted from scrollable-history.tsx so the imperative controller
+ * contract, props, and shared geometry types can be imported without
+ * pulling in the full component.
+ */
+import type { MutableRefObject } from 'react';
+import type { HistoryProps } from './index.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>;
+}
+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;
+}
+//# sourceMappingURL=scroll-controller-types.d.ts.map

package/dist/components/history/scrollbar-geometry.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Scrollbar math and card-span geometry — pure functions for thumb position,
+ * track-cell-to-offset mapping, and mounted card viewport spans.
+ *
+ * Extracted from scrollable-history.tsx.
+ */
+import type { EntryHeightCache } from '../../height-cache.js';
+import { type RenderGroup } from './tool-group.js';
+/** 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;
+//# sourceMappingURL=scrollbar-geometry.d.ts.map

package/dist/components/history/scrollbar-rail.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Right-edge rail for the managed viewport. Its first column is the copy icon
+ * (or blank), the second is a visual gap, and the third is the scrollbar track.
+ * All three columns are always reserved, so copy affordances and scrollability
+ * never reflow chat content.
+ *
+ * Extracted from scrollable-history.tsx.
+ */
+import type React from 'react';
+import type { CopyHit } from './copy-geometry.js';
+export declare function Scrollbar({ rows, offset, total, copyHits, copiedEntryId, }: {
+    rows: number;
+    offset: number;
+    total: number;
+    copyHits: readonly CopyHit[];
+    copiedEntryId?: number | null | undefined;
+}): React.ReactElement;
+//# sourceMappingURL=scrollbar-rail.d.ts.map

package/dist/components/history/selection-helpers.d.ts

@@ -0,0 +1,111 @@
+import type { HistoryEntry } from './index.js';
+/**
+ * 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[];
+/**
+ * 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>;
+    toolGroupsByHeadId?: ReadonlyMap<number, readonly number[]> | undefined;
+}): string;
+//# sourceMappingURL=selection-helpers.d.ts.map