@wrongstack/tui 0.297.0 → 0.298.1

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

@@ -1,4 +1,4 @@
-import type { AutonomyStage, DesignKitEntry, FleetChatVerbosity, TokenSavingTier } from '@wrongstack/core/types';
+import type { AutonomyStage, ContextSnapshot, DesignKitEntry, FleetChatVerbosity, TokenSavingTier } from '@wrongstack/core/types';
 import type { SddBoardSnapshot } from '@wrongstack/sdd';
 import type { State } from './app-state.js';
 import type { DraftEntry, GoalSummary, QueueItem, ResumeSessionEntry, SlashCommandMatch } from './app-state-core-types.js';
@@ -218,6 +218,15 @@ export type Action = {
     type: 'replaceHistory';
     entries: HistoryEntry[];
     nextId: number;
+    /**
+     * Optional context-window snapshot forwarded from the host's
+     * `onResumeSession` return. When present, the reducer writes
+     * `tokens` to `state.leader.ctxTokens` and bumps
+     * `state.contextChipVersion` so the statusline chip and `/context`
+     * panel reflect the rebuilt context immediately, instead of staying
+     * at zero until the next ctx.pct event.
+     */
+    contextSnapshot?: ContextSnapshot | undefined;
 } | {
     type: 'settingsOpen';
     mode: SettingsMode;
@@ -270,7 +279,7 @@ export type Action = {
     breakerEnabled: boolean;
     breakerAutoKillResetMs: number;
     showModelReasoning: boolean;
-    showAgentSwarmPanel: boolean;
+    showAgentSwarmPanel: import('./app-settings-type.js').AgentSwarmPanelMode;
     readSymbols: boolean;
     showSageMemoryInject: boolean;
     sageMemoryInjectThreshold: number;
@@ -920,6 +929,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-props.d.ts

@@ -2,7 +2,7 @@ import type { Agent } from '@wrongstack/core/agent';
 import type { CoordinatorEvent, Director } from '@wrongstack/core/coordination';
 import type { SlashCommandRegistry } from '@wrongstack/core/registry';
 import type { QueueStore } from '@wrongstack/core/storage';
-import type { AttachmentStore, AutonomyStage, FleetChatVerbosity, Message, TokenCounter, TokenSavingTier } from '@wrongstack/core/types';
+import type { AttachmentStore, AutonomyStage, ContextSnapshot, FleetChatVerbosity, Message, TokenCounter, TokenSavingTier } from '@wrongstack/core/types';
 import type { EventBus } from '@wrongstack/core/kernel';
 import type { VisionAdapters } from '@wrongstack/runtime/vision';
 import type { SddLifecycleResult, SddRunControl } from '@wrongstack/sdd';
@@ -410,6 +410,16 @@ export interface AppProps {
         entries: HistoryEntry[];
         nextId: number;
         sessionId: string;
+        /**
+         * Optional context-window snapshot computed from the resumed
+         * session's tokenCounter after accounting the persisted usage.
+         * When present, the reducer writes `tokens` to `state.leader.ctxTokens`,
+         * `maxContext` to `state.leader.ctxMaxTokens`, and bumps
+         * `state.contextChipVersion` so the chip refreshes immediately. When
+         * absent, the chip stays at its previous value until the next ctx.pct
+         * event lands.
+         */
+        contextSnapshot?: ContextSnapshot | undefined;
     } | null>) | undefined;
     /**
      * List recent session summaries for the /resume picker. The host reads

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

@@ -1,5 +1,19 @@
 import type { FleetChatVerbosity, TokenSavingTier } from '@wrongstack/core/types';
 import type { CacheTtl, ContextMode, ReasoningEffort, StatuslineMode } from './settings-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;
@@ -45,7 +59,7 @@ export type Settings = {
     debugStream: boolean;
     /** Skip the confirmation prompt for the `!<command>` shell shortcut. */
     shellBangWarningDontShowAgain?: boolean | undefined;
-    /** Statusline density mode. Defaults to detailed. */
+    /** Statusline density mode. Defaults to minimum (DEFAULT_STATUSLINE_MODE). */
     statuslineMode: StatuslineMode;
     /** Reasoning mode: auto (provider default) | on | off. */
     reasoningMode: 'auto' | 'on' | 'off';
@@ -56,8 +70,10 @@ 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;
     /** 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

@@ -273,8 +273,8 @@ export type State = {
          * (API-level provisioning). Default: true.
          */
         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), or 'off'. Default: 'bottom'. */
+        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. */
@@ -616,6 +616,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/components/auth-panel.d.ts

@@ -3,6 +3,10 @@ import { type AuthPanelState } from './auth-panel-model.js';
 export interface AuthPanelProps {
     panel: AuthPanelState;
 }
+export declare function formatExpiry(expiresAt: string | undefined): {
+    text: string;
+    color: string;
+} | null;
 export declare function isAuthFlowUrlLine(line: string): boolean;
 /** Keep the newest authorize URL pinned even as later status lines arrive. */
 export declare function latestAuthFlowUrl(lines: readonly string[]): string | undefined;

package/dist/components/confirm-prompt.d.ts

@@ -23,5 +23,19 @@ export declare function confirmButtonSegments(suggestedPattern: string): Array<{
     start: number;
     len: number;
 }>;
+/**
+ * Unified-diff text for the payload a mutating tool is about to write.
+ *
+ * `stringifyInput` strips `content`/`new_string` to keep the summary line
+ * readable, and the branch meant to compensate keyed on `input.diff`. But
+ * `diff` lives on EditOutput, never on EditInput/WriteInput, and no layer
+ * enriches the input before the dialog receives it — so the branch was dead
+ * and this dialog asked the user to approve an edit, or an arbitrary
+ * whole-file overwrite, having shown them only a path (WS-080).
+ *
+ * Synthesised here from the fields the tool was actually given, so it renders
+ * through the same DiffBlock the committed history entries use.
+ */
+export declare function payloadDiff(input: unknown): string;
 export declare function ConfirmPrompt({ toolName, input, suggestedPattern, onDecision, onEnableYolo, destructive, boundaryReason, }: ConfirmPromptProps): React.ReactElement;
 //# sourceMappingURL=confirm-prompt.d.ts.map

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

package/dist/components/input.d.ts

@@ -42,6 +42,13 @@ export interface InputProps {
     /** Row count for the hidden placeholder so the bottom region never resizes. */
     placeholderHeight?: number | undefined;
     onKey: (input: string, key: KeyEvent) => void;
+    /**
+     * Optional cap on the column width used for wrapping and frame sizing.
+     * When set, the input area treats this as its effective terminal width
+     * instead of `stdout.columns` — needed when the input sits in a column
+     * narrower than the full terminal (e.g. beside a sidebar).
+     */
+    maxWidth?: number | undefined;
 }
 export interface KeyEvent {
     upArrow: boolean;
@@ -76,5 +83,5 @@ export interface KeyEvent {
     fn?: number | undefined;
 }
 export declare const EMPTY_KEY: KeyEvent;
-export declare const Input: React.MemoExoticComponent<({ prompt, value, cursor, disabled, hint, title, status, animationStyle, workingTime, footerHint, hidden, placeholderHeight, onKey, }: InputProps) => React.ReactElement>;
+export declare const Input: React.MemoExoticComponent<({ prompt, value, cursor, disabled, hint, title, status, animationStyle, workingTime, footerHint, hidden, placeholderHeight, onKey, maxWidth, }: InputProps) => React.ReactElement>;
 //# sourceMappingURL=input.d.ts.map