@wrongstack/tui 0.297.0 → 0.298.0

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;

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

@@ -45,7 +45,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';

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/scrollable-history.d.ts

@@ -1,5 +1,7 @@
 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
@@ -39,6 +41,41 @@ export interface HistoryScrollController {
      * 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
@@ -57,6 +94,11 @@ export interface CopyHit {
 }
 /** 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
@@ -82,14 +124,99 @@ export declare function copyRegistryVisibleClip(opts: {
     tailRows: number;
     viewportRows: number;
 }): number;
-/** Build the live tool-stream header hit, accounting for ToolStreamBox's top margin. */
+/** 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;
@@ -135,6 +262,78 @@ export declare function scrollbarThumb(rows: number, offset: number, total: numb
  *  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;
 /**
  * Bounded history viewport with stable-anchor virtual scrolling.
  *

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

@@ -15,6 +15,16 @@ export type ContextMode = (typeof CONTEXT_MODES)[number];
 export declare const CONTEXT_MODE_DESCS: Record<ContextMode, string>;
 export declare const STATUSLINE_MODES: readonly ['minimum', 'detailed', 'no-color'];
 export type StatuslineMode = (typeof STATUSLINE_MODES)[number];
+/**
+ * Factory default statusline density. `minimum` is the default so a fresh
+ * session shows a single clean rail (state · provider/model · context meter ·
+ * version) with conditional chips only when relevant; `detailed` and
+ * `no-color` are opt-in via /settings. Every app-level default site references
+ * this constant so the default has a single source of truth. (The StatusBar
+ * component's own prop default stays 'detailed' for back-compat with callers
+ * that omit `mode` — the user-facing default is applied at the settings layer.)
+ */
+export declare const DEFAULT_STATUSLINE_MODE: StatuslineMode;
 export declare const REASONING_MODES: readonly ['auto', 'on', 'off'];
 export type ReasoningMode = (typeof REASONING_MODES)[number];
 export declare const REASONING_EFFORTS: readonly ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];

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

@@ -103,12 +103,28 @@ export interface StatusBarProps {
      */
     provider?: string | undefined;
     /**
-     * App version string (e.g. "0.7.0"). Previously rendered a `WS v{version}`
-     * chip at the head of line 1. Now shown in the composer top rail instead
-     * (`WRONGSTACK v{version}`). Kept in the interface for callers that may
-     * use `version` in derived props — no longer rendered by StatusBar itself.
+     * App version string (e.g. "0.7.0"). Rendered as a right-anchored version
+     * chip on the status bar (line 1, and the minimum-mode rail) so it stays
+     * visible after the startup banner scrolls off — in addition to the
+     * composer top rail (`WRONGSTACK v{version}`). When omitted, the chip is
+     * hidden — keeps tests / legacy callers quiet.
      */
     version?: string | undefined;
+    /**
+     * Latest version published to the npm registry, when known. When paired
+     * with {@link updateAvailable} (and not equal to {@link version}), the
+     * version chip on the right edge of the status bar gains an orange
+     * "(update v…)" suffix so the operator notices the upgrade without
+     * scrolling back through history to find the startup banner. Sourced from
+     * the CLI's preflight update-check.
+     */
+    latestVersion?: string | undefined;
+    /**
+     * True when the preflight update-check found a newer published version
+     * than {@link version}. Both must be present (and non-equal) to render the
+     * orange update notice on the status bar.
+     */
+    updateAvailable?: boolean | undefined;
     state: 'idle' | 'running' | 'streaming' | 'aborting';
     /** Single word rendered in the rainbow working-state chip. */
     thinkingWord?: string | undefined;
@@ -204,6 +220,12 @@ export interface StatusBarProps {
     workingDir?: string | undefined;
     /** Autonomy mode chip: 'off' | 'suggest' | 'auto' | 'eternal' | 'eternal-parallel'. */
     autonomy?: 'off' | 'suggest' | 'auto' | 'eternal' | 'eternal-parallel' | undefined;
+    /**
+     * Number of tools dropped from the provider request due to the maxTools
+     * limit. When > 0, renders a warning chip on line 2 (e.g. "⊘ 5 tools")
+     * so the user knows some tools are unavailable to the model this session.
+     */
+    droppedTools?: number | undefined;
     /** Number of tracked bash/exec processes from the process registry. Currently unused on the rail. */
     processCount?: number | undefined;
     /** Current RSS/heap sample for this CLI process. */
@@ -212,7 +234,11 @@ export interface StatusBarProps {
     cpuPercent?: number | undefined;
     /** Items to hide from the status bar. Canonical set: {@link StatuslineItem}. */
     hiddenItems?: StatuslineItem[] | undefined;
-    /** Statusline density. Detailed is the default to preserve the full multi-line display. */
+    /**
+     * Statusline density. The prop default 'detailed' is kept for back-compat
+     * with tests/callers that omit `mode`; the user-facing default is 'minimum'
+     * (DEFAULT_STATUSLINE_MODE), applied at the settings layer.
+     */
     mode?: StatuslineMode | undefined;
     /** EventBus for subscribing to token.accounted events for real-time cost/token updates. */
     events?: EventBus | undefined;

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, 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, 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, }: StatusBarProps): React.ReactElement;
 //# sourceMappingURL=status-bar.d.ts.map

package/dist/hooks/use-statusbar-view-model.d.ts

@@ -49,6 +49,7 @@ export declare function useStatusbarViewModel({ agent, tokenCounter, activeMaxCo
     entriesWithLeader: Record<string, FleetEntry>;
     planCounts: PlanCounts | null;
     taskCounts: TaskCounts | null;
+    droppedTools: number;
 };
 export {};
 //# sourceMappingURL=use-statusbar-view-model.d.ts.map

package/dist/hooks/use-tui-slash-commands.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 { State } from '../app-state.js';
 import { type StatuslineItem } from '../components/statusline-picker.js';
 interface TuiSlashCommandOptions {