@wrongstack/tui 0.306.4 → 0.307.1

package/dist/app-state-core-types.d.ts

@@ -6,6 +6,13 @@ export interface QueueItem {
     blocks: ContentBlock[];
     /** When true, the item will be refined via model.refine before entering the agent context. */
     shouldRefine?: boolean | undefined;
+    /**
+     * Raw (pre-refinement) user text for prompt-journal provenance. Stamped
+     * into `ctx.meta[PROMPT_JOURNAL_RAW_MARKER]` by the queue drainer right
+     * before the item runs — NOT at enqueue time — so each queued item keeps
+     * its own raw text and clearing the queue can never orphan a stale marker.
+     */
+    journalRaw?: string | undefined;
 }
 /** A registered slash command matched against the user's current / query. */
 export interface SlashCommandMatch {

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

@@ -0,0 +1,13 @@
+import type React from 'react';
+import type { AppViewProps } from './app-view-contract.js';
+import type { PanelId } from './ui-contracts.js';
+export interface AppViewPickersProps {
+    host: AppViewProps['host'];
+    runtime: AppViewProps['runtime'];
+    mainColumnWidth: number;
+    pickerMaxRows: number;
+    routedToSidebar: (id: PanelId) => boolean;
+    panelPositions: Record<PanelId, 'bottom' | 'sidebar'>;
+}
+export declare function AppViewPickers({ host, runtime, mainColumnWidth, pickerMaxRows, routedToSidebar, panelPositions, }: AppViewPickersProps): React.ReactElement;
+//# sourceMappingURL=app-view-pickers.d.ts.map

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

@@ -0,0 +1,19 @@
+import type React from 'react';
+import type { AppViewProps } from './app-view-contract.js';
+import type { PanelId } from './ui-contracts.js';
+import type { useSidebarConnections, useSidebarKanban, useSidebarProcessList } from './hooks/use-sidebar-panel-data.js';
+import type { usePlanPanelData } from './components/plan-panel.js';
+export interface AppViewSidebarProps {
+    host: AppViewProps['host'];
+    runtime: AppViewProps['runtime'];
+    sidebarWidth: number;
+    sidebarContentWidth: number;
+    sidebarSlotVisible: (id: PanelId) => boolean;
+    hiddenSidebarPanelCount: number;
+    sidebarProcessData: ReturnType<typeof useSidebarProcessList>;
+    sidebarConnectionsData: ReturnType<typeof useSidebarConnections>;
+    sidebarKanbanData: ReturnType<typeof useSidebarKanban>;
+    sidebarPlanData: ReturnType<typeof usePlanPanelData>;
+}
+export declare function AppViewSidebar({ host, runtime, sidebarWidth, sidebarContentWidth, sidebarSlotVisible, hiddenSidebarPanelCount, sidebarProcessData, sidebarConnectionsData, sidebarKanbanData, sidebarPlanData, }: AppViewSidebarProps): React.ReactElement | null;
+//# sourceMappingURL=app-view-sidebar.d.ts.map

package/dist/app.d.ts

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

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

@@ -9,6 +9,24 @@ export interface ContextPanelData {
     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.
+     */
+    cacheStats?: {
+        readTokens: number;
+        writeTokens: number;
+        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;
     /**
      * Real, measured per-category token accounting for the live request. When
      * present the Composition tab shows honest numbers; when absent (no request

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

@@ -0,0 +1,28 @@
+import type { EntryHeightCache } from '../../height-cache.js';
+import type { CopyHit } from './copy-geometry.js';
+import { type RenderGroup } from './tool-group.js';
+export interface CopyRegistry {
+    hits: CopyHit[];
+    liveHit: CopyHit | null;
+}
+/**
+ * Resolve copy icons into the already-reserved scrollbar gap column.
+ *
+ * Copy affordances must not alter card width: changing the width changes
+ * wrapped row counts, which invalidates the prefix sums that map scrollbar
+ * positions to virtual entry slices. This helper derives icon rows from the
+ * same cached heights used by the mount plan while leaving entry geometry
+ * untouched.
+ */
+export declare function buildCopyRegistry(opts: {
+    renderGroups: readonly RenderGroup[];
+    heightCache: EntryHeightCache;
+    scrolled: boolean;
+    clip: number;
+    tailRows: number;
+    viewportRows: number;
+    iconCol: number;
+    showModelReasoning?: boolean | undefined;
+    liveToolVisible: boolean;
+}): CopyRegistry;
+//# sourceMappingURL=copy-registry.d.ts.map

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

@@ -0,0 +1,63 @@
+import type React from 'react';
+import type { HistoryEntry } from './types.js';
+/**
+ * Per-memory proof costs two rows each, so an 8-hint run would push a 20-row
+ * card into the transcript. Show the top few (the list arrives score-sorted)
+ * and count the rest; the side panel keeps the full set.
+ */
+export declare const MAX_MEMORY_PROOF_ROWS = 4;
+/**
+ * Render the signed score contributions as `metadata 0.72×0.48 +0.34 │ …`.
+ * Uses U+2212 for negatives so a minus is not mistaken for a hyphen inside
+ * the labels, which themselves contain `×` and digits.
+ */
+export declare function formatScoreTerms(terms: ReadonlyArray<{
+    label: string;
+    value: number;
+}>): string;
+export declare function brainStatusStyle(status: Extract<HistoryEntry, {
+    kind: 'brain';
+}>['status']): {
+    icon: string;
+    color: string;
+};
+/**
+ * One-line summary of how a council resolved.
+ *
+ * `distinctTargetCount` is on the headline on purpose: a panel where several
+ * seats resolved to the SAME model produces a perfectly normal-looking verdict
+ * while adding cost without adding independence, and that is invisible unless
+ * the count is shown next to the seat count.
+ */
+export declare function councilHeadline(council: NonNullable<Extract<HistoryEntry, {
+    kind: 'brain';
+}>['council']>): string;
+/** One seat's line under the council headline. */
+export declare function councilSeatLine(seat: NonNullable<Extract<HistoryEntry, {
+    kind: 'brain';
+}>['council']>['seats'][number]): string;
+export declare function memoryLifecycleStyle(action: Extract<HistoryEntry, {
+    kind: 'memory-lifecycle';
+}>['action']): {
+    icon: string;
+    color: string;
+};
+export declare function brainRiskColor(risk: Extract<HistoryEntry, {
+    kind: 'brain';
+}>['risk']): string;
+/**
+ * Full-bordered notice card for `warn`/`error` entries. A rounded box with an
+ * icon + label header in the accent color and the message body below, wrapped
+ * to the terminal width and split across lines so multi-line diagnostics stay
+ * readable instead of overflowing a single-line strip. Slash-command output
+ * is normalized before it reaches Ink so cursor/control sequences can never
+ * paint outside the notice card's measured geometry.
+ */
+export declare function NoticeCard({ icon, label, color, text, termWidth, }: {
+    icon: string;
+    label: string;
+    color: string;
+    text: string;
+    termWidth: number;
+}): React.ReactElement;
+//# sourceMappingURL=entry-helpers.d.ts.map

package/dist/components/history/entry.d.ts

@@ -1,21 +1,7 @@
 import type { TodoItem } from '@wrongstack/core/agent';
 import React from 'react';
 import type { HistoryEntry } from './types.js';
-/**
- * One-line summary of how a council resolved.
- *
- * `distinctTargetCount` is on the headline on purpose: a panel where several
- * seats resolved to the SAME model produces a perfectly normal-looking verdict
- * while adding cost without adding independence, and that is invisible unless
- * the count is shown next to the seat count.
- */
-export declare function councilHeadline(council: NonNullable<Extract<HistoryEntry, {
-    kind: 'brain';
-}>['council']>): string;
-/** One seat's line under the council headline. */
-export declare function councilSeatLine(seat: NonNullable<Extract<HistoryEntry, {
-    kind: 'brain';
-}>['council']>['seats'][number]): string;
+export { councilHeadline, councilSeatLine } from './entry-helpers.js';
 export declare const Entry: React.MemoExoticComponent<({ entry, termWidth, termHeight, setSuggestions, autonomyMode, multiDiffSummaryThreshold, todos, showModelReasoning, showSageMemoryInject, }: {
     entry: HistoryEntry;
     termWidth: number;

package/dist/components/history/sage-memory-block.d.ts

@@ -0,0 +1,44 @@
+import type React from 'react';
+import { type ParsedSageMemoryLine } from './utils.js';
+/**
+ * Compact magenta-bordered panel rendering SAGE memory-injection lines
+ * appended to a tool result. Renders nothing when `sageLines` is empty.
+ *
+ * Layout:
+ *
+ *   ┌ 🧠 SAGE MEMORY INJECTED · <tool>  N memories ────────────────┐
+ *   │ [kind][importance]                                                │
+ *   │     text body (wrapped to panel width)                            │
+ *   │     id: mem_…  anchor: pkg/path  relation: about_file            │
+ *   │     tags: t1, t2, t3                                              │
+ *   │ [next memory …]                                                    │
+ *   └────────────────────────────────────────────────────────────────────┘
+ *
+ * Each memory is parsed by `parseSageMemoryLine` and rendered as key/value
+ * rows instead of the raw `[kind] <memory id="…">text</memory> (anchor) […]`
+ * blob. Lines that fail to parse fall back to the literal text so a future
+ * SAGE format change cannot silently drop data.
+ */
+export declare function SageMemoryBlock({ sageLines, toolName, stats, compact, }: {
+    sageLines?: string[] | undefined;
+    toolName: string;
+    stats?: string | undefined;
+    /**
+     * Compact (opt-in): one magenta chip with count + first preview.
+     * Full (default): bordered panel with every memory row. The bordered form
+     * is the canonical SAGE surface and is asserted by every render test in
+     * `tests/glob-sage-render.test.tsx` and `tests/sage-memory-block-render.test.tsx`.
+     */
+    compact?: boolean | undefined;
+}): React.ReactElement | null;
+/** One parsed memory, rendered as a structured key/value row block. */
+export declare function SageMemoryRow({ parsed, index, }: {
+    parsed: ParsedSageMemoryLine;
+    index: number;
+}): React.ReactElement;
+/** Compact key/value row used inside `SageMemoryRow`. */
+export declare function SageKv({ label, value }: {
+    label: string;
+    value: string;
+}): React.ReactElement;
+//# sourceMappingURL=sage-memory-block.d.ts.map

package/dist/components/history/tool-entry.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { HistoryEntry } from './types.js';
+export declare function ToolEntry({ entry, termWidth, multiDiffSummaryThreshold, showSageMemoryInject, }: {
+    entry: Extract<HistoryEntry, {
+        kind: 'tool';
+    }>;
+    termWidth: number;
+    multiDiffSummaryThreshold?: number | undefined;
+    showSageMemoryInject?: boolean | undefined;
+}): React.ReactElement;
+//# sourceMappingURL=tool-entry.d.ts.map

package/dist/components/history/use-history-controller.d.ts

@@ -0,0 +1,66 @@
+import { type ScrollAnchor, type ScrollGeometry } from '../../scroll-anchor.js';
+import type { CopyHit } from './copy-geometry.js';
+import type { MountedCardSpan } from './scrollbar-geometry.js';
+import type { HistoryScrollController } from './scroll-controller-types.js';
+import type { HistoryEntry } from './types.js';
+export interface UseHistoryControllerOptions {
+    geometry: ScrollGeometry;
+    effectiveAnchor: ScrollAnchor | null;
+    groupIds: readonly number[];
+    termWidth: number;
+    vp: number;
+    copyHitsRef: {
+        current: CopyHit[];
+    };
+    liveToolCopyHitRef: {
+        current: CopyHit | null;
+    };
+    mountedGroupSpansRef: {
+        current: readonly MountedCardSpan[];
+    };
+    selectionRef: {
+        current: {
+            anchor: {
+                row: number;
+                col: number;
+            } | null;
+            head: {
+                row: number;
+                col: number;
+            } | null;
+            inProgress: boolean;
+        };
+    };
+    entriesByIdRef: {
+        current: Map<number, HistoryEntry>;
+    };
+    toolStreamRef: {
+        current: {
+            name: string;
+            text: string;
+            startedAt: number;
+        } | null | undefined;
+    };
+    setAnchor: (anchor: {
+        id: number;
+        clip: number;
+    } | null) => void;
+    setMountBump: (bump: number) => void;
+    controllerRef?: {
+        current: HistoryScrollController | null;
+    } | undefined;
+}
+export declare function useHistoryController(opts: UseHistoryControllerOptions): {
+    controller: HistoryScrollController;
+    applyAnchor: (next: ScrollAnchor | null) => void;
+    effectiveAnchorRef: {
+        current: ScrollAnchor | null;
+    };
+    geometryRef: {
+        current: ScrollGeometry;
+    };
+    groupIdsRef: {
+        current: readonly number[];
+    };
+};
+//# sourceMappingURL=use-history-controller.d.ts.map

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

@@ -8,30 +8,6 @@ export { Scrollbar } from './history/scrollbar-rail.js';
 import type { ScrollableHistoryProps } from './history/scroll-controller-types.js';
 /**
  * Bounded history viewport with stable-anchor virtual scrolling.
- *
- * Instead of streaming entries into the terminal's native scrollback via
- * `<Static>`, retained entries render into a fixed-height `overflowY:'hidden'`
- * viewport the app scrolls itself. Wheel, PageUp/PageDown, and Ctrl+U/D scroll
- * it in every mode; full mouse mode additionally enables scrollbar interaction.
- * All paths use the {@link HistoryScrollController} this component owns.
- *
- * Positioning model (Ink-7 verified against real yoga layout):
- * - Pinned (`anchor:null`): `justifyContent:'flex-end'` + enough trailing
- *   groups mounted to overfill the viewport. Ink clips the overflow at the
- *   TOP, so the newest output hugs the input line with zero position math.
- * - Scrolled: wheel, page keys, and scrollbar gestures all resolve to the
- *   render-group id at the viewport top plus a row clipped inside that group.
- *   Groups mount from that stable anchor and `marginTop:-clip` hides preceding
- *   rows. Height corrections above the anchor can refine the scrollbar extent
- *   without changing which content is visible.
- *
- * The {@link EntryHeightCache} seeds the global row space and decides how many
- * groups to mount. A post-render `measureElement` pass promotes mounted groups
- * to real heights and persists them. Only the mounted virtual window is
- * measured; a long transcript is never mounted wholesale for calibration.
- *
- * Wrapped in `React.memo` so keystrokes in the input buffer don't trigger a
- * full managed-viewport re-layout.
  */
 export declare const ScrollableHistory: React.MemoExoticComponent<({ entries, toolStream, viewportRows, controllerRef, onScrollInfo, maxWidth, setSuggestions, autonomyMode, multiDiffSummaryThreshold, todos, showModelReasoning, showSageMemoryInject, layoutStore, copiedEntryId, onRequestOlderEntries, }: ScrollableHistoryProps) => React.ReactElement>;
 export type { HistoryEntry };

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

@@ -1,4 +1,5 @@
 import type { TodoItem } from '@wrongstack/core/agent';
+import type { CacheStats } from '@wrongstack/core/types';
 import type { ContextBreakdown } from '@wrongstack/core/utils';
 import type React from 'react';
 import type { ResumeSessionEntry } from '../app-state.js';
@@ -13,6 +14,19 @@ export interface SidebarContentProps {
     } | undefined;
     /** Honest per-category accounting behind the context window display. */
     contextBreakdown?: ContextBreakdown | undefined;
+    /**
+     * Live prompt-cache hit ratio + token counts for the sidebar card.
+     * Surfaced so a user staring at the right rail can see how much of
+     * the spend is hitting the prompt cache without opening `/context`.
+     */
+    cacheStats?: CacheStats | undefined;
+    /**
+     * How far the cached prefix reaches into the live request, in tokens.
+     * Drawn as an overlay marker on the context-window spectrum bar so
+     * "exactly how far the cache extends" is answerable at a glance.
+     * Zero hides the marker — no prompt cached this request.
+     */
+    cacheCoverageTokens?: number | undefined;
     /** Fleet entries (leader + subagents) from useStatusbarViewModel. */
     entries: Record<string, FleetEntry>;
     /** Fleet counts summary. */
@@ -88,6 +102,6 @@ export declare function contextSpectrum(breakdown: ContextBreakdown | undefined,
 } | undefined, width: number): Array<ContextSegment & {
     cells: number;
 }>;
-export declare function SidebarContent({ contextWindow, contextBreakdown, entries, fleetCounts, provider, model, width, scrollOffset, focused, todos, showSwarmSection, liveSessions, resumeSessions, currentSessionId, processMemory, cpuPercent, cpuHistory, rssHistory, heapHistory, totalMem, }: SidebarContentProps): React.ReactElement;
+export declare function SidebarContent({ contextWindow, contextBreakdown, cacheStats, cacheCoverageTokens, entries, fleetCounts, provider, model, width, scrollOffset, focused, todos, showSwarmSection, liveSessions, resumeSessions, currentSessionId, processMemory, cpuPercent, cpuHistory, rssHistory, heapHistory, totalMem, }: SidebarContentProps): React.ReactElement;
 export {};
 //# sourceMappingURL=sidebar-content.d.ts.map

package/dist/components/sidebar-panels-shared.d.ts

@@ -0,0 +1,20 @@
+import type React from 'react';
+import type { FleetEntry } from '../app-state.js';
+export declare function fleetStatusVisual(status: FleetEntry['status']): {
+    glyph: string;
+    color: string;
+};
+export declare function liveSessionGlyph(status: string): string;
+export declare function liveSessionColor(status: string): string;
+export declare function fmtRelative(iso: string | undefined, now?: number): string;
+export declare function fmtShortDuration(ms: number): string;
+export declare function SidebarWorklistRow({ icon, iconColor, label, labelColor, innerWidth, dim, strikethrough, }: {
+    icon: string;
+    iconColor: string;
+    label: string;
+    labelColor: string;
+    innerWidth: number;
+    dim?: boolean | undefined;
+    strikethrough?: boolean | undefined;
+}): React.ReactElement;
+//# sourceMappingURL=sidebar-panels-shared.d.ts.map

package/dist/components/sidebar-panels-task.d.ts

@@ -0,0 +1,65 @@
+import type { TodoItem } from '@wrongstack/core/agent';
+import type React from 'react';
+import type { GoalSummary, ResumeSessionEntry } from '../app-state.js';
+import type { QueueItem } from '../app-state-core-types.js';
+import type { LiveSessionEntry } from './sessions-panel.js';
+export interface PlanPanelSidebarProps {
+    openCount: number;
+    inProgressCount: number;
+    doneCount: number;
+    items: readonly {
+        id: string;
+        title: string;
+        status: 'open' | 'in_progress' | 'done';
+    }[];
+    title?: string | undefined;
+    width: number;
+}
+export declare function PlanPanelSidebar({ openCount, inProgressCount, doneCount, items, title, width, }: PlanPanelSidebarProps): React.ReactElement;
+export interface TodosPanelSidebarProps {
+    todos: readonly TodoItem[];
+    width: number;
+}
+export declare function TodosPanelSidebar({ todos, width }: TodosPanelSidebarProps): React.ReactElement;
+export interface QueuePanelSidebarProps {
+    items: readonly QueueItem[];
+    width: number;
+}
+export declare function QueuePanelSidebar({ items, width }: QueuePanelSidebarProps): React.ReactElement;
+export interface ProcessListPanelSidebarProps {
+    activeCount: number;
+    totalCount: number;
+    processes: readonly {
+        pid: number;
+        name: string;
+        status?: string;
+    }[];
+    width: number;
+}
+export declare function ProcessListPanelSidebar({ activeCount, totalCount, processes, width, }: ProcessListPanelSidebarProps): React.ReactElement;
+export interface GoalPanelSidebarProps {
+    goal: GoalSummary | null;
+    coordinatorRunning: boolean;
+    width: number;
+}
+export declare function GoalPanelSidebar({ goal, coordinatorRunning, width, }: GoalPanelSidebarProps): React.ReactElement;
+export interface SessionsPanelSidebarProps {
+    liveSessions?: readonly LiveSessionEntry[] | undefined;
+    resumeSessions?: readonly ResumeSessionEntry[] | undefined;
+    currentSessionId?: string | undefined;
+    now?: number | undefined;
+    width: number;
+}
+export declare function SessionsPanelSidebar({ liveSessions, resumeSessions, currentSessionId, now, width, }: SessionsPanelSidebarProps): React.ReactElement;
+export interface KanbanPanelSidebarProps {
+    columns: readonly {
+        name: string;
+        count: number;
+        wip?: number;
+    }[];
+    totalActive: number;
+    activeCardTitles: readonly string[];
+    width: number;
+}
+export declare function KanbanPanelSidebar({ columns, totalActive, activeCardTitles, width, }: KanbanPanelSidebarProps): React.ReactElement;
+//# sourceMappingURL=sidebar-panels-task.d.ts.map

package/dist/components/sidebar-panels-workspace.d.ts

@@ -0,0 +1,50 @@
+import type React from 'react';
+import type { FleetEntry } from '../app-state.js';
+import type { WorktreeRow } from '../ui-contracts.js';
+import type { ProjectPickerItem } from './project-picker.js';
+export interface ProjectPickerSidebarProps {
+    items: readonly ProjectPickerItem[];
+    selected: number;
+    filter: string;
+    hint?: string | undefined;
+    currentProject?: string | undefined;
+    width: number;
+}
+export declare function ProjectPickerSidebar({ items, selected, filter, hint, currentProject, width, }: ProjectPickerSidebarProps): React.ReactElement;
+export interface FleetPanelSidebarProps {
+    entries: Record<string, FleetEntry>;
+    runningCount: number;
+    width: number;
+}
+export declare function FleetPanelSidebar({ entries, runningCount, width, }: FleetPanelSidebarProps): React.ReactElement;
+export interface AgentsPanelSidebarProps {
+    entries: Record<string, FleetEntry>;
+    totalCost: number;
+    nowTick: number;
+    width: number;
+}
+export declare function AgentsPanelSidebar({ entries, totalCost, nowTick, width, }: AgentsPanelSidebarProps): React.ReactElement;
+export interface WorktreePanelSidebarProps {
+    worktrees: Record<string, WorktreeRow>;
+    width: number;
+}
+export declare function WorktreePanelSidebar({ worktrees, width, }: WorktreePanelSidebarProps): React.ReactElement;
+export interface CoordinatorPanelSidebarProps {
+    running: boolean;
+    activePhases: number;
+    completedPhases: number;
+    phaseNames: readonly string[];
+    elapsedMs: number;
+    width: number;
+}
+export declare function CoordinatorPanelSidebar({ running, activePhases, completedPhases, phaseNames, elapsedMs, width, }: CoordinatorPanelSidebarProps): React.ReactElement;
+export interface ConnectionsPanelSidebarProps {
+    connections: readonly {
+        name: string;
+        status: 'ok' | 'warn' | 'down' | 'unknown';
+        latencyMs?: number | undefined;
+    }[];
+    width: number;
+}
+export declare function ConnectionsPanelSidebar({ connections, width, }: ConnectionsPanelSidebarProps): React.ReactElement;
+//# sourceMappingURL=sidebar-panels-workspace.d.ts.map