@wrongstack/tui 1.0.19 → 1.0.26

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

@@ -23,6 +23,8 @@ export declare function deriveAppViewState(options: AppViewStateOptions): {
     inputHeight: number;
     hideInput: boolean;
     lowerFunctionPanelOpen: boolean;
+    functionPanel: number | null;
+    panelOwnsInput: boolean;
 };
 export {};
 //# sourceMappingURL=app-view-state.d.ts.map

package/dist/app.d.ts

@@ -1,4 +1,5 @@
 import type React from 'react';
+import type { AppProps } from './app-props.js';
 export { buildGoalPreamble } from '@wrongstack/core/execution';
 export type { AppProps } from './app-props.js';
 export { type Action, type FleetEntry, type QueueItem, type ResumeSessionEntry, reducer, type Settings, type SlashCommandMatch, type State, } from './app-reducer.js';
@@ -6,6 +7,5 @@ export { nextInputWordStart, previousInputWordStart } from './input-editing.js';
 export { renderRunningTools } from './running-tools.js';
 export { selectedSlashCommandLine } from './slash-command-search.js';
 export { buildSteeringPreamble } from './steering-preamble.js';
-import type { AppProps } from './app-props.js';
-export declare function App(props: AppProps): React.ReactElement;
+export declare function App(props0: AppProps): React.ReactElement;
 //# sourceMappingURL=app.d.ts.map

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

@@ -172,6 +172,7 @@ export interface AuthPanelHost {
     addLocal(presetId: string, io: AuthFlowIo, opts?: {
         baseUrl?: string;
         apiKey?: string;
+        alias?: string;
     }): Promise<AuthFlowResult>;
     oauthLogin(kind: AuthOAuthKind, io: AuthFlowIo): Promise<AuthFlowResult>;
     /**

package/dist/background-strip-model.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The background strip above the composer: every running subagent and every
+ * background shell, as one row of chips. Alt+B focuses it; ←/→ pick a chip,
+ * Enter shows or hides the last lines of its output, `x` stops a shell (after
+ * a `y`), Esc leaves.
+ *
+ * This file is the pure part (items, layout, peek lines) and the strip's own
+ * little store. The store lives outside the app reducer on purpose: the strip
+ * state is view-only and short-lived, and the key route and the component are
+ * its only readers.
+ */
+import type { FleetEntry } from './app-state-fleet.js';
+export interface BackgroundItem {
+    /** `agent:<id>` or `shell:<pid>`. */
+    id: string;
+    kind: 'agent' | 'shell';
+    label: string;
+    startedAt: number;
+    agentId?: string | undefined;
+    pid?: number | undefined;
+    logFile?: string | undefined;
+}
+export interface BackgroundProcessLike {
+    pid: number;
+    command: string;
+    startedAt: number;
+    background: boolean;
+    killed: boolean;
+    logFile?: string | undefined;
+}
+/** Running subagents (oldest first), then background shells (oldest first). */
+export declare function buildBackgroundItems(fleet: Readonly<Record<string, FleetEntry>>, processes: readonly BackgroundProcessLike[]): BackgroundItem[];
+/** `12s`, `3m`, `1h4m`. */
+export declare function formatElapsed(ms: number): string;
+export interface StripChip {
+    item: BackgroundItem;
+    text: string;
+    selected: boolean;
+}
+/**
+ * The chips that fit in `width` columns (after the `prefix` and before the
+ * `suffix`), always including the selected one; `hidden` counts the rest.
+ */
+export declare function layoutStripChips(items: readonly BackgroundItem[], selected: number, width: number, now: number, spinner: string): {
+    chips: StripChip[];
+    hidden: number;
+};
+/** What a subagent is doing, newest last. */
+export declare function agentPeekLines(entry: FleetEntry | undefined, max: number): string[];
+export interface BackgroundStripState {
+    focused: boolean;
+    /** By id, so a chip that appears before it does not move the selection. */
+    selectedId: string | undefined;
+    peek: boolean;
+    confirmStop: boolean;
+    items: readonly BackgroundItem[];
+}
+export declare function getBackgroundStrip(): BackgroundStripState;
+export declare function updateBackgroundStrip(patch: Partial<BackgroundStripState>): void;
+/** Position of the selected chip (0 when nothing is selected). */
+export declare function selectedIndex(state: BackgroundStripState): number;
+/** Same ids in the same order: the strip keeps its item list (and render). */
+export declare function sameItems(a: readonly BackgroundItem[], b: readonly BackgroundItem[]): boolean;
+export declare function useBackgroundStrip(): BackgroundStripState;
+//# sourceMappingURL=background-strip-model.d.ts.map

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

@@ -93,7 +93,8 @@ export interface BrainPanelSettings {
     /** Effective heuristic toggles (defaults already filled in by the host). */
     heuristics: BrainPanelHeuristics;
     /** Single-LLM tier quality gate. */
-    llmMaxTokens: number;
+    /** undefined = the model's own output ceiling. */
+    llmMaxTokens?: number | undefined;
     llmRejectUncertain: boolean;
     llmMinConfidence: number;
     llmDenyIsTerminal: BrainDenyIsTerminal;
@@ -163,7 +164,7 @@ export interface BrainPanelHost {
      * positive integer"), so there is no "clear back to default" step here —
      * the preset ladders are number-only.
      */
-    setLlmMaxTokens(tokens: number): Promise<string | null>;
+    setLlmMaxTokens(tokens: number | undefined): Promise<string | null>;
     setLlmRejectUncertain(on: boolean): Promise<string | null>;
     setLlmMinConfidence(value: number): Promise<string | null>;
     setLlmDenyIsTerminal(mode: BrainDenyIsTerminal): Promise<string | null>;
@@ -277,7 +278,7 @@ export declare const AUTO_DENY_PRESETS: ReadonlyArray<number | undefined>;
  * fields, so there is no `undefined` ("back to default") rung — the default
  * value itself is the first rung.
  */
-export declare const LLM_MAX_TOKENS_PRESETS: readonly number[];
+export declare const LLM_MAX_TOKENS_PRESETS: ReadonlyArray<number | undefined>;
 export declare const LLM_MIN_CONFIDENCE_PRESETS: readonly number[];
 export declare const CACHE_TTL_PRESETS: readonly number[];
 export declare const CACHE_MAX_ENTRIES_PRESETS: readonly number[];
@@ -291,10 +292,9 @@ export declare const COUNCIL_TIMEOUT_PRESETS: ReadonlyArray<number | undefined>;
 export declare const COUNCIL_CONCURRENCY_PRESETS: ReadonlyArray<number | undefined>;
 export declare const COUNCIL_JUDGE_MAX_TOKENS_PRESETS: ReadonlyArray<number | undefined>;
 /**
- * Per-seat output budget rungs. The default is 2000 (see
- * `BRAIN_COUNCIL_DEFAULT_VOTER_MAX_TOKENS` in core) — reasoning models spend
- * their thinking tokens from this budget, so the rungs skew higher than the
- * judge ladder.
+ * Per-seat output budget rungs. The default (unset) is the model's own output
+ * ceiling — reasoning models spend their thinking tokens from this budget, so
+ * the rungs skew higher than the judge ladder.
  */
 /**
  * Deliberation round presets. Deliberately short: every step is another

package/dist/chat-search-slash.d.ts

@@ -0,0 +1,15 @@
+import type { SlashCommand } from '@wrongstack/core/types';
+import type { Action } from './app-action-type.js';
+interface ChatSearchSlashDeps {
+    dispatch: (action: Action) => void;
+    /** Thinking cards are only searchable while model reasoning is shown. */
+    includeReasoning: () => boolean;
+}
+/**
+ * TUI `/chat-search [text]` — opens the transcript search bar (same as
+ * Alt+F), optionally prefilled. Searches the history retained in this TUI;
+ * entries evicted by history retention are not searched.
+ */
+export declare function createChatSearchSlashCommand(deps: ChatSearchSlashDeps): SlashCommand;
+export {};
+//# sourceMappingURL=chat-search-slash.d.ts.map

package/dist/clipboard.d.ts

@@ -1,2 +1,15 @@
-export { readClipboardImage, readClipboardText, writeClipboardText, type ClipboardImage, } from '@wrongstack/runtime/clipboard';
+export { type ClipboardImage, readClipboardImage, readClipboardText, } from '@wrongstack/runtime/clipboard';
+interface ClipboardWriteDeps {
+    native: (text: string) => Promise<boolean>;
+    stdout: Pick<NodeJS.WriteStream, 'write' | 'isTTY'>;
+}
+/**
+ * Copy text for the TUI's copy actions. The OS clipboard tool first; when there
+ * is none that works — an SSH session, a headless Linux box without
+ * wl-copy/xclip — the terminal is asked to copy it with OSC 52, which reaches
+ * the clipboard of the machine the user is actually sitting at. (Inside tmux
+ * that needs `set -g set-clipboard on`.) OSC 52 has no acknowledgement, so a
+ * sent sequence counts as copied.
+ */
+export declare function writeClipboardText(text: string, deps?: ClipboardWriteDeps): Promise<boolean>;
 //# sourceMappingURL=clipboard.d.ts.map

package/dist/components/agent-monitor-presentation.d.ts

@@ -0,0 +1,61 @@
+import type { AgentTimelineEntry } from '@wrongstack/core/coordination';
+import type { FleetEntry } from '../app-state.js';
+import type { HistoryEntry } from './history.js';
+export declare function isLeaderEntry(entry: FleetEntry): boolean;
+/**
+ * Select the agents the live monitor should render. Only actively-running
+ * subagents are detail-worthy; idle workers are retained by the coordinator for
+ * reuse but should not keep the TUI crowded after their task closes. LEADER
+ * stays visible while a subagent is running (or while LEADER itself is running)
+ * so F3 always has a detail card fallback.
+ */
+export declare function selectLiveAgents(all: FleetEntry[], _now: number, _idleHideMs?: number): FleetEntry[];
+export declare function fmtTokens(n: number): string;
+export declare function fmtExactTokens(n: number): string;
+export declare function snippet(s: string, max?: number): string;
+export declare function formatContextRunway(tokens?: number, maxTokens?: number): string;
+export declare function formatRecentToolChip(tool: FleetEntry['recentTools'][number]): string;
+export declare function formatAgentDetailHeader(entry: FleetEntry): string;
+export declare function agentRisk(entry: FleetEntry): 'calm' | 'busy' | 'hot' | 'critical';
+export declare function riskMeta(risk: ReturnType<typeof agentRisk>): {
+    icon: string;
+    color: string;
+    label: string;
+};
+export declare function currentAction(entry: FleetEntry, now: number): string;
+export declare function selectAgentDetail(live: FleetEntry[], selectedId?: string): FleetEntry | undefined;
+export declare function nextEmptyAgentsCloseStartedAt(liveCount: number, now: number, currentStartedAt?: number): number | undefined;
+export declare function shouldCloseEmptyAgentsMonitor(liveCount: number, now: number, emptyStartedAt: number | undefined, delayMs?: number): boolean;
+export declare function selectHotAgent(entries: FleetEntry[]): FleetEntry | undefined;
+export declare function pctTextFromRatio(pct: number | undefined): string;
+/**
+ * Rows of transcript content for the current terminal. Constant for a
+ * given terminal size and agent count, so agent switches never change
+ * the panel height — only explicit resizes / fleet composition do.
+ * `fullscreen` lifts the 24-row cap: the F3 monitor owns the whole
+ * screen (chat history hidden), so the pane should fill every row the
+ * chrome doesn't need.
+ */
+export declare function transcriptRowsForTerminal(termRows: number | undefined, rosterCount: number, fullscreen?: boolean): number;
+/** One transcript entry as a single display line: `HH:MM:SS L3 🔧 …`. */
+export declare function formatTranscriptLine(e: AgentTimelineEntry, maxWidth?: number): string;
+/**
+ * Map the main chat's history entries into the transcript timeline shape
+ * so LEADER gets its own clean per-agent view in the F3 monitor. Subagent
+ * lines are EXCLUDED — that separation (leader vs subagents, not
+ * interleaved) is the whole point of the per-agent view. Banners and
+ * confirm prompts are UI chrome, not history, and are skipped too.
+ */
+export declare function leaderTimelineFromEntries(entries: readonly HistoryEntry[]): AgentTimelineEntry[];
+/**
+ * Slice a transcript (OLDEST first) into the fixed viewing window.
+ * `scrollOffset` counts lines scrolled UP from the tail (0 = pinned to
+ * newest). Returns the visible slice plus how many entries are hidden
+ * above/below the window.
+ */
+export declare function selectTranscriptWindow(entries: readonly AgentTimelineEntry[], scrollOffset: number, rows?: number): {
+    slice: AgentTimelineEntry[];
+    above: number;
+    below: number;
+};
+//# sourceMappingURL=agent-monitor-presentation.d.ts.map

package/dist/components/agents-monitor.d.ts

@@ -1,9 +1,8 @@
-import type React from 'react';
 import type { AgentTimelineEntry } from '@wrongstack/core/coordination';
+import type React from 'react';
+import type { FleetEntry } from '../app-state.js';
 import type { AgentTranscriptReader } from '../ui-contracts.js';
 export type { AgentTranscriptReader } from '../ui-contracts.js';
-import type { FleetEntry } from '../app-state.js';
-import type { HistoryEntry } from './history.js';
 /**
  * Narrow read-only view of per-subagent transcripts. AgentMonitorService
  * (created in the CLI host) satisfies this structurally; the TUI never
@@ -24,53 +23,8 @@ interface AgentsMonitorProps {
     leaderTranscript?: (() => AgentTimelineEntry[]) | undefined;
     fullscreen?: boolean | undefined;
 }
+export { agentRisk, fmtExactTokens, formatAgentDetailHeader, formatContextRunway, formatRecentToolChip, formatTranscriptLine, leaderTimelineFromEntries, nextEmptyAgentsCloseStartedAt, selectAgentDetail, selectLiveAgents, selectTranscriptWindow, shouldCloseEmptyAgentsMonitor, transcriptRowsForTerminal, } from './agent-monitor-presentation.js';
 export { EMPTY_AGENTS_CLOSE_DELAY_MS, IDLE_HIDE_MS } from './agents-monitor-constants.js';
-/**
- * Select the agents the live monitor should render. Only actively-running
- * subagents are detail-worthy; idle workers are retained by the coordinator for
- * reuse but should not keep the TUI crowded after their task closes. LEADER
- * stays visible while a subagent is running (or while LEADER itself is running)
- * so F3 always has a detail card fallback.
- */
-export declare function selectLiveAgents(all: FleetEntry[], _now: number, _idleHideMs?: number): FleetEntry[];
-export declare function fmtExactTokens(n: number): string;
-export declare function formatContextRunway(tokens?: number, maxTokens?: number): string;
-export declare function formatRecentToolChip(tool: FleetEntry['recentTools'][number]): string;
-export declare function formatAgentDetailHeader(entry: FleetEntry): string;
-export declare function agentRisk(entry: FleetEntry): 'calm' | 'busy' | 'hot' | 'critical';
-export declare function selectAgentDetail(live: FleetEntry[], selectedId?: string): FleetEntry | undefined;
-export declare function nextEmptyAgentsCloseStartedAt(liveCount: number, now: number, currentStartedAt?: number): number | undefined;
-export declare function shouldCloseEmptyAgentsMonitor(liveCount: number, now: number, emptyStartedAt: number | undefined, delayMs?: number): boolean;
-/**
- * Rows of transcript content for the current terminal. Constant for a
- * given terminal size and agent count, so agent switches never change
- * the panel height — only explicit resizes / fleet composition do.
- * `fullscreen` lifts the 24-row cap: the F3 monitor owns the whole
- * screen (chat history hidden), so the pane should fill every row the
- * chrome doesn't need.
- */
-export declare function transcriptRowsForTerminal(termRows: number | undefined, rosterCount: number, fullscreen?: boolean): number;
-/** One transcript entry as a single display line: `HH:MM:SS L3 🔧 …`. */
-export declare function formatTranscriptLine(e: AgentTimelineEntry, maxWidth?: number): string;
-/**
- * Map the main chat's history entries into the transcript timeline shape
- * so LEADER gets its own clean per-agent view in the F3 monitor. Subagent
- * lines are EXCLUDED — that separation (leader vs subagents, not
- * interleaved) is the whole point of the per-agent view. Banners and
- * confirm prompts are UI chrome, not history, and are skipped too.
- */
-export declare function leaderTimelineFromEntries(entries: readonly HistoryEntry[]): AgentTimelineEntry[];
-/**
- * Slice a transcript (OLDEST first) into the fixed viewing window.
- * `scrollOffset` counts lines scrolled UP from the tail (0 = pinned to
- * newest). Returns the visible slice plus how many entries are hidden
- * above/below the window.
- */
-export declare function selectTranscriptWindow(entries: readonly AgentTimelineEntry[], scrollOffset: number, rows?: number): {
-    slice: AgentTimelineEntry[];
-    above: number;
-    below: number;
-};
 /**
  * Agents panel — the redesigned F3 view.
  *

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

@@ -3,7 +3,8 @@ interface AuditPanelProps {
     /** Side effects from ctx.sideEffects, passed from the host. */
     sideEffects: SideEffect[];
     onClose: () => void;
+    maxRows?: number | undefined;
 }
-export declare function AuditPanel({ sideEffects, onClose: _onClose }: AuditPanelProps): import("react").JSX.Element;
+export declare function AuditPanel({ sideEffects, onClose: _onClose, maxRows }: AuditPanelProps): import("react").JSX.Element;
 export {};
 //# sourceMappingURL=audit-panel.d.ts.map

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

@@ -1,6 +1,8 @@
 import type React from 'react';
 import { type AuthPanelState } from './auth-panel-model.js';
 interface AuthPanelProps {
+    maxRows?: number | undefined;
+    columns?: number | undefined;
     panel: AuthPanelState;
 }
 export declare function formatExpiry(expiresAt: string | undefined): {
@@ -10,6 +12,6 @@ export declare function formatExpiry(expiresAt: string | undefined): {
 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;
-export declare function AuthPanel({ panel }: AuthPanelProps): React.ReactElement;
+export declare function AuthPanel({ panel, maxRows, columns }: AuthPanelProps): React.ReactElement;
 export {};
 //# sourceMappingURL=auth-panel.d.ts.map

package/dist/components/background-strip.d.ts

@@ -0,0 +1,20 @@
+import type React from 'react';
+import type { FleetEntry } from '../app-state-fleet.js';
+/** Output lines shown under the strip while a chip is open. */
+export declare const BACKGROUND_STRIP_PEEK_ROWS = 6;
+/** Rows the strip takes: none while nothing runs in the background. */
+export declare function backgroundStripRows(state: {
+    items: readonly unknown[];
+    focused: boolean;
+    peek: boolean;
+}): number;
+/**
+ * Running subagents and background shells, one chip each, right above the
+ * composer. Hidden while nothing runs in the background. Alt+B focuses it
+ * (see key-route-background-strip.ts).
+ */
+export declare function BackgroundStrip({ fleet, width, }: {
+    fleet: Readonly<Record<string, FleetEntry>>;
+    width: number;
+}): React.ReactElement | null;
+//# sourceMappingURL=background-strip.d.ts.map

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

@@ -3,6 +3,8 @@ import type { BrainLogEntry, BrainRiskLevel } from '../brain-contracts.js';
 export type { BrainLogEntry, BrainRiskLevel } from '../brain-contracts.js';
 import { type BrainPanelSettings } from './brain-panel-model.js';
 export interface BrainPanelProps {
+    maxRows?: number | undefined;
+    columns?: number | undefined;
     riskLevel: BrainRiskLevel;
     log: BrainLogEntry[];
     selected: number;
@@ -13,5 +15,5 @@ export interface BrainPanelProps {
     row?: number | undefined;
     busy?: boolean | undefined;
 }
-export declare function BrainPanel({ riskLevel, log, selected, hint, view, settings, row, busy, }: BrainPanelProps): React.ReactElement;
+export declare function BrainPanel({ riskLevel, log, selected, hint, view, settings, row, busy, maxRows, columns, }: BrainPanelProps): React.ReactElement;
 //# sourceMappingURL=brain-panel.d.ts.map

package/dist/components/chat-search-bar.d.ts

@@ -0,0 +1,19 @@
+import type React from 'react';
+import type { State } from '../app-state.js';
+import type { HistoryEntry } from '../history-entry.js';
+/** Rows the bar always occupies, so the history viewport never jumps. */
+export declare const CHAT_SEARCH_BAR_ROWS = 2;
+interface ChatSearchBarProps {
+    search: NonNullable<State['chatSearch']>;
+    entries: readonly HistoryEntry[];
+    includeReasoning: boolean;
+    width: number;
+}
+/**
+ * Transcript search bar shown above the composer while Alt+F search is open.
+ * Row 1: query, match position and key hints. Row 2: the selected match's
+ * line with the hit highlighted (or guidance when there is nothing to show).
+ */
+export declare const ChatSearchBar: React.MemoExoticComponent<({ search, entries, includeReasoning, width, }: ChatSearchBarProps) => React.ReactElement>;
+export {};
+//# sourceMappingURL=chat-search-bar.d.ts.map

package/dist/components/checkpoint-timeline.d.ts

@@ -8,12 +8,16 @@ export interface CheckpointTimelineProps {
     }>;
     selected: number;
     onSelect: (index: number) => void;
-    onConfirm: (index: number) => void;
+    onConfirm: (index: number) => void | Promise<void>;
+    /** Branch a new session at the checkpoint; absent when the host cannot fork. */
+    onFork?: ((index: number) => void) | undefined;
     onClose: () => void;
 }
 /**
  * Full-screen checkpoint timeline overlay for the /rewind command.
- * Arrow keys to navigate, Enter to rewind to selected, Esc to close.
+ * Arrow keys to navigate, Enter to rewind to selected, `f` to fork a new
+ * session there, Esc to close. Both take the selected prompt and everything
+ * after it back, and put the prompt back in the composer.
  */
-export declare function CheckpointTimeline({ checkpoints, selected, onSelect, onConfirm, onClose, }: CheckpointTimelineProps): React.ReactElement;
+export declare function CheckpointTimeline({ checkpoints, selected, onSelect, onConfirm, onFork, onClose, }: CheckpointTimelineProps): React.ReactElement;
 //# sourceMappingURL=checkpoint-timeline.d.ts.map

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

@@ -1,5 +1,5 @@
 import React from 'react';
-export type ConfirmDecision = 'yes' | 'no' | 'always' | 'deny';
+export type ConfirmDecision = 'yes' | 'no' | 'always' | 'always-exact' | 'always-command' | 'always-tool' | 'deny';
 interface ConfirmPromptProps {
     toolName: string;
     input: unknown;
@@ -7,6 +7,7 @@ interface ConfirmPromptProps {
     onDecision: (decision: ConfirmDecision) => void;
     /** Enable YOLO mode (capital Y). Destructive current calls remain pending. */
     onEnableYolo: () => void;
+    maxRows?: number | undefined;
     /** Whether this call was classified destructive. */
     destructive?: boolean;
     boundaryReason?: string | undefined;
@@ -19,12 +20,10 @@ interface ConfirmPromptProps {
 }
 /**
  * 0-based column spans of each button WITHIN the dialog's content area (i.e.
- * relative to the first printable column inside the border + paddingX). Used
- * by the TUI mouse handler to map a click on the button row to a decision.
- * Derived from the same `buttonLabels` the component renders, so the offsets
- * always match what's on screen.
+ * relative to the first printable column inside the border + paddingX).
+ * These describe an unwrapped row; the live handler uses measured DOM boxes.
  */
-export declare function confirmButtonSegments(suggestedPattern: string): Array<{
+export declare function confirmButtonSegments(suggestedPattern: string, toolName?: string): Array<{
     decision: ConfirmDecision;
     start: number;
     len: number;
@@ -43,6 +42,6 @@ export declare function confirmButtonSegments(suggestedPattern: string): Array<{
  * 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, writeTargets, }: ConfirmPromptProps): React.ReactElement;
+export declare function ConfirmPrompt({ toolName, input, suggestedPattern, onDecision, onEnableYolo, destructive, boundaryReason, writeTargets, maxRows, }: ConfirmPromptProps): React.ReactElement;
 export {};
 //# sourceMappingURL=confirm-prompt.d.ts.map

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

@@ -1,7 +1,8 @@
 interface ConnectionsPanelProps {
     projectRoot: string;
     onClose: () => void;
+    maxRows?: number | undefined;
 }
-export declare function ConnectionsPanel({ projectRoot, onClose, }: ConnectionsPanelProps): React.ReactElement;
+export declare function ConnectionsPanel({ projectRoot, onClose, maxRows, }: ConnectionsPanelProps): React.ReactElement;
 export {};
 //# sourceMappingURL=connections-panel.d.ts.map

package/dist/components/context-panel-sections.d.ts

@@ -0,0 +1,53 @@
+import type { ContextBreakdown } from '@wrongstack/core/utils';
+import type React from 'react';
+import type { ContextPanelData } from './context-panel-types.js';
+type ZoneLevel = 'safe' | 'warning' | 'critical' | 'danger';
+export declare function zoneFor(pct: number): ZoneLevel;
+export declare function zoneColor(zone: ZoneLevel): string;
+export declare function zoneEmoji(pct: number): string;
+export declare function zoneLabel(pct: number): string;
+export declare function PressureSection({ data, contentWidth, }: {
+    data: ContextPanelData;
+    contentWidth: number;
+}): React.ReactElement;
+/**
+ * Real composition, measured from the assembled request. Top-level categories
+ * (System / Tools / History / Volatile) each render a bar sized to their share
+ * of the total, plus a muted sub-line of the biggest constituents.
+ */
+export declare function CompositionSection({ breakdown, contentWidth, }: {
+    breakdown: ContextBreakdown | undefined;
+    contentWidth: number;
+}): React.ReactElement;
+export declare function ThresholdSection({ data, contentWidth, }: {
+    data: ContextPanelData;
+    contentWidth: number;
+}): React.ReactElement;
+export declare function CompactionSection({ data }: {
+    data: ContextPanelData;
+}): React.ReactElement;
+export declare function AgentFootprintSection({ data, contentWidth, }: {
+    data: ContextPanelData;
+    contentWidth: number;
+}): React.ReactElement;
+export declare function MetricsSection({ data }: {
+    data: ContextPanelData;
+}): React.ReactElement;
+/**
+ * Cache coverage section — answers "exactly how far does the prompt cache
+ * extend into the live request?" Renders the cumulative cache hit ratio
+ * plus a per-request coverage meter that visibly marks where the cached
+ * prefix ends. Hidden when nothing has been cached yet so the panel does
+ * not advertise a 0% figure as if it were meaningful.
+ */
+export declare function CacheSection({ data }: {
+    data: ContextPanelData;
+}): React.ReactElement;
+export declare function StatusSection({ data }: {
+    data: ContextPanelData;
+}): React.ReactElement;
+export declare function MemoryContextSection({ data }: {
+    data: ContextPanelData;
+}): React.ReactElement;
+export {};
+//# sourceMappingURL=context-panel-sections.d.ts.map

package/dist/components/context-panel-types.d.ts

@@ -0,0 +1,66 @@
+import type { ContextBreakdown } from '@wrongstack/core/utils';
+import type { MemoryContextMonitorState } from '../memory-context-monitor.js';
+export interface ContextPanelData {
+    ctxPct: number | undefined;
+    ctxTokens: number | undefined;
+    ctxMaxTokens: number | undefined;
+    provider: string;
+    model: string;
+    mode: string;
+    uptime: string;
+    /**
+     * Cumulative prompt-cache stats from the per-session TokenCounter.
+     * Surfaced in the panel so `/context` answers "how much of my spend
+     * is hitting the cache" without asking the user to chase the CLI
+     * `/context cache` subcommand.
+     *
+     * `savedUsd` is the gross read-discount USD figure computed by the
+     * counter (cache-read tokens × (input price − cache-read price)).
+     * `cacheWrite5m` / `cacheWrite1h` are present when the upstream exposed
+     * an Anthropic-style TTL split (Anthropic family, including MiniMax
+     * routed through the Anthropic Messages surface); OpenAI-family
+     * gateways emit only the aggregate and leave them undefined.
+     */
+    cacheStats?: {
+        readTokens: number;
+        writeTokens: number;
+        cacheWrite5m?: number | undefined;
+        cacheWrite1h?: number | undefined;
+        hitRatio: number;
+        savedUsd: number;
+    } | undefined;
+    /**
+     * How far the cached prefix reaches through the live request, in
+     * tokens. Drawn on the per-request coverage meter so users see the
+     * exact extent of the cache, not just a percentage.
+     */
+    cacheCoverageTokens?: number | undefined;
+    /** Session cache telemetry split by provider, including fallback/model switches. */
+    providerCacheStats?: Array<{
+        provider: string;
+        input: number;
+        cacheRead: number;
+        cacheWrite: number;
+        cacheWrite5m?: number | undefined;
+        cacheWrite1h?: number | undefined;
+        hitRatio: number;
+    }> | undefined;
+    /**
+     * Real, measured per-category token accounting for the live request. When
+     * present the Composition tab shows honest numbers; when absent (no request
+     * has been assembled yet) the tab shows an empty state instead of fabricated
+     * percentages.
+     */
+    breakdown: ContextBreakdown | undefined;
+    fleetEntries: Array<{
+        name: string;
+        status: string;
+        currentTool: string | undefined;
+        ctxPct: number | undefined;
+    }>;
+    leaderIterations: number;
+    leaderToolCalls: number;
+    leaderStatus: string;
+    memoryContext: MemoryContextMonitorState;
+}
+//# sourceMappingURL=context-panel-types.d.ts.map