@wrongstack/tui 0.310.1 → 0.313.0

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

@@ -300,7 +300,7 @@ export type Action = {
      * One of the renderable styles plus the meta-mode `'cycle'`. Persisted
      * to disk on every ←/→ change in `/settings`.
      */
-    animationStyle: 'rainbow' | 'wave' | 'pulse' | 'dots' | 'breathe' | 'cycle';
+    animationStyle: 'rainbow' | 'wave' | 'pulse' | 'dots' | 'breathe' | 'static' | 'cycle';
     /**
      * Persisted row index for where to land when the picker reopens.
      * See `Settings.lastSettingsField`.
@@ -330,7 +330,7 @@ export type Action = {
     nextStepsTool: boolean;
     /**
      * WrongProxy / WrongTrace: master switch + configurable URL
-     * (default http://localhost:8000). Mirrors `Settings.wrongProxy*`
+     * (default http://localhost:3444). Mirrors `Settings.wrongProxy*`
      * and `SettingsPickerPatch.wrongProxy*`. Both fields land in
      * the Integrations section of the picker; the runtime probe
      * reads the values via the TUI settings adapter (see

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

@@ -95,7 +95,7 @@ export type Settings = {
     cacheTtl: CacheTtl;
     /** Where to persist settings: 'global' or 'project'. */
     configScope: 'global' | 'project';
-    animationStyle: 'rainbow' | 'wave' | 'pulse' | 'dots' | 'breathe' | 'cycle';
+    animationStyle: 'rainbow' | 'wave' | 'pulse' | 'dots' | 'breathe' | 'static' | 'cycle';
     /** When true, read tool includes codebase-index symbols alongside file content. */
     readSymbols: boolean;
     /** Full mouse mode: in-app managed scroll + clickable UI (SGR tracking on). */
@@ -118,7 +118,7 @@ export type Settings = {
      */
     wrongProxyEnabled?: boolean | undefined;
     /**
-     * WrongProxy / WrongTrace URL. Default `http://localhost:8000`. Mirrors
+     * WrongProxy / WrongTrace URL. Default `http://localhost:3444`. Mirrors
      * `SettingsPickerPatch.wrongProxyUrl`.
      */
     wrongProxyUrl?: string | undefined;

package/dist/app-state.d.ts

@@ -326,7 +326,7 @@ export type State = {
          * meta-mode `'cycle'` that rotates through the variant styles every
          * `CYCLE_INTERVAL_SECONDS`. Persisted on every ←/→ change in `/settings`.
          */
-        animationStyle: 'rainbow' | 'wave' | 'pulse' | 'dots' | 'breathe' | 'cycle';
+        animationStyle: 'rainbow' | 'wave' | 'pulse' | 'dots' | 'breathe' | 'static' | 'cycle';
         /**
          * WrongProxy / WrongTrace: master switch. When true AND the daemon at
          * `wrongProxyUrl` is reachable, every provider's base URL is rewritten
@@ -336,7 +336,7 @@ export type State = {
          */
         wrongProxyEnabled: boolean;
         /**
-         * WrongProxy / WrongTrace URL. Default `http://localhost:8000`. The
+         * WrongProxy / WrongTrace URL. Default `http://localhost:3444`. The
          * CLI's periodic probe targets `<wrongProxyUrl>/api/health`; a 2xx
          * response flips the runtime's `active` flag. Picker field 60.
          */

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

@@ -19,7 +19,7 @@ interface AppViewStateOptions {
 export declare function deriveAppViewState(options: AppViewStateOptions): {
     inputHint: string;
     composerStatus: import("./components/composer-status-chip.js").ComposerStatus;
-    composerAnimationStyle: "breathe" | "cycle" | "dots" | "pulse" | "rainbow" | "wave";
+    composerAnimationStyle: "breathe" | "cycle" | "dots" | "pulse" | "rainbow" | "static" | "wave";
     inputHeight: number;
     hideInput: boolean;
     lowerFunctionPanelOpen: boolean;

package/dist/components/animation-style.d.ts

@@ -1,7 +1,7 @@
 export declare const HUE_WHEEL: string[];
 export declare const BREATHE_FRAMES: string[];
 export declare const DOTS_FRAMES: string[];
-export declare const ANIMATION_STYLES: readonly ['rainbow', 'wave', 'pulse', 'dots', 'breathe'];
+export declare const ANIMATION_STYLES: readonly ['rainbow', 'wave', 'pulse', 'dots', 'breathe', 'static'];
 export type AnimationStyle = (typeof ANIMATION_STYLES)[number];
 export declare const DEFAULT_ANIMATION_STYLE: AnimationStyle;
 export declare const ANIMATION_STYLE_DESCS: Record<AnimationStyle, string>;
@@ -36,7 +36,7 @@ export declare function colorPhaseFromTime(elapsedMs: number): number;
 /**
  * Cycle through every other `AnimationStyle` in order, returning to the
  * start once the list is exhausted. `rainbow` is excluded from the cycle
- * (it's the default/canonical look); cycle goes through the four variant
+ * (it's the default/canonical look); cycle goes through the five variant
  * styles only.
  */
 export declare const CYCLE_ORDER: readonly AnimationStyle[];

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

@@ -53,31 +53,66 @@ export interface HistoryScrollController {
      * 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.
+     *
+     * Column contract (v1.1 M3): `col` is a HISTORY-BAND column (0-based from
+     * the band's left edge). The controller translates it to card-body-local
+     * coordinates before storing: bordered kinds (assistant/thinking/user) have
+     * a MESSAGE_PANEL_CHROME_WIDTH (2) left gutter, and gutter columns CLAMP to
+     * the card's first visible column — a press on the border/padding selects
+     * from the start of the card's visible line, mirroring standard editor
+     * margin-click behavior. Gutterless kinds (info, memory-lifecycle, tool
+     * groups, …) pass the column through unchanged.
+     *
+     * Known limitation: `warn` rows still render a `⚠ ` prefix inline with no
+     * prefix translation (the wrap map covers assistant/thinking/user/info —
+     * see wrap-geometry.ts). User cards WITH a paste block also keep the v1
+     * naive path: they render two text regions while the copy base holds one.
+     *
+     * Inline prefixes (user `👤 USER  ` label, info `ℹ ` icon) are translated
+     * row-aware in the assembler: the wrap map wraps `prefix + first line`
+     * together exactly as the renderer's single Text node does, and
+     * resolveRowCol shifts row-0 columns past the measured prefix width
+     * (string-width cells), clamping label/icon clicks to the text start —
+     * the same margin-click semantics as the gutter clamp above. Constants
+     * are single-sourced in wrap-geometry.ts and consumed by entry.tsx.
      */
     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.
+     * Extend an active selection to `row`,`col` (history-band viewport cell,
+     * translated to body-local exactly as in {@link beginSelection}). If no
+     * selection is in progress, the call is a no-op. Columns outside the band
+     * or rows below the viewport / above 0 cancel 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.
+     * Mark an active drag as ended (left-release) WITHOUT copying. The primary
+     * release path goes straight to {@link commitSelection}; this intermediate
+     * state exists for callers that end a drag but defer the copy decision,
+     * and it pins {@link extendSelection} against stray post-release motion.
+     * If no selection is in progress, the call is a no-op.
      */
     endSelection(): void;
+    /**
+     * True while a drag-selection has been begun and not yet committed,
+     * cleared, or cancelled. Lets the key handler decide synchronously whether
+     * a left-release should trigger {@link commitSelection} — a release with
+     * no active selection must not spawn a pointless async clipboard path.
+     */
+    hasSelection(): boolean;
     /** 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.
+     * Commit the active selection to the system clipboard. Triggered by the
+     * left-button release that ends a drag (the release-commits-copy
+     * contract); a right-press in the history band commits any selection that
+     * is still pending after an unusual end. 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>;
 }

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

@@ -4,15 +4,24 @@
  * All three columns are always reserved, so copy affordances and scrollability
  * never reflow chat content.
  *
+ * The gap column doubles as the drag-selection highlight band: while a drag is
+ * in progress, the subscribing component re-renders ONLY this rail (via
+ * useSyncExternalStore on {@link SelectionBandStore}) — the history cards
+ * never re-render, and because the band occupies the already-reserved gap
+ * column the layout (and the fixed-height overflow-hidden viewport) cannot
+ * change mid-drag.
+ *
  * 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, }: {
+import { type SelectionBandStore } from './selection-band-store.js';
+export declare function Scrollbar({ rows, offset, total, copyHits, copiedEntryId, selectionBandStore, }: {
     rows: number;
     offset: number;
     total: number;
     copyHits: readonly CopyHit[];
     copiedEntryId?: number | null | undefined;
+    selectionBandStore?: SelectionBandStore | undefined;
 }): React.ReactElement;
 //# sourceMappingURL=scrollbar-rail.d.ts.map

package/dist/components/history/selection-band-store.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Minimal external store for the drag-selection highlight band.
+ *
+ * Why an external store instead of React state: the selection gesture must
+ * not re-render the history cards. Selection coordinates already live in a
+ * ref (see use-history-controller) precisely so a drag causes zero renders;
+ * this store gives the one leaf that DOES need to update — the right-edge
+ * rail — a subscription channel. The controller publishes on every selection
+ * mutation, and only components that call useSyncExternalStore on the store
+ * re-render. Cards never subscribe, so they never re-render mid-drag, and
+ * because the band renders inside the rail's already-reserved columns the
+ * layout (and the fixed-height overflow-hidden viewport) cannot change.
+ *
+ * Snapshots are immutable; `publish` suppresses value-identical updates so a
+ * drag that holds the same row span doesn't spam listeners.
+ */
+/** Row span of an in-progress drag, in viewport rows (0-based, inclusive). */
+export interface SelectionBand {
+    readonly topRow: number;
+    readonly bottomRow: number;
+    /** Row under the live drag head — rendered denser so the user can see
+     * where the gesture currently points. */
+    readonly headRow: number;
+}
+export type SelectionBandSnapshot = SelectionBand | null;
+export interface SelectionBandStore {
+    subscribe(listener: () => void): () => void;
+    getSnapshot(): SelectionBandSnapshot;
+    publish(next: SelectionBandSnapshot): void;
+}
+/** Band covering the anchor..head row span of an in-progress drag. */
+export declare function bandFromSelection(anchor: {
+    row: number;
+}, head: {
+    row: number;
+}): SelectionBand;
+export declare function createSelectionBandStore(): SelectionBandStore;
+//# sourceMappingURL=selection-band-store.d.ts.map

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

@@ -1,4 +1,4 @@
-import type { HistoryEntry } from './index.js';
+import type { HistoryEntry } from './types.js';
 /**
  * Selection rectangle in viewport cell coordinates, normalized so
  * `topLeft.row <= bottomRight.row` and the column pairs are likewise ordered.
@@ -107,5 +107,12 @@ export declare function assembleSelectionText(opts: {
     slices: readonly SelectionSlice[];
     entriesById: ReadonlyMap<number, HistoryEntry>;
     toolGroupsByHeadId?: ReadonlyMap<number, readonly number[]> | undefined;
+    /**
+     * Render width used to build the wrap-aware row→line translation for
+     * assistant/thinking cards (v1.1 M4). When omitted, wrapped kinds fall
+     * back to the v1 naive mapping below — callers that cannot know the
+     * width keep their existing behavior.
+     */
+    termWidth?: number | undefined;
 }): string;
 //# sourceMappingURL=selection-helpers.d.ts.map

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

@@ -1,7 +1,8 @@
 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 { MountedCardSpan } from './scrollbar-geometry.js';
+import { type SelectionBandStore } from './selection-band-store.js';
 import type { HistoryEntry } from './types.js';
 export interface UseHistoryControllerOptions {
     geometry: ScrollGeometry;
@@ -41,6 +42,10 @@ export interface UseHistoryControllerOptions {
             startedAt: number;
         } | null | undefined;
     };
+    /** External store for the drag-selection highlight band. The controller
+     * publishes selection geometry here so the rail leaf can re-render on
+     * drag motion WITHOUT any history card re-rendering. */
+    selectionBandStore?: SelectionBandStore | undefined;
     setAnchor: (anchor: {
         id: number;
         clip: number;

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

@@ -0,0 +1,130 @@
+/**
+ * Wrap-aware card-row → source-text translation for drag-selection text
+ * recovery (v1.1 item M4).
+ *
+ * v1's assembler indexed the entry's source lines by the card's VISUAL row,
+ * which equals the source line only when no line wraps. Any wrapped line
+ * desynchronizes the index and garbles the copied text. This module supplies
+ * the per-row mapping against the entry's SOURCE text (sanitized, with the
+ * assistant next-steps block stripped exactly like the renderer).
+ *
+ * Exactness boundary: the mapping is EXACT for plain prose and thinking text
+ * — MarkdownView renders those lines as-is and Ink wraps them with the same
+ * wrap-ansi call mirrored below. For assistant text containing markdown
+ * STRUCTURE (headings, lists, tables, fenced code), MarkdownView restyles
+ * the render (heading styles, bullet glyphs, table layout), so the visual
+ * rows can diverge from this source-text map. The copy semantics are
+ * deliberately source-based in that case: a drag recovers what the model
+ * wrote, not the renderer's decoration. Visual-row alignment for
+ * heavily-structured markdown is approximate and documented as such.
+ *
+ * The render truth this mirrors (verified against the components):
+ *  - `assistant` cards (entry.tsx) render `parseNextSteps(text, true).stripped`
+ *    through AssistantBody → MarkdownView, wrapped by Ink's Text at
+ *    `assistantContentWidth(termWidth)` = termWidth − 2. Ink wraps via
+ *    wrap-ansi with `{ trim: false, hard: true }` (ink/build/wrap-text.js).
+ *    The markdown transform above applies only to structured spans; plain
+ *    prose lines pass through unwrapped-by-markdown and are exact here.
+ *  - `thinking` cards render sanitizeTerminalText(text) at the same width
+ *    with no markdown transform — exact.
+ *  - `user` cards render the `'👤 USER  '` label inline before the text in
+ *    the same bordered Text (entry.tsx), so row 0 = label cells then text;
+ *    wrapped continuation rows start at the text. `pasteContent` renders as
+ *    a second block (`'  ↳ '` preview) after a newline; the copy base is
+ *    `pasteContent || text` (copy-icon.ts), so a card with BOTH blocks shows
+ *    two text regions while the base holds one — those keep the v1 naive
+ *    mapping (assembler-side residual, documented here).
+ *  - `info` cards are unbordered plain Text: the `'ℹ '` icon inline before
+ *    the text, wrapped at the FULL termWidth (no panel gutter).
+ *
+ * Inline-prefix translation: the label/icon cells are chrome, not copyable
+ * text. buildBodyRowMap wraps `prefix + first line` together — the renderer
+ * concatenates them into one Text node before Ink wraps it, so the wrap
+ * boundaries are only correct when the prefix participates in the wrap — and
+ * records the prefix width in terminal cells (string-width, the project's
+ * measurer; 👤 is a surrogate pair — 2 code units AND 2 cells — so both
+ * shipped prefixes happen to have prefixWidth === prefix.length). resolveRowCol
+ * shifts row-0 columns past it, clamping prefix clicks to the text start:
+ * the same margin-click semantics M3 gives the card gutter. The clamp works
+ * in CELLS while segment ranges are in CHARACTERS — exact when the body's
+ * characters are single-cell, the same standing M4 approximation that
+ * already governs text content. Narrow panes where the label alone exceeds
+ * the content width produce label-only rows (zero-width spans) — that
+ * mirrors Ink's render exactly and is deliberately preserved: any divergence
+ * between the map and the renderer breaks WYSIWYG slicing.
+ *
+ * Origin: card row 0 = body row 0, matching v1's documented origin (one card
+ * row per source line when nothing wraps). Any chrome-row offset above the
+ * body is a preexisting v1 approximation outside M4's scope — preserved, not
+ * altered, so every pinned expectation keeps its exact meaning.
+ *
+ * The load-bearing invariant (verified empirically against wrap-ansi@10.0.1,
+ * the exact version ink 7.1.1 resolves): for each source line,
+ * `wrapAnsi(line, w, {trim:false, hard:true}).split('\n').join('') === line`.
+ * Segment prefix sums therefore give EXACT source offsets. For a non-wrapped
+ * line the single segment spans the whole line with `start = 0`, so every
+ * resolve here reduces to v1's math (`offset = col`, end = `col + 1`).
+ */
+import type { HistoryEntry } from './types.js';
+/** One wrapped visual row inside a card body: the source line it shows and
+ * the half-open [start, end) character range of that line it covers. */
+export interface BodyRowSpan {
+    line: number;
+    start: number;
+    end: number;
+}
+export interface BodyRowMap {
+    /** Per-card-row spans, index 0 = card row 0 (v1 origin). */
+    rows: readonly BodyRowSpan[];
+    /** The exact text the map indexes into — the render base (sanitized; for
+     * assistant entries with the next-steps block stripped exactly like the
+     * renderer). Slicing this text is WYSIWYG for the wrapped kinds. */
+    text: string;
+    /** Terminal CELLS of inline chrome rendered before the first text
+     * character on row 0 (user label / info icon). 0 for prefix-less kinds. */
+    prefixWidth: number;
+}
+/** Inline label the renderer places before a user card's text
+ * (entry.tsx: `<Text bold>👤 USER  </Text>` then the text, one Text node).
+ * Exported so entry.tsx consumes the single source (p3) — drift between the
+ * render and this constant silently mis-offsets user-card selection. */
+export declare const USER_LABEL = "\uD83D\uDC64 USER  ";
+/** Inline icon the renderer places before an info card's text
+ * (entry.tsx: `<Text>ℹ </Text>` then the text, one Text node). */
+export declare const INFO_PREFIX = "\u2139 ";
+/** Kinds whose render path this module mirrors. Everything else uses the
+ * v1 naive mapping in assembleSelectionText. Declared as a type predicate
+ * (taking the entry, not the kind) so call sites narrow the HistoryEntry
+ * union — every member kind carries `text`, the others may not. The
+ * assembler additionally restricts user cards to the no-pasteContent shape
+ * (see selection-helpers): a card with a paste block renders two text
+ * regions but the copy base holds one, so those stay on the v1 path. */
+export declare function hasWrapMap(entry: HistoryEntry): entry is Extract<HistoryEntry, {
+    kind: 'assistant' | 'thinking' | 'user' | 'info';
+}>;
+/**
+ * Build the card-row → (source line, char range) map for one text card.
+ * Pure and deterministic from (kind, text, termWidth).
+ *
+ * For prefixed kinds (user label, info icon) line 0 is wrapped AS the
+ * renderer sees it — `prefix + line` in one Text node — so wrap boundaries
+ * match the visual rows; each segment is then translated back to
+ * text-local character coordinates (the prefix chars subtracted, clamped).
+ */
+export declare function buildBodyRowMap(kind: HistoryEntry['kind'], rawText: string, termWidth: number): BodyRowMap;
+/**
+ * Resolve the (source line, char offset) a card row + column points at,
+ * clamping out-of-range rows to the last body row and columns to the
+ * wrapped segment.
+ *
+ * Column semantics match v1: `col` is a body-local character offset (v1
+ * sliced the source line by it directly), so a non-wrapped line resolves to
+ * exactly v1's numbers. `atEnd` is set for an inclusive drag endpoint (end
+ * of a selection range): the offset then counts one past the column,
+ * clamped to the segment's end — mirroring v1's `endCol + 1`.
+ */
+export declare function resolveRowCol(map: BodyRowMap, row: number, col: number, atEnd: boolean): {
+    line: number;
+    offset: number;
+};
+//# sourceMappingURL=wrap-geometry.d.ts.map

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

@@ -83,7 +83,7 @@ export declare function formatMultiDiffSummaryThreshold(n: number): string;
 export declare function formatEnhanceDelay(ms: number): string;
 export declare function formatPreRefineSeconds(s: number): string;
 /** Animation style choices for the settings picker — all AnimationStyles plus 'cycle'. */
-export declare const ANIMATION_STYLE_CHOICES: readonly ["rainbow", "wave", "pulse", "dots", "breathe", "cycle"];
+export declare const ANIMATION_STYLE_CHOICES: readonly ["rainbow", "wave", "pulse", "dots", "breathe", "static", "cycle"];
 export type AnimationStyleChoice = (typeof ANIMATION_STYLE_CHOICES)[number];
 /** Human-readable label for an animation style choice (including cycle). */
 export declare function formatAnimationStyle(style: AnimationStyleChoice): string;

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

@@ -91,7 +91,7 @@ export interface SettingsPickerProps {
      */
     wrongProxyEnabled: boolean;
     /**
-     * WrongProxy / WrongTrace URL. Default `http://localhost:8000`. Text
+     * WrongProxy / WrongTrace URL. Default `http://localhost:3444`. Text
      * field (Enter on the row opens an inline edit). Picker field 60.
      */
     wrongProxyUrl: string;

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

@@ -58,10 +58,10 @@ export interface WrongProxyPanelSidebarProps {
     width: number;
 }
 /**
- * Sidebar twin for the live WrongProxy / WrongTrace daemon. Renders
- * the proxy URL, a status pill (LIVE / WARN / DOWN / ?), the round-trip
- * latency when known, and a brief footer hint mirroring the WebUI copy
- * about openai-codex being excluded by spec.
+ * Sidebar twin for the live WrongProxy / WrongTrace daemon. Renders the
+ * proxy URL with its round-trip latency, the probe error detail when
+ * warn/down, and — when the daemon's `/api/health` body exposes them —
+ * the WrongTrace IPC socket path and daemon version.
  *
  * The panel is mounted only when `wrongProxyEnabled` is true at the
  * `app-view-sidebar.tsx` gate — see the `wrongProxyEnabled` usage there.

package/dist/hooks/use-live-settings-state.d.ts

@@ -1,5 +1,5 @@
 import type { Settings } from '../app-settings-type.js';
-type AnimationStyle = 'rainbow' | 'wave' | 'pulse' | 'dots' | 'breathe' | 'cycle';
+type AnimationStyle = 'rainbow' | 'wave' | 'pulse' | 'dots' | 'breathe' | 'static' | 'cycle';
 export declare function useLiveSettingsState({ getSettings, titleController, chime, confirmExit, }: {
     getSettings?: (() => Settings) | undefined;
     titleController?: {

package/dist/hooks/use-mouse-tracking.d.ts

@@ -1,4 +1,4 @@
-import { type MouseTrackingPolicy } from '../mouse.js';
+import type { MouseTrackingPolicy } from '../mouse.js';
 type MouseWritable = {
     write(data: string): unknown;
 } | undefined;

package/dist/hooks/use-sidebar-panel-data.d.ts

@@ -53,6 +53,15 @@ export interface SidebarWrongProxy {
     status: SidebarWrongProxyStatus;
     latencyMs?: number | undefined;
     detail?: string | undefined;
+    /**
+     * WrongTrace IPC endpoint, read from the `/api/health` body's
+     * `socket_path` field (named pipe / UDS the daemon listens on).
+     * Undefined when the daemon is down or does not expose a socket —
+     * the sidebar then omits the IPC rows entirely.
+     */
+    socketPath?: string | undefined;
+    /** Daemon version from the `/api/health` body, when reported. */
+    version?: string | undefined;
 }
 /**
  * Probe the WrongProxy daemon. Refreshes every 8 seconds while