zidane 7.2.5 → 8.0.4

package/dist/transcript-anchors-BeudMbXx.d.ts

@@ -1,1762 +0,0 @@
-import { Bv as SkillConfig, Dd as EditOutcome, Fd as SessionMeta, Hf as ModelInfo, Id as Settings, Jv as SessionData, Ld as StreamEvent, Lf as ProviderAuth, Nd as Picked, Qo as ExtensionRegistry, Rf as ProviderKey, Tc as SubagentRegistry, U_ as SessionTurn, Uc as LoadedPlugin, Wf as ProviderDescriptor, Wl as StorageMode, Xv as SessionRun, Z_ as ThinkingLevel, Zv as SessionStore, ac as StoredExtensionConfigItem, bf as ModelChainEntry, nv as ToolResultContent, qs as ExtensionConfigCategory, t as Preset, wc as SubagentOverride, y_ as McpServerConfig, ym as AgentRegistry, z_ as SessionContentBlock } from "./index-BgN1T3lk.js";
-//#region src/chat/hints.d.ts
-/**
- * Single hint entry — `<key> <label>`, optionally followed by an inline
- * secondary chord (`<key><extra.key> <label> <extra.label>`) for compound
- * shortcuts like `ctrl+m/n model effort`.
- *
- * Colour fields are advisory hex strings (resolved against the active
- * theme by the renderer); leaving them undefined lets the renderer pick
- * its conventional fallback (e.g. `warn` for keys, `dim` for labels,
- * `mute` for secondary).
- */
-interface Hint {
-  key: string;
-  label: string;
-  /** Optional override for the key color. Renderer default: warn. */
-  keyColor?: string;
-  /** Optional override for the label color. Renderer default: dim. */
-  labelColor?: string;
-  /**
-   * Optional secondary chord + value rendered inline after the primary
-   * pair: `<key><extra.key> <label> <extra.label>`. Lets one hint advertise
-   * a compound shortcut (e.g. `ctrl+m/n model effort`) without forcing
-   * callers into a parallel struct or a custom renderer.
-   */
-  extra?: {
-    key: string;
-    label: string;
-    /**
-     * Dispatchable binding spec behind `extra.key` when the displayed
-     * chord is an abbreviation (`/l` for `ctrl+l` — see `shortChord`).
-     * The abbreviation itself doesn't parse as a keypress, so a renderer
-     * that makes the secondary chord independently clickable needs the
-     * full spec. Defaults to `extra.key` when omitted.
-     */
-    keySpec?: string; /** Defaults to mute on the renderer side. */
-    keyColor?: string; /** Defaults to dim on the renderer side. */
-    labelColor?: string;
-  };
-}
-/**
- * Truncate `text` to at most `max` characters, replacing the trailing
- * overflow with `…`. Edge cases:
- *   - `max <= 0` → empty string (no room to render at all).
- *   - `max === 1` → just the ellipsis glyph.
- *   - `text.length <= max` → unchanged.
- *
- * Trailing-style truncation matches the natural read order of titles:
- * the prefix carries enough signal to identify the surface.
- */
-declare function truncateTrailing(text: string, max: number): string;
-/**
- * Plain-text width estimate for a list of {@link Hint}s rendered as
- * `<key> <label> · <key> <label> · …`. Exported so prompt-box overlays
- * can run the same responsive math as the bottom-bar footer when
- * deciding whether trigger hints fit. Pure / total.
- */
-declare function hintsLength(hints: readonly Hint[]): number;
-/**
- * Stable empty list so callers can compare by reference. Exported so
- * any consumer that needs to feed "no primary hints" into the same
- * `clipHintsToWidth` / `renderHintSpans` pipeline (e.g. the TUI's
- * minimal UI mode, where the prompt overlay shows only `@` / `/`
- * triggers) reuses the same frozen array instead of allocating a new
- * one each render.
- */
-declare const EMPTY_HINTS: readonly Hint[];
-/**
- * Return the longest prefix of `hints` whose rendered width fits within
- * `budget`. Used to degrade hint rows gracefully at narrow terminal
- * widths instead of letting an absolutely-positioned hint row wrap
- * mid-segment (which paints the overflow over surrounding borders and
- * looks like garbled glyphs in a TUI).
- *
- * Prefix-only (no reordering, no last-hint priority) so the survivors
- * keep their authored order — the user's muscle memory for "leftmost
- * hint = primary action" stays intact as the terminal shrinks.
- */
-declare function clipHintsToWidth(hints: readonly Hint[], budget: number): readonly Hint[];
-//#endregion
-//#region src/start/shared-options.d.ts
-declare const startProviderNames: readonly ["anthropic", "openai", "openrouter", "cerebras", "xai", "arcee", "baseten", "local", "openai-compat"];
-type StartProviderName = typeof startProviderNames[number];
-declare const startPresetNames: readonly ["basic"];
-type StartPresetName = typeof startPresetNames[number];
-declare const startFormatNames: readonly ["zidane", "provider"];
-type StartFormatName = typeof startFormatNames[number];
-interface StartLocalOptions {
-  system?: string;
-  prompt: string;
-  model?: string;
-  baseURL?: string;
-  apiKeyEnv?: string;
-  headersEnv?: string;
-  extraHeaders?: Record<string, string>;
-  vision?: boolean;
-  imageInToolResult?: boolean;
-  temperature?: number;
-  seed?: number;
-  preset: StartPresetName;
-  thinking: ThinkingLevel;
-  provider: StartProviderName;
-  context: string;
-  image?: string;
-  cwd?: string;
-  env?: Record<string, string>;
-  pregame?: {
-    name: string;
-    content: string;
-  };
-  sandboxId?: string;
-  sandboxOnDestroy?: 'kill' | 'pause' | 'leave';
-  mcp?: McpServerConfig[];
-  sessionDb?: string;
-  sessionId?: string;
-  schema?: Record<string, unknown>;
-  json: boolean;
-  streamJson: boolean;
-  format: StartFormatName;
-}
-//#endregion
-//#region src/chat/keybindings.d.ts
-/**
- * Keybindings — a single source of truth for the app's global shortcuts.
- *
- * Every customizable action is declared once in {@link KEYBINDING_DEFS}
- * with its default trigger, label, and description. The TUI imports
- * `DEFAULT_KEYBINDINGS` for the baked-in defaults; on launch we load
- * `<userDir>/keybindings.json` (when present) and merge user overrides
- * on top so the user can rebind any action without recompiling.
- *
- * Scope (deliberate):
- *
- *   - We expose only the **global, action-opening** shortcuts here —
- *     "open the Settings modal", "cycle agent profile", "enter
- *     select-turn mode", etc. Modal-internal letter shortcuts (`f`
- *     fork, `d` delete, `c` copy on the turn-details modal) and
- *     universal navigation (`↑/↓/↵/⎋`) stay hardcoded — they live
- *     too close to a renderable's input contract to remap safely.
- *
- *   - Storage lives at the **user level** (`<userDir>/keybindings.json`),
- *     never inside a project's `.{prefix}/`. Shortcut muscle memory is
- *     a per-user concern, not a per-repo one.
- *
- * Format on disk: JSON with `//` and `/* … *\/` comments allowed
- * (parsed via a small JSONC stripper). Each entry maps an action id
- * to a binding spec string. Specs are parsed by {@link parseBindingSpec};
- * unknown / malformed entries fall back to the default for that action
- * (with a debug log under `ZIDANE_DEBUG`) so a syntax slip never bricks
- * the TUI.
- */
-/**
- * Every action the keybindings system can drive. Adding a new action
- * here forces every consumer (TUI keyboard handler, hint rows, settings
- * UI) to handle it, and ships a default that the user can override.
- */
-type KeyAction = 'openSettings' | 'openSessionDetails' | 'newSession' | 'openModelPicker' | 'openEffortPicker' | 'openTodos' | 'openArtifacts' | 'panelNext' | 'panelPrev' | 'openContextPanel' | 'openMainSession' | 'openUsagePanel' | 'openKeybindings' | 'openPalette' | 'cycleAgent' | 'enterSelectTurnMode' | 'cancelToolCall' | 'abortRun' | 'changeCwd' | 'attachClipboardImage' | 'openExternalEditor' | 'enterQueueSelection' | 'pushQueuedMessage' | 'dropQueuedMessage' | 'turnFork' | 'turnDelete' | 'turnCopy' | 'turnEdit' | 'sessionDelete' | 'sessionCopyId' | 'sessionGenerateTitle' | 'sessionExportMarkdown' | 'sessionExportJson' | 'sessionCompact';
-/** Resolved keybindings — every action has a current spec string. */
-type KeyBindings = Record<KeyAction, string>;
-/**
- * Resolved spec string for one extension-contributed keybinding. Same
- * shape as a built-in {@link KeyBindings} entry but the `id` is
- * extension-owned (no `KeyAction` union member). The TUI dispatcher
- * iterates these alongside the built-ins; user overrides flow through
- * the same `keybindings.json` file by matching on `id`.
- */
-interface ResolvedExtensionKeybinding {
-  /** Extension-owned id (matches `ExtensionKeybinding.id`). */
-  id: string;
-  /** Active spec string — user override when present, default otherwise. May be empty (= unbound). */
-  spec: string;
-}
-/**
- * Logical grouping for one action — used by the keybindings panel to
- * render section headers. Stable strings (not an enum) so future
- * groups can be added without churning every existing entry.
- */
-type KeyBindingGroup = 'Global' | 'Message queue' | 'Turn details' | 'Session details';
-/** Static metadata for one action — used by the loader, hint rows, settings UI. */
-interface KeyBindingDef {
-  /** Stable identifier — JSON key + TS union member. */
-  action: KeyAction;
-  /** Default trigger spec (e.g. `'ctrl+o'`). */
-  default: string;
-  /** Short label used in shortcut hint rows. */
-  label: string;
-  /** Longer description for the settings UI and the annotated JSON file. */
-  description: string;
-  /**
-   * Group label rendered as a section header in the keybindings panel.
-   * Items are listed in {@link KEYBINDING_DEFS} order; the panel just
-   * inserts a header whenever this field changes between adjacent
-   * entries — so groups stay contiguous and the order here is the
-   * order on screen.
-   */
-  group: KeyBindingGroup;
-}
-/**
- * The canonical action catalog. Order is the source of truth for the
- * generated keybindings file and the settings UI.
- */
-declare const KEYBINDING_DEFS: readonly KeyBindingDef[];
-/** Index by action for O(1) lookup of label / description / default. */
-declare const KEYBINDING_DEF_BY_ACTION: Readonly<Record<KeyAction, KeyBindingDef>>;
-/** Defaults, derived from {@link KEYBINDING_DEFS} so the two never drift. */
-declare const DEFAULT_KEYBINDINGS: KeyBindings;
-/** Parsed shape of a `"ctrl+shift+o"` spec. */
-interface ParsedBinding {
-  ctrl: boolean;
-  shift: boolean;
-  alt: boolean;
-  meta: boolean;
-  /** The key name (e.g. `'o'`, `'tab'`, `'escape'`). Always lowercase. */
-  name: string;
-}
-/**
- * Parse a `'ctrl+shift+o'`-style spec into structured fields. Returns
- * `null` for empty / malformed inputs; the caller falls back to the
- * default for that action.
- *
- * Tolerant by design:
- *   - Case-insensitive (`Ctrl+O` → same as `ctrl+o`).
- *   - Modifier order doesn't matter (`shift+ctrl+o` works).
- *   - Mixed `+` and `-` separators allowed (`ctrl-o`, `ctrl+o`).
- *   - Trailing / leading whitespace is stripped.
- *   - Duplicate modifiers collapse silently.
- */
-declare function parseBindingSpec(spec: string | undefined | null): ParsedBinding | null;
-/**
- * Test a KeyEvent against a parsed-or-string binding. Accepts either
- * form so callers can pre-parse (hot path) or pass the raw spec for
- * one-off checks.
- *
- * Modifier semantics: ALL declared modifiers must be pressed AND no
- * extra modifiers may be pressed. So `'o'` does NOT match `ctrl+o`,
- * and `'ctrl+o'` does NOT match `ctrl+shift+o`. This avoids surprises
- * where a binding that should be specific accidentally fires for a
- * superset of key combinations.
- */
-declare function matchesBinding(event: {
-  name?: string;
-  ctrl?: boolean;
-  shift?: boolean;
-  meta?: boolean;
-  option?: boolean;
-  alt?: boolean;
-}, spec: string | ParsedBinding): boolean;
-/**
- * Render a binding spec (`"ctrl+return"`, `"backspace"`, `"delete"`) as a
- * compact display string the user recognizes at a glance. Substitutes
- * arrow / enter / backspace glyphs for their verbose names so the hint
- * row stays narrow; modifier names + plain keys pass through unchanged.
- *
- * Empty / missing specs return an empty string — callers decide whether
- * to render a placeholder (e.g. `'—'` for an unbound action in the
- * keybindings panel) or hide the surface entirely (e.g. hint rows that
- * fall back to a different chord when the binding is empty).
- */
-declare function formatBindingForDisplay(spec: string | null | undefined): string;
-/**
- * Merge a partial map of user overrides into the defaults. Unknown
- * action keys are dropped (a future TUI version may have retired the
- * action); invalid spec strings (parse fails) fall back to the default
- * for that action.
- */
-declare function mergeKeybindings(overrides: Readonly<Record<string, unknown>> | null | undefined): KeyBindings;
-/** Path of the user-level keybindings file. */
-declare function keybindingsPath(userDir: string): string;
-/**
- * One contiguous section of the catalog — every action in a single
- * `group` rendered together with the section header inserted once.
- * Adjacent sections with the same group are NOT merged: catalog order
- * wins so the on-screen story matches the on-disk file.
- *
- * `rows` may carry built-in `KeyBindingDef`s (the common case) or
- * extension-owned ones (when an extension contributes a keybinding).
- * Both share label / description / spec — see {@link KeyBindingRow}.
- */
-interface KeyBindingSection {
-  group: string;
-  rows: ReadonlyArray<KeyBindingRow>;
-}
-/**
- * One row in the keybindings catalog. Either a built-in action (with
- * its `def`) or an extension-contributed one (with `id` instead). The
- * renderer reads `label` / `description` / `spec` uniformly and only
- * needs the `kind` discriminator when offering action-specific UI
- * (e.g. "edit in keybindings.json" by action name).
- */
-type KeyBindingRow = {
-  kind: 'builtin';
-  def: KeyBindingDef;
-  spec: string;
-} | {
-  kind: 'extension';
-  id: string;
-  label: string;
-  description: string;
-  spec: string;
-};
-/**
- * Walk {@link KEYBINDING_DEFS} in order and bucket rows into contiguous
- * sections by `group`. Shared between the standalone `KeybindingsModal`
- * and the `Keybindings` tab inside `SettingsModal` so both surfaces
- * render the same catalog with the same ordering rules.
- *
- * Pass `extensionRows` (resolved extension keybindings paired with
- * their definitions) to append an "Extensions" section at the end so
- * extension-contributed shortcuts are discoverable in the same UI.
- */
-declare function groupBindings(bindings: KeyBindings, extensionRows?: readonly {
-  id: string;
-  label: string;
-  description: string;
-  spec: string;
-}[]): readonly KeyBindingSection[];
-/**
- * Width (in cells) of the fixed key column used by every binding-row
- * renderer. Derived once from {@link KEYBINDING_DEFS} so a new action
- * with a wider default spec (`ctrl+shift+x`, …) automatically grows
- * the column instead of truncating the label.
- */
-declare const KEYBINDING_KEY_COL_WIDTH: number;
-/**
- * Load + merge the user's keybindings file (when present). Always
- * returns a fully-resolved {@link KeyBindings} — defaults fill in for
- * any missing / invalid entries so consumers can treat the result as
- * total.
- *
- * Failure modes (all tolerated, all fall back to defaults):
- *   - File missing
- *   - File not valid JSON / JSONC (after comment stripping)
- *   - Top-level is not an object
- *   - Individual entries have invalid spec strings
- */
-declare function readKeybindings(userDir: string): KeyBindings;
-/**
- * Create the user-level `keybindings.json` if it doesn't exist,
- * prefilled with every default. Returns the absolute file path either
- * way so the caller can open it in `$EDITOR`. Idempotent: an existing
- * user file is NEVER overwritten — the user's customizations are
- * sacred.
- */
-declare function ensureKeybindingsFile(userDir: string): string;
-/**
- * Read the raw on-disk JSON object from `keybindings.json` after the
- * JSONC stripper. Used by extension-keybinding resolution so the
- * user's overrides for extension-owned ids flow through the same file
- * the built-in actions use.
- *
- * Returns an empty object on missing / malformed / non-object files
- * — same fault-tolerance contract as {@link readKeybindings}.
- */
-declare function readKeybindingsRaw(userDir: string): Readonly<Record<string, unknown>>;
-/**
- * Resolve the live spec string for each extension-contributed
- * keybinding. The user's `keybindings.json` is consulted for an
- * override on the binding's `id`; absent / invalid entries fall back
- * to the binding's `default`.
- *
- * Pass the raw object (from {@link readKeybindingsRaw}) — passing
- * `KeyBindings` here wouldn't help because the typed map only carries
- * built-in `KeyAction` entries.
- *
- * Returns one entry per input binding, in source order. Empty `spec`
- * (binding declared `default: ''` and the user didn't bind it) is a
- * legitimate "unbound" state — the dispatcher never matches an empty
- * spec, so the action stays accessible via re-binding through
- * `keybindings.json`.
- */
-declare function resolveExtensionKeybindings(bindings: readonly {
-  id: string;
-  default: string;
-}[], raw: Readonly<Record<string, unknown>>): ResolvedExtensionKeybinding[];
-/**
- * Strip `//` line comments and `/* … *\/` block comments from a JSONC
- * source string. Stays out of string literals so a `"foo // bar"` value
- * keeps its slashes. Exported for unit-tests; the only runtime caller
- * is {@link readKeybindings}.
- *
- * Trade-off: this is a tiny state-machine, not a full JSONC parser. It
- * doesn't understand `\\` outside strings (irrelevant for JSON) and
- * doesn't track line numbers in error messages. Good enough for a
- * config file — corruption in production gracefully falls back to the
- * defaults via the try/catch in `readKeybindings`.
- */
-declare function stripJsonComments(input: string): string;
-//#endregion
-//#region src/chat/store.d.ts
-interface TuiState {
-  lastProvider?: ProviderKey;
-  lastSessionId?: string;
-  /** Per-provider last-used model id. */
-  lastModelByProvider?: Partial<Record<ProviderKey, string>>;
-  /**
-   * Last-applied model fallback chain (entry 0 = primary, mirroring
-   * `lastProvider` + `lastModelByProvider`; entries 1+ = fallbacks).
-   * Additive — absent for single-model users and older state files.
-   * Restored on launch only when entry 0 still matches the resolved
-   * primary; entries are re-validated against the live registry.
-   */
-  lastModelChain?: ModelChainEntry[];
-  /**
-   * Per-model last-picked reasoning effort. Keyed by model id (not provider)
-   * so switching the same model across providers preserves the user's
-   * intent. Models without reasoning support are absent from the map.
-   */
-  lastEffortByModel?: Record<string, ThinkingLevel>;
-  /**
-   * Per-model last-picked custom options (e.g. `{ fast: true }`). Keyed by
-   * model id like {@link lastEffortByModel}, so a toggle follows the model
-   * across providers. Models with no options are absent from the map.
-   */
-  lastModelOptionsByModel?: Record<string, Record<string, boolean>>;
-  /**
-   * Last-active agent profile id (see {@link AgentRegistry}). Resumed on
-   * launch so a returning user lands back in the same mode (Build / Plan /
-   * a host profile). Falls back to the host's `defaultAgent` then the first
-   * registry key if the id is no longer registered.
-   */
-  /**
-   * @deprecated No longer read: the agent profile is per-session and fresh
-   * sessions always start in the default. Kept so older state files parse.
-   */
-  lastAgent?: string;
-  /** User-toggled transcript filters. Persisted so they outlive a launch. */
-  settings?: Partial<Settings>;
-}
-interface StateStoreApi {
-  load: () => TuiState;
-  save: (state: TuiState) => void;
-}
-declare function createStateStore(path: string): StateStoreApi;
-declare function loadState(path: string): TuiState;
-declare function saveState(path: string, state: TuiState): void;
-/**
- * Load every session and project it to the compact `SessionMeta` shape used by
- * the picker. Sorted by recency via the underlying store's `list()` contract
- * (sqlite store returns by `updated_at DESC`).
- *
- * Robust to per-row failures: `Promise.allSettled` so a single corrupt or
- * unreadable row (malformed JSON, partial write, transient I/O error)
- * doesn't take down the entire picker. Failed rows are silently skipped;
- * a stderr line is emitted under `ZIDANE_DEBUG` for diagnosis.
- */
-declare function listSessionMeta(store: SessionStore, filter?: {
-  /**
-   * Restrict to sessions belonging to this project. Omit to ignore
-   * the axis; pass `null` to ask for untagged (legacy) sessions
-   * specifically. The TUI defaults to passing the current git root /
-   * cwd here so each project sees only its own conversations.
-   */
-  projectRoot?: string | null;
-}): Promise<SessionMeta[]>;
-/** Derive a short title from the first user message — returns null when empty. */
-declare function titleFromTurns(turns: SessionTurn[]): string | null;
-/**
- * Display title for a session — preferred sources, in order:
- *
- *   1. `metadata.title` if it's a non-empty string (typically set by
- *      the session-details modal's "generate title" action).
- *   2. {@link titleFromTurns} — the first user message, one-line + clipped.
- *   3. {@link DEFAULT_SESSION_TITLE} (`'New session'`).
- *
- * Total / pure / defensive on non-string metadata values.
- */
-declare function deriveSessionTitle(turns: SessionTurn[], metadata?: Record<string, unknown>): string;
-/**
- * Replay persisted turns as a viewable transcript. Mirrors the event shape
- * produced live by the agent hooks so loaded and streaming history render
- * identically — including subagent ancestry when `runs` is supplied.
- *
- * Subagent reconstruction:
- *   - Every turn carries a `runId`. We look that up in `runs` to get the
- *     run's `depth` and tag the resulting events with `{ depth, childId }`
- *     — the same shape the live `child:*` bubble hooks produce.
- *   - We synthesize `spawn-start` / `spawn-end` markers at each child-run
- *     boundary so the transcript reads the same as a live run did
- *     (`🌱 [run-id] task` … child events … `🌳 [run-id] done · tokens`).
- *   - For child runs (`depth > 0`), the user-role "task" text is suppressed
- *     because `spawn-start` already shows it.
- *
- * Without `runs` (legacy callers / tests), the function falls back to the
- * old behavior: depth-0 events with no subagent grouping.
- */
-/**
- * Map a `compact-summary` content block to its `compact-summary` StreamEvent —
- * the single source of truth for the compaction boundary card. Used by
- * {@link eventsFromTurns} (reload / TUI live repaint) AND by chat hosts that
- * surface the boundary live without a full reload (the GUI broadcasts this
- * from the loop's `compact:end` hook), so the live card and the reloaded card
- * are byte-identical regardless of who created the marker (manual, the old
- * host trigger, or loop-native auto-compaction — all share this block shape).
- */
-declare function compactSummaryEvent(block: Extract<SessionContentBlock, {
-  type: 'compact-summary';
-}>, turnId?: string): StreamEvent;
-declare function eventsFromTurns(turns: SessionTurn[], runs?: readonly SessionRun[]): StreamEvent[];
-declare function toolCallPreview(name: string, input: Record<string, unknown>): string;
-/**
- * Update the trailing `'tool'` event matching `callId` so its
- * `edit.outcomes` reflects the canonical merged outcomes the chat
- * layer's `tool:transform` hook just computed. Without this, the live
- * diff badges stay frozen at whatever the gate set (approval-side
- * outcomes) and never reflect body-side failures from `multi_edit`'s
- * best-effort run — only a session reload re-attaches the merged
- * outcomes via {@link eventsFromTurns}.
- *
- * Walks back-to-front because the matching event is overwhelmingly the
- * most recent (we're updating right after the body returned). Returns
- * the same reference when no match is found (or the event already
- * carries the target outcomes), so React skips the re-render.
- */
-declare function updateToolEventOutcomes(events: readonly StreamEvent[], callId: string, outcomes: readonly EditOutcome[]): StreamEvent[];
-/** Render tool output as plain text, whether it's a string or structured content. */
-declare function toolResultText(output: string | ToolResultContent[]): string;
-/**
- * Strip the `Tokens: …` line from a spawn tool-result. The spawn-end marker
- * displayed right above already shows the same stats; keeping the line in the
- * rendered tool-result body just produces a visible duplicate (and, on
- * reloaded pre-fix sessions, an *inconsistent* duplicate — the persisted line
- * uses the old `13 in / 4075 out` shape while the freshly synthesized
- * spawn-end uses the cache-aware `in 92615 (cache 92602) / 4075 out` shape).
- *
- * Display-only: the persisted tool_result content is untouched, so the LLM
- * still sees the full string in its context window. Anchored to start-of-line
- * and matches both `Tokens: 13 in / 4075 out` (legacy) and `Tokens: in 13 …`
- * (post-`formatTokenUsage`) shapes.
- */
-declare function stripSpawnTokensLine(text: string): string;
-/**
- * Resolve the top margin (in rows) for an event given the one rendered
- * just before it. Context-aware rules:
- *
- *   - A `tool` / `tool-result` event right after another
- *     `tool` / `tool-result` collapses to a tight list — call→result
- *     pairs and back-to-back calls read as one logical block.
- *   - Consecutive `task-notification` banners stack tight — a burst of
- *     background-task completions reads as one log column rather than
- *     scattered banners.
- *
- * NB: parent-level events (`depth === 0`) following a subagent block
- * (`depth > 0`) get their normal default margin. An earlier revision
- * collapsed this transition to 0 on the assumption that the subagent's
- * `🌳` end-marker provided enough visual separation — it didn't. A
- * 2-cell emoji on the same row as the close marker doesn't create a
- * vertical break, and in hide-subagent-output mode the SubagentBlock
- * box isn't rendered either, so the parent's follow-up markdown was
- * glued directly against the close line. Subagents should READ like
- * tool calls: open with breathing room, close tight inside, and open
- * a clean gap before the parent's next thought — that's the contract
- * the tool-call → markdown transition uses, mirrored here.
- *
- * Renderer-agnostic — TUI uses it as Yoga `marginTop`; a CSS host can
- * use the same number as the row's top margin in `em` / `rem`.
- */
-declare function marginTopFor(event: StreamEvent, previous: StreamEvent | undefined): number;
-/** Effective context size of the most recent assistant turn — drives the footer indicator. */
-/**
- * Walk from the end of `turns` and return the cache-aware input-token total
- * of the most recent **parent** (depth-0) assistant turn. Subagent turns
- * are skipped because their context window is the child's, not the parent's
- * — surfacing a subagent's `usage.input` as the footer's "context used"
- * after a session ends mid-spawn would be misleading. The next prompt
- * feeds the parent, so the parent's last view is what matters.
- *
- * Zero-context placeholder turns are also skipped. `executeTurn`
- * synthesizes an assistant turn with `usage: { input: 0, output: 0 }`
- * when the provider stream throws / aborts before any usage is reported
- * (see `src/loop.ts`'s catch path) — that turn is purely a shape
- * contract for resume, not a real context-window measurement. Without
- * the skip, an abort mid-stream shadows the prior real turn and the
- * footer reads `ctx 0` on the next session load even though earlier
- * turns accumulated meaningful context (and `run.cost`).
- *
- * `runs` is optional for backwards compatibility (older call sites and
- * tests that don't have ancestry info). Without it, this falls back to the
- * pre-fix behavior — depth is unknown so every assistant turn qualifies.
- */
-declare function lastContextSizeFromTurns(turns: SessionTurn[], runs?: readonly SessionRun[]): number;
-/**
- * Sum provider-reported USD cost across every run in a session. Used to
- * seed the live cost indicator on session activation. Returns 0 when no
- * run carries a `cost` (most providers — only OpenRouter reports today).
- */
-declare function sumRunCosts(runs: readonly SessionRun[]): number;
-/** Per-model token/spend totals across a session — see {@link usageByModel}. */
-interface ModelUsageSummary {
-  /** Provider-echoed model id, or `"unknown"` for turns that never recorded one. */
-  modelId: string;
-  turns: number;
-  /** Fresh (uncached) input tokens. */
-  input: number;
-  output: number;
-  cacheRead: number;
-  cacheCreation: number;
-  /** Summed USD cost across turns that carried one (provider-reported or estimated). */
-  cost: number;
-  /**
-   * `false` when at least one turn had no cost figure (no published rate
-   * for the model) — `cost` is then a floor, not a total.
-   */
-  costComplete: boolean;
-}
-/**
- * Aggregate per-model token + spend totals across every run in a session.
- * Parent and subagent runs alike: each turn carries its own `modelId`, so
- * cost-tiered delegation (cheap spawn workers) shows up as separate rows
- * priced at their own rates. Sorted by cost (desc), then total tokens, so
- * the biggest spender reads first.
- */
-declare function usageByModel(runs: readonly SessionRun[]): ModelUsageSummary[];
-//#endregion
-//#region src/chat/config.d.ts
-/**
- * Provider registry — a map keyed by `descriptor.key`. Passed verbatim to the
- * chat engine; there is no implicit merge with built-ins. Hosts that want the
- * four default providers spread {@link BUILTIN_PROVIDERS}; hosts that only
- * want their own pass exactly their own.
- */
-type ProviderRegistry = Readonly<Record<string, ProviderDescriptor>>;
-/**
- * Options accepted by `resolveConfig()` (and, transitively, by `runTui()` and
- * any future GUI launcher). Every field is optional — defaults boot a working
- * chat against the built-in providers with sessions stored under `~/.zidane/`.
- */
-interface ChatOptions {
-  /**
-   * Directory name used under `storageDir` for sessions + state.
-   * Default: `'.zidane'` → `~/.zidane/sessions.db` + `~/.zidane/state.json`.
-   * Pass e.g. `'.myapp'` for `~/.myapp/...`, or `'myapp'` for a visible dir.
-   */
-  prefix?: string;
-  /**
-   * Storage root. Defaults to the user's home directory. Combined with
-   * `prefix` to form the data directory.
-   */
-  storageDir?: string;
-  /**
-   * Provider registry. Each value is a {@link ProviderDescriptor} carrying
-   * label + factory + credential metadata. **No automatic merge** — hosts
-   * pass exactly what they want.
-   *
-   * - Omitted → {@link BUILTIN_PROVIDERS} (anthropic + openai + openrouter + cerebras).
-   * - `providers: BUILTIN_PROVIDERS` → same as omitted, but explicit.
-   * - `providers: { anthropic: anthropicDescriptor }` → only Anthropic.
-   * - `providers: { ...BUILTIN_PROVIDERS, mine: customDescriptor }` → built-ins + custom.
-   * - `providers: { mine: customDescriptor }` → custom-only, **no built-ins**.
-   */
-  providers?: ProviderRegistry;
-  /**
-   * Legacy single-agent preset (tools, system prompt, behavior). When set
-   * **without** {@link ChatOptions.agents}, the resolver wraps this preset
-   * into a one-entry {@link AgentRegistry} keyed `default` so existing
-   * callers keep working and the picker is effectively hidden.
-   *
-   * Prefer `agents` for any multi-profile setup. Passing both throws.
-   */
-  preset?: Preset;
-  /**
-   * Agent profile registry — keyed by `profile.id`. Each profile bundles a
-   * preset with display metadata (label, description, accent). The TUI
-   * shows a picker (Ctrl+A) when more than one profile is registered.
-   *
-   * - Omitted (and `preset` omitted) → {@link BUILTIN_AGENTS} (Build + Plan).
-   * - Omitted but `preset` provided → single-entry registry around the preset.
-   * - Provided → host owns the registry; pass exactly what you want.
-   *
-   * Hosts mixing built-ins with their own typically spread:
-   * `agents: { ...BUILTIN_AGENTS, debug: myDebugProfile }`.
-   */
-  agents?: AgentRegistry;
-  /**
-   * Id of the profile every fresh session (and the initial launch) starts
-   * in. Resolved against `agents`; unknown ids fall through to
-   * `DEFAULT_AGENT_ID`, then the registry's first key. Sessions remember
-   * the profile they were created with; this is never overridden by a
-   * previously picked profile.
-   */
-  defaultAgent?: string;
-  /**
-   * Session store — either an instance or a factory called with the
-   * resolved storage paths. **Required** at the chat layer so this module
-   * stays platform-agnostic (no `bun:sqlite` baked in). Terminal hosts use
-   * `createTuiStore` from `zidane/session/sqlite`; a future GUI host can
-   * supply a different adapter (IndexedDB, remote API, in-memory) without
-   * touching this layer.
-   *
-   * ```ts
-   * import { createTuiStore } from 'zidane/session/sqlite'
-   *
-   * // Either pass a factory…
-   * resolveConfig({ store: paths => createTuiStore(paths.db) })
-   *
-   * // …or an instance built ahead of time.
-   * const store = createTuiStore('/path/to/sessions.db')
-   * resolveConfig({ store })
-   * ```
-   */
-  store: SessionStore | ((paths: ResolvedPaths) => SessionStore);
-  /**
-   * Project-scoped session storage. Off by default; when it resolves
-   * to `true` and the launch happens inside a git repo, zidane
-   * auto-creates `<git-root>/.{prefix}/` and stores `sessions.db` +
-   * `state.json` there — so sessions, mcps.json, and skills all live
-   * alongside the project they belong to. Credentials and the
-   * cross-project safelist stay at `~/.{prefix}/` regardless.
-   *
-   * Precedence (most → least specific): `options.projectDb` >
-   * `ZIDANE_PROJECT_DB` env var (`0`/`false`/`off`/`no` → off,
-   * `1`/`true`/`on`/`yes` → on) > `~/.{prefix}/config.json`
-   * `projectDb` > `false`. Note the host option beats the env var —
-   * setting `ZIDANE_PROJECT_DB` has no effect when the host passes an
-   * explicit `projectDb`.
-   *
-   * When it resolves to `false`, OR when not inside a git repo,
-   * everything lives at `~/.{prefix}/` — the classic single-store
-   * layout.
-   */
-  projectDb?: boolean;
-  /**
-   * Override for the project root. Defaults to `process.cwd()`. Hosts
-   * embedding the TUI from a non-CLI context (tests, daemons) can pin
-   * the cwd here so the git-root walk produces a stable result. Has no
-   * effect when `projectDb` resolves to `false`.
-   */
-  cwd?: string;
-  /**
-   * Optional one-shot launch request used by CLI shells such as `zidane run`.
-   * The TUI opens/creates the requested session and submits the prompt after
-   * the first provider/session activation, while keeping the normal renderer
-   * and persistence behavior.
-   */
-  launch?: StartLocalOptions;
-  /**
-   * Auto-update wiring. When set, the App quietly checks the npm registry
-   * for a newer release of `packageName` (matching the host's package),
-   * caches the result for a day under `userDir/`, and surfaces a passive
-   * `↑ vX.Y.Z` chip in the footer when one is available.
-   *
-   * Consumers wrapping `runTui` for their own CLI inline their own
-   * `package.json` version at build time and pass it here. The bundled
-   * `zidane-tui` binary wires this automatically in `tui/src/cli.ts`.
-   *
-   * Defaults to `null` — no auto-update plumbing, no network calls,
-   * no chip.
-   */
-  autoUpdate?: AutoUpdateConfig | null;
-  /**
-   * Pre-built {@link ExtensionRegistry}. The `resolveConfig` surface is
-   * synchronous; extension `setup()` can be async, so the host must
-   * build the registry ahead of time and pass it here verbatim.
-   *
-   * Typical wiring (matches `runTui`):
-   *
-   * ```ts
-   * import {
-   *   buildExtensionRegistry,
-   *   discoverExtensions,
-   *   inlineLoadedExtension,
-   *   resolveConfig,
-   * } from 'zidane'
-   *
-   * const registry = await buildExtensionRegistry([
-   *   // Project-scoped extensions run arbitrary local code — they stay
-   *   // off unless the host establishes trust explicitly (or the user
-   *   // sets ZIDANE_TRUST_PROJECT_EXTENSIONS=1).
-   *   ...await discoverExtensions({ cwd, prefix, trustProjectExtensions: hostTrustsProject }),
-   *   ...inlineDefinitions.map(inlineLoadedExtension),
-   * ])
-   * const config = resolveConfig({ ...opts, extensionRegistry: registry })
-   * ```
-   *
-   * Omitted → empty registry (no contributions).
-   */
-  extensionRegistry?: ExtensionRegistry;
-  /**
-   * Extra extension scan roots the host used (or wants runtime re-discovery
-   * to use). Each path is a root containing extension dirs/packages:
-   * `<root>/<name>/index.ts`. `runTui` wires this from
-   * `ZIDANE_EXTENSION_DIRS` when omitted.
-   */
-  extensionScanPaths?: readonly string[];
-  /**
-   * Extra Agent Plugin scan roots. Each path is a root containing plugin
-   * directories: `<root>/<name>/plugin.json`. `runTui` wires this from
-   * `ZIDANE_PLUGIN_DIRS` when omitted.
-   *
-   * Appended after the four default roots, so a project or user plugin still
-   * wins a name collision against a dev root.
-   */
-  pluginScanPaths?: readonly string[];
-  /**
-   * Whether project-scoped extensions are trusted to run their (arbitrary,
-   * local) code. Off by default unless the embedding host has established
-   * project trust; falls back to `ZIDANE_TRUST_PROJECT_EXTENSIONS=1`.
-   *
-   * Surfaced on {@link ResolvedConfig.trustProjectExtensions} so a host
-   * that re-discovers extensions at runtime (e.g. the TUI on a working-
-   * directory change) reuses the same trust decision as boot.
-   */
-  trustProjectExtensions?: boolean;
-}
-/**
- * Host-supplied auto-update settings. The check itself is gated on
- * `Settings.checkForUpdates`; passing a config wires the React plumbing.
- *
- * Hosts that want to publish their own consumer-facing package can pass
- * different values without forking anything — the registry / channel /
- * platform-package-prefix are all knobs.
- */
-interface AutoUpdateConfig {
-  /** Top-level npm package the user installs (`zidane-tui`, `my-app`, …). */
-  packageName: string;
-  /** Inlined at build time — usually `pkg.version`. */
-  currentVersion: string;
-  /** dist-tag. Defaults to `'latest'`. */
-  channel?: string;
-  /** Registry base URL. Defaults to `'https://registry.npmjs.org'`. */
-  registry?: string;
-  /**
-   * Override the read-through cache lifetime in ms for the in-TUI hook.
-   * Defaults to `0` — every TUI launch fetches fresh, so the chip
-   * never lies. Pass a positive value (e.g. `3_600_000` for 1 h) to
-   * throttle the registry-poll rate at the cost of staleness.
-   *
-   * The on-disk cache is always WRITTEN, regardless of this value, so
-   * `zidane upgrade` and other tooling read paths benefit immediately.
-   */
-  cacheTtlMs?: number;
-  /**
-   * Platform-package prefix used by the in-place self-update flow when
-   * resolving the per-arch tarball name. Defaults to `'<packageName>-'`
-   * (i.e. `zidane-tui-darwin-arm64` when `packageName === 'zidane-tui'`).
-   * Override only when your platform packages don't follow the `<name>-<key>`
-   * convention.
-   */
-  platformPackagePrefix?: string;
-  /**
-   * Executable name on PATH for `packageName`, used to probe the version
-   * installed on disk (the `↻ vX` "restart to update" chip). Defaults to
-   * `packageName`; the TUI passes `'zidane'` for `zidane-tui`.
-   */
-  binName?: string;
-}
-/** Resolved on-disk layout produced by {@link resolveConfig}. */
-interface ResolvedPaths {
-  /**
-   * Effective data root — equals `userDir` (configDir) when project
-   * mode is off, `projectDir` when it's on. Kept for callers that
-   * wrote against the pre-project-db API; new code should reference
-   * the explicit slots (`configDir` / `dataDir` / `cacheDir` /
-   * `stateDir`) or `projectDir` / `db` / `state` instead.
-   */
-  dir: string;
-  /**
-   * User-scoped config root — credentials, mcp-credentials, keybindings,
-   * `config.json`, `mcps.json`, skills. Legacy alias for `configDir`;
-   * existing call sites still reference `userDir`. In XDG mode this
-   * lands at `$XDG_CONFIG_HOME/zidane`; in legacy mode the four slots
-   * (config / data / state / cache) collapse to a single
-   * `<storageDir>/<prefix>` directory.
-   */
-  userDir: string;
-  /**
-   * Project-scoped data root. Set to `<git-root>/<prefix>` when project
-   * mode resolved to ON and a git root was found. `null` otherwise.
-   */
-  projectDir: string | null;
-  /** Resolved `sessions.db` path. Lives under `projectDir` when active, else `dataDir`. */
-  db: string;
-  /** Resolved `state.json` path. Lives under `projectDir` when active, else `stateDir`. */
-  state: string;
-  /**
-   * XDG config slot — `$XDG_CONFIG_HOME/zidane` on a fresh Linux install,
-   * `<storageDir>/<prefix>` (e.g. `~/.zidane/`) in legacy mode. Holds
-   * user-editable surface (`credentials.json`, `mcps.json`, …).
-   */
-  configDir: string;
-  /**
-   * XDG data slot — `$XDG_DATA_HOME/zidane` on Linux, single-dir
-   * elsewhere. Holds long-lived chat history (`sessions.db`).
-   */
-  dataDir: string;
-  /**
-   * XDG state slot — `$XDG_STATE_HOME/zidane` on Linux, single-dir
-   * elsewhere. Holds per-machine UI bookkeeping (`state.json`).
-   */
-  stateDir: string;
-  /**
-   * XDG cache slot — `$XDG_CACHE_HOME/zidane` on Linux, single-dir
-   * elsewhere. Holds regenerable data: persisted tool results,
-   * background-task logs, auto-update registry cache.
-   */
-  cacheDir: string;
-  /**
-   * Which resolution branch produced the layout. `'xdg'` when split
-   * across the four XDG dirs; one of `'legacy-explicit'`,
-   * `'legacy-existing'`, or `'default'` when the slots collapse to a
-   * single directory. Surfaced for diagnostics + tests.
-   */
-  storageMode: StorageMode;
-}
-interface ResolvedConfig {
-  prefix: string;
-  storageDir: string;
-  paths: ResolvedPaths;
-  providers: ProviderRegistry;
-  /**
-   * Resolved profile registry. Always non-empty; the resolver throws when
-   * the host passes an empty `agents` map (same contract as `providers`).
-   */
-  agents: AgentRegistry;
-  /** Id of the profile to activate on mount. Guaranteed to key into `agents`. */
-  initialAgentId: string;
-  store: SessionStore;
-  stateStore: StateStoreApi;
-  /** Lookup by `ProviderKey` returning the available models for the picker. */
-  modelsFor: (key: ProviderKey) => readonly ModelInfo[];
-  initialState: TuiState;
-  initialSettings: Partial<Settings>;
-  resumeProvider: ProviderAuth | null;
-  initialPicked: Picked | null;
-  /**
-   * Effective keybindings — defaults merged with the user-level
-   * `<userDir>/keybindings.json` (when present). Always fully-resolved
-   * so consumers can treat the record as total. See `./keybindings.ts`
-   * for the action catalog + spec format.
-   */
-  keybindings: KeyBindings;
-  /**
-   * Resolved extension-contributed keybindings. Each entry pairs the
-   * extension's binding definition with the user's effective spec
-   * (override from `keybindings.json` when present, default
-   * otherwise). The TUI dispatcher iterates these alongside the
-   * built-in action catalog; the GUI host can do the same.
-   *
-   * Empty when no extension contributed a keybinding.
-   */
-  extensionKeybindings: readonly ResolvedExtensionKeybinding[];
-  /**
-   * Resolved auto-update knobs (forwarded verbatim from `ChatOptions.autoUpdate`)
-   * — `null` when the host didn't wire one. The TUI feeds this into
-   * `useUpdateCheck` so the footer chip + the `zidane upgrade` subcommand
-   * share a single source of truth.
-   */
-  autoUpdate: AutoUpdateConfig | null;
-  /**
-   * Merged extension contributions — the registry passed via
-   * {@link ChatOptions.extensionRegistry}, returned verbatim, or
-   * {@link EMPTY_EXTENSION_REGISTRY} when the host didn't pass one.
-   * `resolveConfig` is synchronous, so it never runs `setup()` itself;
-   * the host pre-builds the registry with `buildExtensionRegistry`.
-   *
-   * Renderer-side wiring reads `tuiContributions` / `guiContributions`
-   * to mount keybindings / footer hints / modals / panels. The
-   * `extensionPreset` field below carries the agent-side surface
-   * (tools / hooks / mcpServers / skills) ready to spread.
-   */
-  extensions: ExtensionRegistry;
-  /**
-   * Extra extension scan roots used at boot. Runtime re-discovery (TUI cwd
-   * changes, future hosts) feeds these back into the shared discovery helper so
-   * local/dev package roots stay active after the initial launch.
-   */
-  extensionScanPaths: readonly string[];
-  /**
-   * Extra Agent Plugin scan roots used at boot. Threaded into the discovery
-   * shell so a dev root stays active across project/cwd changes, same as
-   * {@link ResolvedConfig.extensionScanPaths}.
-   */
-  pluginScanPaths: readonly string[];
-  /**
-   * Single {@link Preset} folded together from every extension's
-   * agent-side contributions. Hosts spread it into `createAgent()`
-   * alongside the active profile's preset:
-   *
-   * ```ts
-   * const profile = composePresets(extensionPreset, agentProfile.preset)
-   * const agent = createAgent({ ...profile, provider })
-   * ```
-   *
-   * Extension hooks are bucketed per event so every handler fires;
-   * tools and mcpServers compose with profile contributions via the
-   * usual `composePresets` rules. System-prompt fragments land as a
-   * trailing block on `preset.system` (host profiles that re-derive
-   * `system` per session — Build / Plan — append the fragments via
-   * the `system:transform` hook so the live system always carries
-   * them).
-   */
-  extensionPreset: Preset;
-  /**
-   * System-prompt fragments contributed by extensions, in registration
-   * order. Surfaced separately from {@link extensionPreset} so hosts
-   * that re-derive `system` per session (Build / Plan in the TUI) can
-   * append them on `system:transform` instead of trying to merge two
-   * `preset.system` strings.
-   */
-  extensionSystemFragments: readonly string[];
-  /**
-   * Spawnable subagents (adds) contributed by extensions, keyed by name.
-   * Surfaced separately from {@link extensionPreset} (like
-   * {@link extensionSystemFragments}) because subagents don't ride the
-   * preset path — the host merges them onto the spawn tool's base
-   * registry via `spawn.withSubagents(...)` at agent build time.
-   */
-  extensionSubagents: SubagentRegistry;
-  /**
-   * Subagent edits contributed by extensions, keyed by target name and
-   * composed in registration order. Applied (after the adds above) by
-   * the host's `spawn.withSubagents(...)` call so extensions can edit or
-   * delete host- / extension-provided subagents by name.
-   */
-  extensionSubagentOverrides: Record<string, SubagentOverride>;
-  /**
-   * Merged extension-contributed config categories, keyed by category id.
-   * Surfaced (alongside {@link extensionConfigItems}) so the TUI can read
-   * the schema in-process — same way it reads `extensions.themes` — and
-   * the GUI's `extensions:configSchema` IPC can serialize it.
-   */
-  extensionConfigCategories: Readonly<Record<string, ExtensionConfigCategory>>;
-  /**
-   * Merged extension-contributed config items, namespaced
-   * `extName → itemKey → item`. Each item carries its resolved
-   * `category`; values are read default-first via the core resolver.
-   */
-  extensionConfigItems: Readonly<Record<string, Readonly<Record<string, StoredExtensionConfigItem>>>>;
-  /**
-   * Resolved project-extension trust decision (option + env fallback).
-   * Hosts that re-discover extensions at runtime feed this back into
-   * {@link discoverAndBuildExtensionRegistry} so the rebuild trusts the
-   * same scopes boot did.
-   */
-  trustProjectExtensions: boolean;
-  /**
-   * Raw user `keybindings.json` object (post-JSONC-strip). Surfaced so a
-   * host re-resolving {@link extensionKeybindings} at runtime (after an
-   * extension registry rebuild) can reuse the same override source
-   * without a second disk read.
-   */
-  rawKeybindings: Readonly<Record<string, unknown>>;
-  /** One-shot launch request forwarded from {@link ChatOptions.launch}. */
-  launch: StartLocalOptions | null;
-}
-/**
- * Resolve user options into a fully-bound runtime config.
- *
- * NOT pure: besides disk reads, this mutates `process.env` so the harness
- * providers pick up the chat engine's credential store — it sets
- * `ZIDANE_CREDENTIALS_PATH` and reconciles stored API keys / OAuth entries
- * into env via `applyApiKeyEnv` (which can overwrite or delete ambient keys
- * like `ANTHROPIC_API_KEY`; see its JSDoc for the precedence rationale).
- */
-declare function resolveConfig(options: ChatOptions): ResolvedConfig;
-/**
- * Compute the on-disk layout for a single TUI session. Public so hosts
- * (CLI tools, tests, scripted bootstraps) can ask "where will sessions
- * land?" without going through `resolveConfig`'s full machinery.
- *
- * Storage-slot resolution (config / data / state / cache) is delegated
- * to {@link resolveStorageDirs}. In legacy modes the four slots collapse
- * to a single `<storageDir>/<prefix>` directory; in XDG mode they fan
- * out into `$XDG_CONFIG_HOME/zidane`, `$XDG_DATA_HOME/zidane`,
- * `$XDG_STATE_HOME/zidane`, `$XDG_CACHE_HOME/zidane`. See the module
- * doc on `./xdg.ts` for the full precedence chain.
- *
- * Decision logic for project mode (least → most specific):
- *
- *   1. Default: OFF — sessions live in the user-scoped `dataDir`
- *      and get scoped per-project via the `SessionData.projectRoot` tag.
- *   2. `<configDir>/config.json` `projectDb` flag (when present).
- *   3. `ZIDANE_PROJECT_DB` env var (`'0'` / `'false'` / `'off'` → off,
- *      anything else true if set).
- *   4. `options.projectDb` (host call site).
- *
- * Project mode activates only when the resolution above lands on
- * `true` AND a git repo is found above `cwd`. Outside git or with the
- * flag off, sessions + state stay at the user-scoped slots.
- *
- * Auto-creates the project `.{prefix}/` directory when mode resolves
- * to ON (silent — mirrors `ensureStateDir`). User slots are created
- * lazily by the state-store + credentials writers; we don't pre-touch
- * them here so a read-only invocation stays read-only.
- */
-declare function resolveStoragePaths(opts: {
-  prefix: string; /** Explicit storage root. When set, forces legacy-explicit mode. */
-  storageDir?: string;
-  cwd: string; /** Host override for project mode. Beats the user-config + env-var sources. */
-  projectDb?: boolean;
-}): ResolvedPaths;
-//#endregion
-//#region src/chat/credentials.d.ts
-interface ApiKeyCredential {
-  kind: 'apikey';
-  /**
-   * Bearer API key. May be empty when the descriptor has no `envKey` and
-   * authenticates entirely via {@link customFields} (e.g. the `local`
-   * provider, where the auth signal is the configured base URL).
-   */
-  value: string;
-  /**
-   * Free-form fields collected by the wizard from the descriptor's
-   * `customFields` definitions. Keys match the descriptor field's `key`.
-   * Mirrored into `process.env[field.envVar]` by `applyApiKeyEnv` so the
-   * provider's factory can read them via the existing env-var convention.
-   */
-  customFields?: Record<string, string>;
-}
-interface OAuthCredential {
-  kind: 'oauth';
-  access: string;
-  refresh?: string;
-  expires?: number;
-  /**
-   * User-given account name ("work", "personal"). Optional — absent reads as
-   * `DEFAULT_OAUTH_ACCOUNT_LABEL` (see `oauthAccountLabel`). Survives token
-   * refresh because the refresh path spreads the stored entry into the rotated
-   * one (see `resolveOAuthApiKey`).
-   */
-  label?: string;
-  /** Provider-specific extras (e.g. OpenAI Codex `accountId`). */
-  [extra: string]: unknown;
-}
-type ProviderCredential = ApiKeyCredential | OAuthCredential;
-/** One stored credential of a provider, addressed by the file key it lives at. */
-interface StoredCredential {
-  /** File key — the selection identity for promote / remove / relabel. */
-  key: string;
-  credential: ProviderCredential;
-  /** True for the canonical slot, i.e. the credential readers resolve. */
-  active: boolean;
-}
-/** Top-level shape of `credentials.json` — keys are credential-file keys. */
-type CredentialsFile = Record<string, ProviderCredential>;
-/**
- * Resolve the credentials file path given the resolved TUI data directory
- * (typically `~/.zidane`, i.e. `config.paths.dir`).
- *
- * Matches the convention used elsewhere in the TUI (sessions.db, state.json)
- * so a single `ZIDANE_STORAGE_DIR` override moves the entire data root.
- */
-declare function credentialsPath(dataDir: string): string;
-/**
- * Read credentials from disk.
- *
- * Returns `{}` when the file is missing or corrupt (last-ditch tolerance —
- * a hand-edit gone wrong shouldn't lock the user out of re-authing). On first
- * call with no file present, attempts a migration from `cwd/.credentials.json`
- * (the legacy location used by `bun run auth`).
- */
-declare function readCredentials(dataDir: string): CredentialsFile;
-/** Read a single provider's credential (translating via the descriptor). */
-declare function readProviderCredential(dataDir: string, descriptor: ProviderDescriptor): ProviderCredential | undefined;
-/**
- * Both stored credentials for a provider: `active` is the one every reader
- * resolves, `alternate` is the stored-but-not-preferred one (if any).
- *
- * Predates multi-account and only sees the `#alt` slot; use
- * {@link readProviderCredentials} to list every stored account.
- */
-declare function readProviderCredentialPair(dataDir: string, descriptor: ProviderDescriptor): {
-  active?: ProviderCredential;
-  alternate?: ProviderCredential;
-};
-/**
- * Every stored credential of a provider, active first.
- *
- * Tolerant of any kind in any slot: `#alt` is meant for the API key and
- * `#account:N` for OAuth accounts, but a file written by an older build (which
- * parked the OAuth alternate in `#alt`) must still list everything it holds.
- */
-declare function readProviderCredentials(dataDir: string, descriptor: ProviderDescriptor): StoredCredential[];
-/** Pure form of {@link readProviderCredentials} over an already-read file. */
-declare function storedCredentialsOf(all: CredentialsFile, fileKey: string): StoredCredential[];
-/**
- * Write credentials atomically (write-then-rename) with mode 0o600.
- *
- * Atomic on the same filesystem — readers either see the previous file or the
- * new one, never a half-written intermediate. Creates the parent dir if needed
- * (first launch on a fresh machine: `~/.zidane/` may not exist yet).
- */
-declare function writeCredentials(dataDir: string, creds: CredentialsFile): void;
-interface SetProviderCredentialOptions {
-  /**
-   * File key of the stored credential this one REPLACES (a re-auth of a known
-   * account). The slot keeps its position — replacing the active one keeps it
-   * active. When the key is no longer stored (removed from another window
-   * mid-login), the credential is added as a new active account instead.
-   */
-  replaceKey?: string;
-}
-/**
- * Store a credential as the provider's preferred one.
- *
- * The previous active credential is demoted, not destroyed: authenticating
- * with OAuth used to silently delete a working API key (and vice versa), and a
- * second OAuth login used to overwrite the first account. An API key moves to
- * {@link alternateCredKey}; an OAuth grant moves to the next free account slot.
- * Replacing an API key with an API key is a plain overwrite — there is only
- * ever one — and so is an OAuth login that names its predecessor via
- * `replaceKey`.
- */
-declare function setProviderCredential(dataDir: string, descriptor: ProviderDescriptor, cred: ProviderCredential, opts?: SetProviderCredentialOptions): void;
-/**
- * Outcome of {@link setPreferredCredential}.
- *
- * Three states rather than a boolean because the two non-promoting cases need
- * opposite handling: `already-active` is a harmless idempotent call (the UI
- * repaints and moves on), while `not-stored` means the caller asked for a
- * credential that does not exist and should say so.
- */
-type PreferCredentialResult = 'promoted' | 'already-active' | 'not-stored';
-/**
- * What {@link setPreferredCredential} promotes: a stored credential by file
- * key (from {@link readProviderCredentials} / `AuthMethod.key`), or the first
- * stored credential of a kind — the pre-multi-account form, still right when
- * the caller only knows "switch to the API key".
- */
-type PreferredCredentialTarget = ProviderCredential['kind'] | {
-  key: string;
-};
-/**
- * Make one of the provider's stored credentials the preferred one.
- *
- * Swaps the target into the canonical slot and parks the previous active one
- * (see {@link parkDemoted}). Returns which of the three outcomes happened so a
- * caller cannot report a swap that provably did not occur — the write is
- * silent either way, and a success-shaped `void` was a trap for any caller that
- * trusted it instead of refetching.
- */
-declare function setPreferredCredential(dataDir: string, descriptor: ProviderDescriptor, target: PreferredCredentialTarget): PreferCredentialResult;
-/**
- * Drop ONE stored credential. Removing the active one promotes a survivor —
- * another credential of the same kind when there is one (a second OAuth
- * account), else whatever is left — so the provider does not go dark while it
- * still holds a working credential. Returns false when `key` was not stored.
- */
-declare function removeStoredCredential(dataDir: string, descriptor: ProviderDescriptor, key: string): boolean;
-/**
- * Name a stored OAuth account. An empty label drops the field, which reads
- * back as {@link DEFAULT_OAUTH_ACCOUNT_LABEL}. Returns false when `key` holds
- * no OAuth credential.
- */
-declare function setCredentialLabel(dataDir: string, descriptor: ProviderDescriptor, key: string, label: string): boolean;
-/**
- * Sign a provider out — drops EVERY stored credential.
- *
- * "Signed out" has to mean the provider resolves nothing afterwards, which is
- * what this has always guaranteed and what callers named it for; promoting a
- * survivor instead would silently leave the provider authenticated through
- * another source. Callers that want that behavior use
- * {@link removeStoredCredential} on the one slot they mean.
- */
-declare function removeProviderCredential(dataDir: string, descriptor: ProviderDescriptor): void;
-/**
- * Reconcile `process.env` with the stored credentials so the harness providers
- * pick up the wizard's output via their existing env-var resolution. Called
- * once at TUI launch after the credentials file has been resolved.
- *
- * **Precedence: stored credential > ambient env.** When the user has run the
- * auth wizard, that's an explicit, recent action — it MUST win over whatever
- * ambient value is already in `process.env`. Otherwise an upgrade reliably
- * breaks for anyone whose cwd happens to contain a stale `.env`: Bun
- * auto-loads `.env` from cwd into `process.env` before our code runs, the
- * legacy `bun run auth` used to upsert tokens into `cwd/.env`, and even a
- * one-off `export ANTHROPIC_API_KEY=…` from months ago in the user's shell rc
- * can outlive its usefulness. None of those should override a key the user
- * just typed into the wizard.
- *
- * Three cases per registered provider with an `envKey`:
- *
- *   1. Stored `kind: 'apikey'` → overwrite env with the stored value. Wizard
- *      wins. A debug log fires when this clobbers a different ambient value.
- *   2. Stored `kind: 'oauth'`  → DELETE env, so {@link resolveOAuthApiKey}
- *      falls through to the file-read + refresh path. A stale OAuth token
- *      in env would otherwise short-circuit refresh and get rejected.
- *   3. No stored entry → leave env alone. Env-only setups (no wizard run yet,
- *      hosts driving zidane purely from secrets management) keep working.
- *
- * To opt out and force ambient env to win again, the user signs the provider
- * out via the wizard (which deletes the stored entry → case 3 above).
- *
- * Descriptors without an `envKey` (OAuth-only providers, custom providers
- * that bypass env-var resolution) are skipped silently.
- */
-declare function applyApiKeyEnv(dataDir: string, registry: Readonly<Record<string, ProviderDescriptor>>, opts?: {
-  log?: (message: string) => void;
-}): void;
-//#endregion
-//#region src/chat/mcps-discovery.d.ts
-/**
- * One entry in the discovered list. `path` is the source file (one of
- * the `mcp(s).json` variants under `.agents/` or `.{prefix}/`) so a
- * Settings picker can show "Defined in ~/.zidane/mcp.json" tooltips
- * and the user can tell which file declared what.
- */
-interface DiscoveredMcp {
-  config: McpServerConfig;
-  source: 'project' | 'user';
-  path: string;
-}
-/**
- * Search order for MCP config files — see {@link projectUserPaths}.
- *
- * Both `mcps.json` (zidane's canonical name) and `mcp.json` (Cursor /
- * common ecosystem alias) are picked up from every search root. The
- * canonical name wins within the same directory; across files the
- * usual first-found-by-name dedup applies, so `mcp.json` effectively
- * merges its non-overlapping entries on top of `mcps.json`.
- *
- * Order per scope (project beats user):
- *   1. `{project}/.agents/mcps.json`
- *   2. `{project}/.agents/mcp.json`
- *   3. `{project}/.{prefix}/mcps.json`
- *   4. `{project}/.{prefix}/mcp.json`
- *   5. `~/.agents/mcps.json`
- *   6. `~/.agents/mcp.json`
- *   7. `~/.{prefix}/mcps.json`
- *   8. `~/.{prefix}/mcp.json`
- *
- * Non-existent files are skipped without error.
- */
-declare function defaultMcpsConfigPaths(opts?: {
-  cwd?: string;
-  home?: string;
-  prefix?: string;
-}): {
-  path: string;
-  source: 'project' | 'user';
-}[];
-/**
- * Parse one `mcps.json` file. Canonical zidane shape is a flat array; the
- * other shapes exist for copy-paste from neighboring tools:
- *
- *   - `McpServerConfig[]` — flat array (recommended).
- *   - `{ name: {...} }` — name-keyed map.
- *   - `{ "mcpServers": { name: {...} } }` — Claude Desktop / Claude Code /
- *     Cursor wrapper. Unwrapped before normalization (otherwise
- *     `normalizeMcpServers` would treat the whole wrapper as a single server).
- *
- * Per-entry `enabled: false` (Cursor runtime state) drops the entry — same
- * intent as the source tool. Use the TUI toggle list for "show but disabled".
- *
- * Tolerant to common copy-paste artifacts: when strict `JSON.parse` fails,
- * retries after normalizing invisible whitespace that's valid Unicode but
- * not valid JSON whitespace (BOM, NBSP, zero-width spaces, line/paragraph
- * separators) — only OUTSIDE string literals, so user data isn't mutated.
- * If the sanitized version still fails, throws the original error with a
- * targeted hint when NBSPs are present.
- *
- * Validation flows through `normalizeMcpServers` so the result matches
- * what `createAgent` accepts. Throws on truly malformed JSON; the caller
- * decides whether to surface or swallow.
- */
-declare function parseMcpsFile(text: string): McpServerConfig[];
-/**
- * Per-file failure surfaced from {@link discoverProjectMcps}. The TUI shows
- * these in the MCP settings empty / preamble state so a malformed
- * `mcps.json` doesn't look identical to a missing one.
- */
-interface DiscoveryError {
-  path: string;
-  source: 'project' | 'user';
-  message: string;
-  /**
-   * A deliberate, documented behavior being reported (e.g. the ruler stdio
-   * security carve-out) rather than a failure. Hosts should style these as
-   * info, not error — crying wolf over a working default trains users to
-   * ignore the channel that also carries real parse failures.
-   */
-  informational?: boolean;
-}
-/**
- * Result of {@link discoverProjectMcps}. `servers` is the per-source-priority
- * merged list (project beats user, first-found wins on name collision).
- * `errors` is one entry per file that existed but failed to parse, plus
- * informational entries for servers a security gate skipped (ruler stdio
- * without the foreign-agent opt-in) — empty on the happy path.
- */
-interface DiscoveryResult {
-  servers: DiscoveredMcp[];
-  errors: DiscoveryError[];
-}
-/**
- * Walk the default config paths, parse every file that exists, and return
- * `{ servers, errors }` in source-priority order. Project entries appear
- * before user entries; first occurrence of a `name` wins (later
- * duplicates dropped).
- *
- * Parse failures are captured into `errors` rather than thrown — the picker
- * surfaces them while still showing whatever DID parse. A `ZIDANE_DEBUG`
- * log line is also emitted for ops visibility.
- */
-declare function discoverProjectMcps(opts?: {
-  cwd?: string;
-  home?: string;
-  prefix?: string;
-  /**
-   * Also read MCP configs other agents maintain (Claude Code, Codex,
-   * Pi) — see `foreign-configs.ts`. Mirrors the `importForeignConfigs`
-   * setting; native locations always win name collisions, and project
-   * beats user within each group.
-   */
-  foreignAgents?: boolean;
-  /**
-   * Also read Ruler MCP configs (`.ruler/ruler.toml` + `mcp.json`,
-   * project and XDG-global) — see `ruler-configs.ts`. Mirrors the
-   * `importRulerConfigs` setting; same collision rules as above.
-   */
-  ruler?: boolean;
-}): DiscoveryResult;
-/**
- * Map a user-toggled enable list onto the `mcpServers` array the agent
- * receives. Conventions match `buildSkillsConfig`:
- *
- *   - `enabled === undefined` → every discovered server enabled (default).
- *   - `enabled === []`        → no servers (the agent runs MCP-less).
- *   - `enabled === [names]`   → allowlist; servers not in the list are
- *                               dropped.
- *
- * `disabledTools` is the per-server tool deny-list from
- * `Settings.disabledMcpTools`. For each server that survives the
- * server-level enable filter, the per-tool names are merged into
- * `McpServerConfig.disabledTools` via **union** with anything the JSON
- * file already pinned — a tool listed in either source is dropped.
- * Union (not override) keeps JSON-side policy stable: a server file
- * that pins `disabledTools: ['dangerous_tool']` can't be re-enabled
- * via the UI by accident.
- *
- * `enabledTools` (JSON-side allowlist) takes precedence over the
- * UI-side deny-list when both are set on the same server — the
- * allowlist's "only these" semantics would be meaningless if a UI
- * deny-list could subtract from it again. We don't emit `disabledTools`
- * when `enabledTools` is present.
- *
- * Returns a fresh array — callers can mutate without affecting the
- * underlying discovery list. Per-server config objects are also fresh
- * copies (shallow), so the merged `disabledTools` doesn't leak back
- * onto the discovery catalog.
- */
-declare function buildMcpServers(opts: {
-  discovered: readonly DiscoveredMcp[];
-  enabled?: readonly string[];
-  disabledTools?: Record<string, readonly string[]>;
-}): McpServerConfig[];
-/**
- * Dedup a merged MCP-server list by `name`. First entry wins.
- *
- * Applied at agent build across every source that can contribute a server —
- * `mcps.json`, Agent Plugins, launch options, extensions — so the earliest
- * source in that order takes precedence.
- *
- * Drops are REPORTED rather than silent, via `onDropped`. A plugin shipping a
- * `github` server loses to a `github` in `mcps.json`, and nothing downstream
- * says so: the plugin's settings row still counts the server it shipped,
- * because the row renders what the PACKAGE declares and only this merge knows
- * what survived. That mirrors how the skills side reports the same class of
- * event — `resolveSkills` emits `name-collision-shadowed` on the winner rather
- * than annotating the loser.
- *
- * The reporter is injected rather than calling a logger directly so this stays
- * a pure function of its input, testable without a logging shim. It lives here
- * beside {@link buildMcpServers} rather than in the TUI because merge
- * precedence is a config concern, not a rendering one.
- */
-declare function dedupMcpServersByName<T extends {
-  name: string;
-}>(servers: readonly T[], onDropped?: (names: readonly string[]) => void): T[];
-//#endregion
-//#region src/chat/project-user-paths.d.ts
-/**
- * Shared search-path builder for project + user config discovery.
- *
- * Both Skills (`skills/<name>/SKILL.md`) and MCP servers (`mcps.json`)
- * follow the same first-found-wins order:
- *
- *   1. `{project-root}/.agents/<sub>`   — project, agnostic convention
- *   2. `{project-root}/.{prefix}/<sub>` — project, zidane (`.zidane` default)
- *   3. `~/.agents/<sub>`                — user, agnostic
- *   4. `~/.{prefix}/<sub>`              — user, zidane
- *
- * `{project-root}` is the git root walked up from `cwd` when present,
- * else `cwd` itself. This pairs with the project-scoped session
- * storage (`resolveStoragePaths`) so all three project-aware surfaces
- * — sessions, mcps, skills — anchor at the same `.{prefix}/`.
- *
- * Centralizing the pattern keeps the four paths in one place — a third
- * discovery surface (hooks, rules, …) gets the same convention for free
- * and stays in lock-step on a prefix bump.
- */
-/** A discovered path tagged with whether it lives in the project or the user dir. */
-interface ProjectUserPath {
-  path: string;
-  source: 'project' | 'user';
-}
-/**
- * Resolve the four search paths for a given subdirectory (`skills`,
- * `mcps.json`, …). Returns absolute paths regardless of whether they
- * exist — the caller chooses to `existsSync`-filter or feed straight
- * into a tolerant discovery routine.
- */
-declare function projectUserPaths(opts: {
-  /** Subdirectory or filename relative to each search root. E.g. `'skills'`, `'mcps.json'`. */subPath: string; /** Discovery cwd. Default: `process.cwd()`. */
-  cwd?: string; /** User home directory. Default: `os.homedir()`. */
-  home?: string; /** Storage prefix. Leading dot tolerated. Default: `'.zidane'`. */
-  prefix?: string;
-}): ProjectUserPath[];
-//#endregion
-//#region src/chat/plugins-discovery.d.ts
-/** One plugin found on disk, loaded (successfully or not). */
-interface DiscoveredPlugin {
-  /**
-   * Identity for dedup + the enabled allowlist. The manifest's `name` when
-   * the plugin loaded; the directory basename when it didn't, so a rejected
-   * plugin still has something stable to key a row and a toggle on.
-   */
-  name: string;
-  /** Load result. Check `ok` before trusting `manifest`. */
-  plugin: LoadedPlugin;
-  /** Which search root it came from. */
-  source: 'project' | 'user';
-  /** Plugin root directory, as discovered. */
-  path: string;
-}
-/**
- * Load every plugin reachable from the default search roots.
- *
- * Each immediate child directory of a root is one plugin — the same
- * depth-1 rule the spec applies inside `skills/`. A child that isn't a
- * directory, or that holds no `plugin.json`, is silently skipped: dropping a
- * README next to your plugins is not an error.
- *
- * Dedup is by plugin NAME, not directory name, because the manifest owns
- * identity — two directories called `tools/` shipping different plugins are
- * two plugins, and one plugin vendored at two scopes is one plugin.
- */
-declare function discoverProjectPlugins(opts?: {
-  cwd?: string;
-  home?: string;
-  prefix?: string;
-  /**
-   * Extra scan roots appended AFTER the four defaults — typically from
-   * {@link parsePluginScanPathEnv}. Ordered last so a real project or user
-   * plugin always wins a name collision against a dev/host-provided root.
-   *
-   * Scoped `'project'`: they're supplied by whoever launched the process, the
-   * same trust level as a plugin sitting in the working tree.
-   */
-  extraRoots?: readonly string[];
-  signal?: AbortSignal;
-}): Promise<{
-  plugins: DiscoveredPlugin[];
-  errors: DiscoveryError[];
-}>;
-/**
- * Map the user's enabled-plugin list onto the contributions a host merges
- * into the agent.
- *
- * Conventions match `enabledSkills` / `enabledMcps`:
- *   - `undefined` → every discovered plugin is enabled (default)
- *   - `[]`        → all off
- *   - `[names]`   → allowlist
- *
- * A plugin that failed to load contributes nothing regardless of the
- * allowlist — `ok: false` means components were never discovered.
- */
-declare function buildPluginContributions(opts: {
-  discovered: readonly DiscoveredPlugin[];
-  enabled?: readonly string[];
-}): {
-  skills: SkillConfig[];
-  mcpServers: McpServerConfig[];
-};
-//#endregion
-//#region src/chat/enabled-toggle-set.d.ts
-/**
- * Renderer-agnostic state machine for an "enabled allowlist" — the shape
- * used by `settings.enabledSkills` / `settings.enabledMcps` (and any future
- * `enabledX` toggle backed by a `Settings` field).
- *
- * Semantics, kept identical across all three call sites:
- *   - `undefined`  → every catalog entry is enabled (default — user has
- *                    never opened the picker; new entries flow in).
- *   - `[]`         → the whole subsystem is off.
- *   - `[names]`    → explicit allowlist; the persisted shape stays a
- *                    concrete array once the user has toggled anything.
- *
- * The hook exposes a live `enabledSet` (Set<string>) + a `toggle(name)`
- * callback that persists the result through `useSettings().setSetting`.
- * The first toggle seeds the persisted allowlist from the current catalog
- * so newly-added entries don't silently drop on the next launch.
- *
- * Renderer-neutral: works for the TUI's `<ToggleListModal>`, a GUI
- * checkbox list, a CLI flag tool. Hook tests live alongside the chat
- * suite; the rendering layer is tested where it lives.
- */
-/** Settings keys whose value type is `readonly string[] | undefined`. */
-type EnabledAllowlistKey = 'enabledSkills' | 'enabledMcps' | 'enabledExtensions' | 'enabledPlugins';
-interface EnabledToggleSet {
-  /** Live set of enabled names — `Set` for O(1) `has`. */
-  enabledSet: ReadonlySet<string>;
-  /** Toggle one name on/off; persists immediately via `setSetting`. */
-  toggle: (name: string) => void;
-}
-/**
- * Bind an "enabled allowlist" setting to a discovered catalog.
- *
- * `keyOf` extracts the persisted identity from a catalog entry (skill name,
- * MCP server name, …). Pass a stable, collision-free key — the persisted
- * allowlist is keyed against it forever.
- */
-declare function useEnabledToggleSet<T>(opts: {
-  catalog: readonly T[];
-  keyOf: (entry: T) => string;
-  settingKey: EnabledAllowlistKey;
-  /**
-   * Names that survive the persisted-allowlist GC even when absent from
-   * `catalog`. Use when the catalog deliberately hides entries that are
-   * still known to exist — e.g. errored / untrusted extensions are kept
-   * out of the toggle list but must not be dropped from the allowlist
-   * by an unrelated toggle. Defaults to the catalog keys.
-   */
-  gcKeys?: readonly string[];
-}): EnabledToggleSet;
-//#endregion
-//#region src/chat/session-export.d.ts
-/** File format supported by the exporter. */
-type SessionExportFormat = 'markdown' | 'json';
-/**
- * Anchor for the resolved destination directory:
- *   - `project` — the nearest enclosing git repository (`<repoRoot>/.{prefix}/sessions`)
- *   - `home`    — fallback when no repo was found (`~/.{prefix}/sessions`)
- */
-type SessionExportAnchor = 'project' | 'home';
-/** Resolved file destination for a session export. */
-interface SessionExportTarget {
-  /** Absolute directory holding the file. May not exist yet — `writeSessionExport` creates it on demand. */
-  dir: string;
-  /** Absolute path of the file (`dir/{id}.{ext}`). */
-  filepath: string;
-  /** Where the destination was anchored. */
-  anchor: SessionExportAnchor;
-}
-/** Options shared by every resolve / write entry-point. */
-interface ResolveOptions {
-  /** Discovery cwd. Defaults to `process.cwd()`. */
-  cwd?: string;
-  /** User home directory. Defaults to `os.homedir()`. */
-  home?: string;
-  /**
-   * Storage prefix. Leading dot tolerated (`zidane` and `.zidane` are
-   * equivalent). Defaults to `'.zidane'`.
-   */
-  prefix?: string;
-}
-/**
- * Resolve the export target for a session id + format. Pure: no fs
- * write happens here, the caller decides whether to `existsSync` the
- * directory or hand the path to `writeSessionExport`.
- *
- * Anchor selection walks upward from `cwd` looking for a `.git` entry;
- * the first hit anchors to that repo's root (`project`). When the walk
- * exits without finding `.git`, the destination anchors to `home`.
- *
- * @throws RangeError when `sessionId` would resolve to an empty / `..`
- *   filename — defensive guard against malicious or buggy callers
- *   crossing into a sibling directory via the id.
- */
-declare function resolveSessionExportTarget(opts: {
-  sessionId: string;
-  format: SessionExportFormat;
-} & ResolveOptions): SessionExportTarget;
-/**
- * Render a session into a string in the requested format.
- *
- * `markdown` produces a human-readable transcript: a YAML-free header
- * block with the title and a one-line `id · created · turns` summary,
- * a stats section (turns / runs / tokens / cost / status), then a
- * `## Conversation` block where each turn renders as `### N. role ·
- * run_X · ISO-date` with text, thinking, tool calls, and tool results
- * formatted as appropriate fenced blocks. Useful for sharing a session
- * with a teammate or pasting into an issue tracker.
- *
- * `json` returns a 2-space-indented, deterministic dump of the full
- * `SessionData` blob. Useful for re-importing into the store or for
- * post-hoc analysis tooling.
- */
-declare function renderSession(session: SessionData, format: SessionExportFormat): string;
-/**
- * Render `session` and write the resulting bytes to disk. Returns the
- * resolved target so the caller can show the user where the file
- * landed. The parent directory is created on demand (`recursive: true`)
- * — first-time exports don't need any pre-flight setup.
- */
-declare function writeSessionExport(opts: {
-  session: SessionData;
-  format: SessionExportFormat;
-} & ResolveOptions): Promise<SessionExportTarget>;
-//#endregion
-//#region src/chat/transcript-anchors.d.ts
-/**
- * One entry in the partitioned transcript-row list. Single events
- * render as a normal row; a `child-run` groups ONE subagent's events
- * from a consecutive run of subagent output into one bordered box
- * (concurrent siblings get a `child-run` each, so their rows never
- * braid together inside a shared frame); `tool-group`s
- * collect ALL parent-owned tool/tool-result events of one exchange
- * into a single collapsible summary row (`Settings.groupToolCalls`);
- * an `exchange-fold` goes further (`Settings.transcriptDensity:
- * 'compact'`) and takes every thinking, tool and worker event of the
- * exchange, leaving only the prompt and the assistant's prose in place.
- * `key` is stable across re-partitions of the same stream (derived
- * from the first grouped event) so expand state survives appends.
- *
- * Currently produced by the TUI's `partitionTranscript`; a GUI shell
- * grouping subagent runs the same way can produce the same shape.
- */
-type TranscriptItem = {
-  kind: 'event';
-  event: StreamEvent;
-  previous?: StreamEvent;
-} | {
-  kind: 'child-run';
-  events: StreamEvent[];
-  previous?: StreamEvent;
-} | {
-  kind: 'tool-group';
-  key: string;
-  events: StreamEvent[];
-  previous?: StreamEvent;
-} | {
-  kind: 'exchange-fold';
-  key: string;
-  events: StreamEvent[];
-  previous?: StreamEvent;
-};
-/**
- * Per-item anchor ids for auto-scroll. Walks `items` in render order
- * and, for each event, returns either:
- *   - `'turn-anchor-<turnId>'` — the first event of this turn (the
- *     scroll target).
- *   - `undefined` — later event of an already-tagged turn (or a
- *     synthetic event with no `turnId`).
- *
- * `ids[i]` is a tuple per item: length 1 for plain events, length N
- * for subagent runs (one entry per inner event). `idByTurn` is the
- * inverse lookup used by the scroll effect. `lastTurnId` is the
- * most-recently-rendered turn — the scroll effect special-cases it to
- * snap to bottom rather than scroll the anchor into view (which would
- * stop short of the actual tail).
- *
- * Exported so the anchor-tagging matrix can be unit-tested without
- * rendering anything.
- */
-declare function computeTurnAnchors(items: readonly TranscriptItem[]): {
-  idByTurn: ReadonlyMap<string, string>;
-  ids: readonly (readonly (string | undefined)[])[];
-  lastTurnId: string | undefined;
-};
-//#endregion
-export { ModelUsageSummary as $, ProviderCredential as A, groupBindings as At, removeStoredCredential as B, Hint as Bt, discoverProjectMcps as C, KeyBindingDef as Ct, OAuthCredential as D, ResolvedExtensionKeybinding as Dt, CredentialsFile as E, ParsedBinding as Et, readCredentials as F, readKeybindings as Ft, writeCredentials as G, setPreferredCredential as H, hintsLength as Ht, readProviderCredential as I, readKeybindingsRaw as It, ProviderRegistry as J, AutoUpdateConfig as K, readProviderCredentialPair as L, resolveExtensionKeybindings as Lt, StoredCredential as M, matchesBinding as Mt, applyApiKeyEnv as N, mergeKeybindings as Nt, PreferCredentialResult as O, ensureKeybindingsFile as Ot, credentialsPath as P, parseBindingSpec as Pt, resolveStoragePaths as Q, readProviderCredentials as R, stripJsonComments as Rt, defaultMcpsConfigPaths as S, KeyAction as St, ApiKeyCredential as T, KeyBindings as Tt, setProviderCredential as U, truncateTrailing as Ut, setCredentialLabel as V, clipHintsToWidth as Vt, storedCredentialsOf as W, ResolvedPaths as X, ResolvedConfig as Y, resolveConfig as Z, DiscoveredMcp as _, usageByModel as _t, SessionExportTarget as a, eventsFromTurns as at, buildMcpServers as b, KEYBINDING_DEF_BY_ACTION as bt, writeSessionExport as c, loadState as ct, useEnabledToggleSet as d, stripSpawnTokensLine as dt, StateStoreApi as et, DiscoveredPlugin as f, sumRunCosts as ft, projectUserPaths as g, updateToolEventOutcomes as gt, ProjectUserPath as h, toolResultText as ht, SessionExportFormat as i, deriveSessionTitle as it, SetProviderCredentialOptions as j, keybindingsPath as jt, PreferredCredentialTarget as k, formatBindingForDisplay as kt, EnabledAllowlistKey as l, marginTopFor as lt, discoverProjectPlugins as m, toolCallPreview as mt, computeTurnAnchors as n, compactSummaryEvent as nt, renderSession as o, lastContextSizeFromTurns as ot, buildPluginContributions as p, titleFromTurns as pt, ChatOptions as q, SessionExportAnchor as r, createStateStore as rt, resolveSessionExportTarget as s, listSessionMeta as st, TranscriptItem as t, TuiState as tt, EnabledToggleSet as u, saveState as ut, DiscoveryError as v, DEFAULT_KEYBINDINGS as vt, parseMcpsFile as w, KeyBindingSection as wt, dedupMcpServersByName as x, KEYBINDING_KEY_COL_WIDTH as xt, DiscoveryResult as y, KEYBINDING_DEFS as yt, removeProviderCredential as z, EMPTY_HINTS as zt };
-//# sourceMappingURL=transcript-anchors-BeudMbXx.d.ts.map