zidane 5.14.4 → 6.0.0

package/dist/{transcript-anchors-BHIgMlPq.d.ts → transcript-anchors-Cb-bDbNH.d.ts}

@@ -1,130 +1,4 @@
-import { G as SessionRun, K as SessionStore, Kn as McpServerConfig, Sr as ToolResultContent, T as ToolDef, W as SessionData, _r as ThinkingLevel, mr as SessionTurn, ur as SessionContentBlock } from "./agent-EFWt6uQ_.js";
-import { t as Preset } from "./index-BtzE3Uaq.js";
-import { A as SessionMeta, G as ProviderKey, I as CompletionItem, L as CompletionProvider, M as StreamEvent, O as Picked, P as ActiveTrigger, R as CompletionReference, W as ProviderAuth, Y as ModelInfo, Z as ProviderDescriptor, j as Settings, w as EditOutcome } from "./tool-formatters-C6iLgc9f.js";
-import { ReactNode } from "react";
-
-//#region src/chat/agents.d.ts
-/**
- * Theme color token used to accent the active profile in the UI (footer
- * badge, picker highlight). Resolved against `ThemeColors` via
- * `useColors()`; falls back to `accent` when omitted.
- */
-type AgentAccent = 'brand' | 'accent' | 'warn' | 'model';
-/**
- * Resolve a profile's `accent` token to a concrete hex color via the
- * caller's color palette. Renderer-agnostic — accepts the four-role
- * subset of `ThemeColors` that's relevant to accent surfaces, so this
- * helper composes against either `useColors()` (TUI) or a CSS-variable
- * lookup (GUI). Omitted / unknown tokens fall back to `accent`.
- */
-declare function accentColor(accent: AgentAccent | undefined, COLOR: {
-  brand: string;
-  accent: string;
-  warn: string;
-  model: string;
-}): string;
-interface AgentProfile {
-  /** Stable identifier persisted in `TuiState.lastAgent` and shown in keybindings. */
-  id: string;
-  /** Human-readable label rendered in the picker and footer badge. */
-  label: string;
-  /** One-line description shown next to the label in the picker. */
-  description: string;
-  /**
-   * Preset applied to `createAgent()` when this profile is active. Profiles
-   * are self-contained: the host's chat-level `preset` (if any) is NOT
-   * merged underneath. Hosts that want a shared base across profiles
-   * should compose it explicitly in each profile's preset.
-   */
-  preset: Preset;
-  /** Theme token used by the picker / footer badge. Defaults to `'accent'`. */
-  accent?: AgentAccent;
-}
-type AgentRegistry = Readonly<Record<string, AgentProfile>>;
-/**
- * Tools the chat layer never persists to disk, regardless of output size.
- *
- * Rationale per entry:
- * - `read_file` — our reader is already paginated (`offset` + `limit`).
- *   Persisting the slice the model asked for and pointing it at the
- *   persisted path is circular; if the model wants more, it pages.
- * - `tool_search` — short metadata envelope. Never large.
- * - `skills_use` / `skills_read` — the `<skill_content>` body is
- *   intentionally part of the prompt; persisting it defeats the purpose.
- * - `read_chat_turns` — previous-chat excerpts are explicitly loaded
- *   conversation context; persisting them defeats the purpose.
- * - `present_plan` / `ask_user` — short JSON envelopes (decision +
- *   answers). Never large.
- * - `spawn` — the subagent's final report IS the value of the call;
- *   stubbing it out would defeat the orchestration pattern.
- *
- * Exported so SDK consumers building custom profiles can extend the list
- * (e.g. host-defined `screenshot` tool whose base64 payload should stay
- * inline). Set `behavior.persistExcludeTools` to your own list to fully
- * override.
- */
-declare const DEFAULT_PERSIST_EXCLUDE_TOOLS: readonly string[];
-/**
- * Tools whose output is exempt from the per-turn `toolOutputBudget` accounting.
- *
- * These tools exist to LOAD context into the conversation — their text output
- * IS the value of the call. Counting it against the budget steers the model
- * away from the very tool it needs to make progress (e.g. a 78 KiB
- * `tool_search` response for a 20-tool Notion MCP server would trigger the
- * "summarize before calling more tools" nudge on the very turn that
- * unlocked those tools, making them effectively unusable).
- *
- * Note this list is intentionally narrower than {@link DEFAULT_PERSIST_EXCLUDE_TOOLS}:
- * `read_file` is NOT exempt — a 200 KiB file load is exactly the case the
- * budget should steer against. Same for `spawn` (a sprawling subagent
- * report should still nudge a consolidation pass).
- *
- * Exported so SDK consumers building custom profiles can extend the list
- * for host-defined context-loading tools.
- */
-declare const DEFAULT_BUDGET_EXCLUDE_TOOLS: readonly string[];
-/**
- * Build agent — the default profile. Full read/write/shell access plus
- * subagent spawning. Mirrors the legacy `basic` preset so existing TUI
- * behavior is preserved when `agents` is omitted.
- *
- * The system prompt is the cwd-less variant of {@link buildBuildSystem};
- * the TUI overrides it per-session with an env-anchored composition so
- * the prompt carries the current project root + date. SDK consumers
- * calling `createAgent({ ...BUILD_AGENT.preset })` directly get the
- * cwd-less prompt and can wrap their own env section.
- */
-declare const BUILD_AGENT: AgentProfile;
-/**
- * Plan agent — read-only exploration mode. Locked down to file reading and
- * codebase search; no shell, no edits, no spawning. The system prompt
- * frames the conversation as planning rather than execution so the model
- * outputs proposals instead of attempting mutations.
- */
-declare const PLAN_AGENT: AgentProfile;
-/**
- * Default registry shipped with `zidane/tui`. Insertion order = picker order.
- * Hosts that want only one profile can pass `{ agents: { build: BUILD_AGENT } }`,
- * or a fully custom registry of their own profiles.
- */
-declare const BUILTIN_AGENTS: AgentRegistry;
-/** Id of the profile activated on first launch when nothing is persisted. */
-declare const DEFAULT_AGENT_ID = "build";
-/**
- * Resolve an agent id against a registry with sensible fallbacks: the
- * requested id wins when present, then `defaultId`, then the first key.
- * Returns `null` when the registry is empty (host misconfiguration —
- * the caller should surface this rather than silently failing).
- */
-declare function resolveAgentId(registry: AgentRegistry, requestedId: string | undefined, defaultId: string | undefined): string | null;
-/**
- * Wrap a legacy single `Preset` into a single-profile registry. Used by
- * `resolveConfig` when the host passed `preset` without `agents`, so older
- * call sites keep working — they get a one-entry registry whose picker is
- * a no-op (only one option).
- */
-declare function singleAgentRegistry(preset: Preset): AgentRegistry;
-//#endregion
+import { Af as SessionStore, Cu as ProviderDescriptor, Ld as SessionContentBlock, Of as SessionData, Vd as SessionTurn, Wd as ThinkingLevel, Yd as ToolResultContent, _u as ProviderKey, au as EditOutcome, du as SessionMeta, fs as SubagentOverride, fu as Settings, gu as ProviderAuth, ka as ExtensionConfigCategory, kf as SessionRun, lu as Picked, ps as SubagentRegistry, pu as StreamEvent, ql as AgentRegistry, t as Preset, xu as ModelInfo, yd as McpServerConfig, yo as ExtensionRegistry, za as StoredExtensionConfigItem } from "./index-B8UtiZy7.js";
 //#region src/chat/hints.d.ts
 /**
  * Single hint entry — `<key> <label>`, optionally followed by an inline
@@ -196,52 +70,6 @@ declare const EMPTY_HINTS: readonly Hint[];
  */
 declare function clipHintsToWidth(hints: readonly Hint[], budget: number): readonly Hint[];
 //#endregion
-//#region src/chat/completion.d.ts
-/** State surface returned by `useCompletion()`. */
-interface CompletionState<TItem = unknown> {
-  /** Active trigger, or null when the cursor doesn't sit in a completable span. */
-  active: ActiveTrigger<TItem> | null;
-  /** Items for the active query. Empty when no trigger is active. */
-  items: readonly CompletionItem<TItem>[];
-  /** True while the provider's `suggest` promise is pending. */
-  loading: boolean;
-  /** Index of the highlighted item inside `items`. */
-  selectedIndex: number;
-  /** Move the highlight. Wraps at the ends. No-op when `items` is empty. */
-  selectNext: () => void;
-  selectPrev: () => void;
-  /**
-   * Commit the highlighted item. Returns the new text + cursor pair, or
-   * `null` when there's nothing to commit (no active trigger, empty list).
-   */
-  commit: () => {
-    text: string;
-    cursor: number;
-  } | null;
-  /** Force-close the popover until the user types again. */
-  dismiss: () => void;
-  /** All references in the current buffer, regardless of provider. */
-  references: readonly CompletionReference<TItem>[];
-}
-/**
- * Drive a prompt-completion popover from React state.
- *
- * Inputs are pull-style — the caller owns `text` + `cursor` (typically
- * mirroring an `OpenTUI TextareaRenderable` or a `<textarea>` element) and
- * passes them in each render. Providers are matched by their `trigger`
- * character; the engine picks at most one active provider per cursor
- * position.
- *
- * Asynchronous suggest calls are aborted when the query changes or the
- * popover closes, so providers that hit a backend don't leak.
- */
-declare function useCompletion<TItem = unknown>(input: {
-  text: string;
-  cursor: number;
-}, providers: readonly CompletionProvider<TItem>[], options?: {
-  maxQueryLength?: number;
-}): CompletionState<TItem>;
-//#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];
@@ -317,9 +145,22 @@ interface StartLocalOptions {
  * 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' | 'openContextPanel' | 'openKeybindings' | 'cycleAgent' | 'enterSelectTurnMode' | 'cancelToolCall' | 'changeCwd' | 'attachClipboardImage' | 'enterQueueSelection' | 'pushQueuedMessage' | 'dropQueuedMessage' | 'turnFork' | 'turnDelete' | 'turnCopy' | 'turnEdit' | 'sessionDelete' | 'sessionCopyId' | 'sessionGenerateTitle' | 'sessionExportMarkdown' | 'sessionExportJson' | 'sessionCompact';
+type KeyAction = 'openSettings' | 'openSessionDetails' | 'newSession' | 'openModelPicker' | 'openEffortPicker' | 'openTodos' | 'openContextPanel' | 'openKeybindings' | 'cycleAgent' | 'enterSelectTurnMode' | 'cancelToolCall' | '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
@@ -421,21 +262,49 @@ declare function keybindingsPath(userDir: string): string;
  * `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: KeyBindingDef['group'];
-  rows: ReadonlyArray<{
-    def: KeyBindingDef;
-    spec: string;
-  }>;
+  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): readonly KeyBindingSection[];
+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
@@ -464,6 +333,36 @@ declare function readKeybindings(userDir: string): KeyBindings;
  * 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
@@ -540,7 +439,7 @@ declare function titleFromTurns(turns: SessionTurn[]): string | null;
  *   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. The literal `'untitled'`.
+ *   3. {@link DEFAULT_SESSION_TITLE} (`'New session'`).
  *
  * Total / pure / defensive on non-string metadata values.
  */
@@ -886,6 +785,51 @@ interface ChatOptions {
    * 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[];
+  /**
+   * 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
@@ -1008,6 +952,16 @@ interface ResolvedConfig {
    * 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
@@ -1015,6 +969,94 @@ interface ResolvedConfig {
    * 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[];
+  /**
+   * 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;
 }
@@ -1224,7 +1266,7 @@ declare function buildMcpServers(opts: {
  * suite; the rendering layer is tested where it lives.
  */
 /** Settings keys whose value type is `readonly string[] | undefined`. */
-type EnabledAllowlistKey = 'enabledSkills' | 'enabledMcps';
+type EnabledAllowlistKey = 'enabledSkills' | 'enabledMcps' | 'enabledExtensions';
 interface EnabledToggleSet {
   /** Live set of enabled names — `Set` for O(1) `has`. */
   enabledSet: ReadonlySet<string>;
@@ -1242,264 +1284,15 @@ declare function useEnabledToggleSet<T>(opts: {
   catalog: readonly T[];
   keyOf: (entry: T) => string;
   settingKey: EnabledAllowlistKey;
-}): EnabledToggleSet;
-//#endregion
-//#region src/chat/interactions.d.ts
-declare const PRESENT_PLAN_TOOL = "present_plan";
-declare const ASK_USER_TOOL = "ask_user";
-/** True when `name` is one of the interaction tool canonical names. */
-declare function isInteractionTool(name: string): boolean;
-interface PlanStep {
-  id: string;
-  title: string;
-  description?: string;
-}
-interface PlanPayload {
-  /** Short headline summary — used as the modal title. */
-  title: string;
-  /** Full plan body. Markdown. */
-  plan: string;
-  /** Optional structured step list — surfaced as a checklist preview. */
-  steps?: readonly PlanStep[];
-}
-interface QuestionChoice {
-  id: string;
-  label: string;
-  description?: string;
-}
-/**
- * One question in an `ask_user` batch. Discriminated by `type`:
- *
- *   - `text`     — single-line free-text answer (rendered via `<input>`).
- *   - `textarea` — multi-line free-text answer (rendered via `<textarea>`).
- *   - `select`   — single pick from a fixed set of `choices`.
- *   - `confirm`  — yes/no boolean (rendered as a 2-option select).
- *
- * The model batches related clarifications into one tool call instead of
- * pinging the user N times with N round-trips.
- */
-type QuestionType = 'text' | 'textarea' | 'select' | 'confirm';
-interface BaseQuestion {
-  /** Stable id — keys the response back to the model. */
-  id: string;
-  /** Question text shown above the input (Markdown allowed). */
-  prompt: string;
-  /** Optional helper text under the prompt. */
-  description?: string;
-  /**
-   * Whether the answer is required (non-empty). Default: `true` for
-   * `select` / `confirm` (no sensible empty), `false` for free-text
-   * (skipping = empty string). Free-text questions still accept an
-   * answer; the flag only gates submission.
-   */
-  required?: boolean;
-}
-interface TextQuestion extends BaseQuestion {
-  type: 'text' | 'textarea';
-  /** Placeholder shown when the input is empty. */
-  placeholder?: string;
-  /** Pre-fill the input with this value (still editable). */
-  default?: string;
-}
-interface SelectQuestion extends BaseQuestion {
-  type: 'select';
-  choices: readonly QuestionChoice[];
-}
-interface ConfirmQuestion extends BaseQuestion {
-  type: 'confirm';
-  /** Label for the affirmative option. Default: `'yes'`. */
-  affirmLabel?: string;
-  /** Label for the negative option. Default: `'no'`. */
-  denyLabel?: string;
-}
-type Question = TextQuestion | SelectQuestion | ConfirmQuestion;
-interface QuestionPayload {
-  /** Optional intro / context shown above every question (Markdown). */
-  intro?: string;
-  /** One or more questions for the user to answer in one form. */
-  questions: readonly Question[];
-}
-/** Per-question answer value — `string` for text/textarea/select, `boolean` for confirm. */
-type AnswerValue = string | boolean;
-interface BaseRequest {
-  /** Stable id — the `tool_call.id` from the model. */
-  id: string;
-  /** Tool canonical name. */
-  tool: string;
-  /** Run that emitted the call, when known. */
-  runId?: string;
-  /** Turn id the call lives in. */
-  turnId?: string;
-  /** Unix ms when the request was raised. */
-  createdAt: number;
-}
-interface PlanRequest extends BaseRequest {
-  kind: 'plan';
-  tool: typeof PRESENT_PLAN_TOOL;
-  payload: PlanPayload;
-}
-interface QuestionRequest extends BaseRequest {
-  kind: 'question';
-  tool: typeof ASK_USER_TOOL;
-  payload: QuestionPayload;
-}
-type InteractionRequest = PlanRequest | QuestionRequest;
-type PlanDecision = 'approve' | 'reject' | 'revise';
-interface PlanResponse {
-  kind: 'plan';
-  decision: PlanDecision;
-  /** Optional free-text feedback — shown to the model verbatim. */
-  comment?: string;
-}
-interface QuestionResponse {
-  kind: 'question';
   /**
-   * Map of `Question.id → AnswerValue` for every question the user
-   * answered. Missing keys = question skipped (only possible when
-   * `required: false`).
+   * 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.
    */
-  answers: Readonly<Record<string, AnswerValue>>;
-}
-type InteractionResponse = PlanResponse | QuestionResponse;
-/**
- * Format an {@link InteractionResponse} as the tool_result content. JSON
- * keeps the envelope parseable and explicit. Empty fields are stripped so
- * the model doesn't waste tokens reading absent values.
- */
-declare function serializeInteractionResponse(response: InteractionResponse): string;
-/**
- * Build a protocol-valid user `SessionTurn` that closes a batch of
- * resumed pending interactions.
- *
- * - `requests` MUST be the same list returned by
- *   {@link pendingInteractionsFromTurns} for the session, in order.
- * - `responses` MUST contain an entry for every request id; throws
- *   otherwise (caller bug — flush before all answers collected).
- *
- * Pure / total. Tested in isolation so the batching invariant doesn't
- * regress without the resumed-flow integration noticing.
- */
-declare function buildResumedToolResultsTurn(requests: readonly InteractionRequest[], responses: ReadonlyMap<string, InteractionResponse>, options: {
-  /** Turn id minted by the session store. */turnId: string;
-  /**
-   * Run id that emitted the pending tool calls — when known, attaching
-   * it ties the resumed turn back to the originating `SessionRun` row
-   * so consumers grouping turns by run keep clean ancestry across the
-   * close/reopen boundary.
-   */
-  runId?: string; /** `createdAt` timestamp. Defaults to `Date.now()`. */
-  createdAt?: number;
-}): SessionTurn;
-/**
- * Scan `turns` and return every interaction tool call without a matching
- * `tool_result`, ordered by turn appearance. Works equally for live mid-run
- * inspection and reload-from-disk.
- *
- * Malformed payloads (input that doesn't match the tool's schema) are
- * skipped silently — the call still lives in the persisted history, but
- * the renderer wouldn't know how to display it. The next `agent.run()` on
- * the session will see the orphan and synthesize an error tool_result via
- * the loop's normal recovery path.
- */
-declare function pendingInteractionsFromTurns(turns: readonly SessionTurn[]): InteractionRequest[];
-interface CreateInteractionToolsOptions {
-  /**
-   * Called when the agent invokes one of the interaction tools. Resolves
-   * with the user's response (forwarded to the model as the tool_result);
-   * reject to signal denial / abort (the model receives
-   * `Tool error: <message>` as the result).
-   */
-  requestInteraction: (request: InteractionRequest) => Promise<InteractionResponse>;
-}
-/**
- * Create the `present_plan` and `ask_user` tools as a record, ready to
- * spread into `createAgent({ tools })` or composed into a {@link Preset}.
- */
-declare function createInteractionTools(opts: CreateInteractionToolsOptions): Record<string, ToolDef>;
-interface PendingInteractionEntry {
-  request: InteractionRequest;
-  /** The user picked something — forward to the live tool Promise or the resumed tool_result writer. */
-  resolve: (response: InteractionResponse) => void;
-  /**
-   * The user / system cancelled — distinct from `resolve` so renderers can
-   * differentiate "user picked something" from "user gave up / aborted".
-   * Live entries reject the tool's Promise; resumed entries decide what
-   * to persist as the cancelled tool_result.
-   */
-  cancel: (reason?: string) => void;
-}
-interface InteractionsActions {
-  /** Add a request to the FIFO queue. */
-  enqueue: (entry: PendingInteractionEntry) => void;
-  /** Resolve the head request with `response`. */
-  resolveHead: (response: InteractionResponse) => void;
-  /**
-   * Cancel the head request. Reserved for future per-call cancel
-   * affordances (a "skip this" button, a GUI's close-modal-X) — the
-   * built-in TUI currently cancels via the run-level `cancelAll` path
-   * only. Kept on the public API so consumer renderers can wire it
-   * without a follow-up surface change.
-   */
-  cancelHead: (reason?: string) => void;
-  /** Cancel every queued request. Used by abort / session teardown. */
-  cancelAll: (reason?: string) => void;
-}
-declare function InteractionsProvider({
-  children
-}: {
-  children: ReactNode;
-}): import("react/jsx-runtime").JSX.Element;
-/** Read the live queue (re-renders on every push/pop). */
-declare function useInteractionsQueue(): readonly PendingInteractionEntry[];
-/** Read the stable actions object. */
-declare function useInteractionsActions(): InteractionsActions;
-/**
- * Build the `requestInteraction` callback for `createInteractionTools` from
- * the React-side {@link InteractionsActions}. Each call adds a fresh entry
- * to the queue whose `resolve` / `cancel` route back to one Promise that
- * the tool's `execute` awaits.
- */
-declare function makeRequestInteraction(actions: InteractionsActions): CreateInteractionToolsOptions['requestInteraction'];
-//#endregion
-//#region src/chat/markdown-segments.d.ts
-/**
- * One block returned by {@link splitMarkdownCodeBlocks}. Prose segments
- * carry their original markdown (including blank lines that bracketed
- * the fence) so the surrounding paragraph spacing stays faithful to the
- * original input. Code segments carry the raw body — fence markers and
- * info-string stripped — so a "copy code" action lands what the user
- * actually sees, byte-for-byte.
- */
-interface MarkdownSegment {
-  kind: 'prose' | 'code';
-  content: string;
-  /** Info-string (e.g. `ts`, `python`). Empty when the fence had none. */
-  lang?: string;
-  /**
-   * `true` on a code segment whose closing fence hasn't arrived yet —
-   * i.e. the trailing block during streaming. Consumers can render this
-   * in "streaming" mode (no copy affordance, partial-highlight pipeline)
-   * until the closer lands and it flips to a regular closed segment.
-   */
-  open?: boolean;
-}
-/**
- * Split markdown text into alternating prose / fenced-code segments.
- *
- * Recognizes both ` ``` ` and `~~~` fences, with arbitrary length ≥ 3,
- * matching CommonMark's "fence indicator must be at least as long to
- * close" rule. Info-strings (the bit after the opening fence) are kept
- * as the `lang` hint; any trailing whitespace is trimmed. Closing
- * fences are detected on a line of their own (whitespace tolerated).
- *
- * Unclosed fences fall back to emitting the would-be-code body as a
- * trailing prose segment so no content is dropped — finalized markdown
- * isn't expected to ship one, but the fallback keeps the renderer
- * truthful when the model produces malformed output.
- *
- * Exported for unit tests.
- */
-declare function splitMarkdownCodeBlocks(text: string): MarkdownSegment[];
+  gcKeys?: readonly string[];
+}): EnabledToggleSet;
 //#endregion
 //#region src/chat/session-export.d.ts
 /** File format supported by the exporter. */
@@ -1575,206 +1368,6 @@ declare function writeSessionExport(opts: {
   format: SessionExportFormat;
 } & ResolveOptions): Promise<SessionExportTarget>;
 //#endregion
-//#region src/chat/theme.d.ts
-/**
- * Renderer-agnostic theme system.
- *
- * A `Theme` bundles every variable that can change visually between
- * "themes" — colors, select-row styling, code/markdown syntax highlight
- * tokens, panel backgrounds. Plain JSON: no OpenTUI dependency, no React,
- * no functions. The TUI consumes the theme by reading from `useTheme()`
- * and converting hex strings into OpenTUI's `RGBA`/`SyntaxStyle`; a future
- * GUI consumes the same theme by converting into CSS variables or Tailwind
- * tokens.
- *
- * Components should always read theme values through `useTheme()` /
- * `useColors()` so a runtime theme switch (Settings → Theme) re-paints
- * the whole tree. Importing a raw theme object directly bypasses the
- * context and pins the component to a single look.
- *
- * Built-in flavors (Catppuccin, Vaporwave) live in `./themes/`. This file
- * just defines the shape + the default theme + the registry.
- */
-/** Role-named color palette. Reused throughout the UI for text, borders, accents. */
-interface ThemeColors {
-  /** Primary accent — selected text, brand emphasis (e.g. `▶` markers). */
-  brand: string;
-  /** Success / progress accent — used sparingly. */
-  accent: string;
-  /** Model badge accent (provider/model name in the footer, links). */
-  model: string;
-  /** Warnings — busy spinner, approval picker border, esc hints. */
-  warn: string;
-  /** Errors — `✗` prefix on error events, validation messages. */
-  error: string;
-  /** Secondary text — captions, helper text, dim transcript lines. */
-  dim: string;
-  /** Tertiary text — separators, descriptions, the `┃` tool-result bar. */
-  mute: string;
-  /** Resting border color. */
-  border: string;
-  /** Border color on focused / active elements. */
-  borderActive: string;
-  /**
-   * Optional gradient endpoints for the in-chat working throbber
-   * (`<CrushThrobber>`). Falls back to `[brand, accent]` when unset.
-   * Themes can pin a richer pair here — e.g. Crush's `Charple` →
-   * `Dolly` purple-to-pink — without having to repurpose `accent`.
-   */
-  throbber?: {
-    from: string;
-    to: string;
-  };
-  /**
-   * Optional tone for the footer's session-cost indicator. Falls back
-   * to `warn` when unset. Carved out as its own role because some
-   * themes (e.g. Crush) intentionally bind `warn` to a non-yellow tone
-   * and a separate "money" color reads more naturally on the footer.
-   */
-  money?: string;
-}
-/** Select-component styling. Plain prop shape; both OpenTUI's `<select>` and any GUI equivalent can consume this. */
-interface ThemeSelect {
-  backgroundColor: string;
-  focusedBackgroundColor: string;
-  selectedBackgroundColor: string;
-  selectedTextColor: string;
-  textColor: string;
-  descriptionColor: string;
-  selectedDescriptionColor: string;
-}
-/** Background + foreground pair for a completion-reference chip pill. */
-interface ChipColor {
-  /** Background paint — the pill itself. High-saturation by convention. */
-  bg: string;
-  /** Foreground paint — the chip text. Pre-paired with {@link ChipColor.bg} for legibility. */
-  fg: string;
-}
-/**
- * Chip colors keyed by completion-provider id (`'skills'`, `'files'`, …).
- * `default` is the required fallback used by any provider id without an
- * explicit entry — keeps host-registered providers themable out of the
- * box. Use {@link resolveChipColor} to perform the kind-specific → default
- * lookup rather than indexing the map directly.
- */
-/**
- * Map of provider id → chip color pair. `default` is required so callers
- * always have a fallback; every other key is optional so direct indexing
- * (`chips['unknown']`) surfaces as `ChipColor | undefined` and nudges
- * consumers toward {@link resolveChipColor}, which encodes the fallback.
- */
-type ChipColorMap = {
-  default: ChipColor;
-} & Partial<Record<string, ChipColor>>;
-/**
- * Look up the chip color pair for a provider id, falling back to
- * `chips.default` when the theme has no kind-specific entry. Mirrors
- * `resolveChipStyleId` so both rendering surfaces (submitted echo +
- * live textarea) share one canonical lookup rule.
- */
-declare function resolveChipColor(chips: ChipColorMap, providerId: string): ChipColor;
-/** Panel / surface backgrounds. */
-interface ThemeSurfaces {
-  /**
-   * Solid paint for the app's root surface. Covers the whole TUI viewport
-   * so transparent / translucent terminals don't show desktop windows
-   * underneath. Conventionally one tier deeper than {@link modal} so
-   * modal panels still read as elevated above the body.
-   */
-  background: string;
-  /** Background of an overlaid modal panel (settings, model picker, …). */
-  modal: string;
-  /**
-   * Completion-chip color pairs keyed by provider id. Built-in themes
-   * ship distinct `skills` + `files` tones so the two reference kinds
-   * read differently in both the submitted echo and the live textarea.
-   */
-  chips: ChipColorMap;
-  /**
-   * Background paint for the selected turn's events in select-turn mode.
-   * Subtle, low-saturation lift from the terminal default so the whole
-   * span of the selected turn reads as one continuous highlighted block
-   * without overpowering the foreground text. Inverse-tinted on the
-   * light flavor (Latte) so the same visual role works there.
-   */
-  selection: string;
-  /**
-   * Edit-diff color block. Drives the native `<diff>` renderable used
-   * by {@link Settings.showEditDiffs}. Pre-mixed against each theme's
-   * primary surface so terminals without true alpha-blend get a
-   * legible "subtle red / subtle green" effect rather than a flat
-   * saturated band.
-   *
-   *   - `*Bg`         row-level paint (gutter + content)
-   *   - `*ContentBg`  content-only paint (overrides `*Bg` on the text
-   *                   column). Set when a deeper hue should punch
-   *                   through behind the syntax-highlighted code; omit
-   *                   to let `*Bg` carry the full row.
-   *   - `*Fg`         color for the `+` / `-` glyph in the sign gutter.
-   */
-  diff: DiffSurfaces;
-}
-/** Per-row paints used by the native `<diff>` renderable. */
-interface DiffSurfaces {
-  addBg: string;
-  removeBg: string;
-  contextBg?: string;
-  addContentBg?: string;
-  removeContentBg?: string;
-  addFg: string;
-  removeFg: string;
-}
-/**
- * One entry in a `SyntaxStyles` map — what OpenTUI's `SyntaxStyle.fromStyles`
- * accepts, minus the `RGBA` conversion. Renderer-agnostic JSON.
- */
-interface SyntaxTokenStyle {
-  fg?: string;
-  bg?: string;
-  bold?: boolean;
-  italic?: boolean;
-  underline?: boolean;
-  dim?: boolean;
-}
-/**
- * Map of Tree-sitter / markdown capture group → token style.
- *
- * Two flavours of keys live in the same table:
- *   - `markup.*` — the markdown structure captures (heading, bold, italic,
- *     list, quote, raw inline + block, link). OpenTUI's markdown parser
- *     emits these for the markdown text itself.
- *   - bare token names (`keyword`, `string`, `function`, …) — emitted by
- *     the embedded language Tree-sitter grammars when a code fence
- *     declares a language. OpenTUI passes the same `SyntaxStyle` down to
- *     the fenced-code renderable, so this map drives both surfaces.
- */
-type SyntaxStyles = Record<string, SyntaxTokenStyle>;
-/** Full theme bundle. */
-interface Theme {
-  /** Stable identifier, used as the key in `BUILTIN_THEMES` and `Settings.theme`. */
-  id: string;
-  /** Human-readable label shown in the settings picker. */
-  label: string;
-  colors: ThemeColors;
-  select: ThemeSelect;
-  surfaces: ThemeSurfaces;
-  syntax: SyntaxStyles;
-}
-declare const DEFAULT_THEME: Theme;
-/**
- * Built-in theme registry, keyed by `theme.id`. The TUI looks up the active
- * theme here using `Settings.theme`; unknown ids fall back to
- * `DEFAULT_THEME`. Hosts can extend this by passing additional themes to a
- * future `runTui({ themes })` option (not yet wired).
- *
- * Insertion order is the picker cycle order — keep `default` first so a
- * fresh install (no `theme` in `state.json`) sees the familiar yellow theme
- * before the others.
- */
-declare const BUILTIN_THEMES: Readonly<Record<string, Theme>>;
-/** Resolve a theme id to its full `Theme`, falling back to default on unknown ids. */
-declare function resolveTheme(id: string | undefined): Theme;
-//#endregion
 //#region src/chat/transcript-anchors.d.ts
 /**
  * One entry in the partitioned transcript-row list. Single events
@@ -1818,5 +1411,5 @@ declare function computeTurnAnchors(items: readonly TranscriptItem[]): {
   lastTurnId: string | undefined;
 };
 //#endregion
-export { useInteractionsQueue as $, mergeKeybindings as $t, InteractionsProvider as A, loadState as At, QuestionPayload as B, KEYBINDING_DEFS as Bt, ASK_USER_TOOL as C, TuiState as Ct, InteractionRequest as D, eventsFromTurns as Dt, CreateInteractionToolsOptions as E, deriveSessionTitle as Et, PlanRequest as F, titleFromTurns as Ft, TextQuestion as G, KeyBindingSection as Gt, QuestionResponse as H, KEYBINDING_KEY_COL_WIDTH as Ht, PlanResponse as I, toolCallPreview as It, isInteractionTool as J, ensureKeybindingsFile as Jt, buildResumedToolResultsTurn as K, KeyBindings as Kt, PlanStep as L, toolResultText as Lt, PendingInteractionEntry as M, saveState as Mt, PlanDecision as N, stripSpawnTokensLine as Nt, InteractionResponse as O, lastContextSizeFromTurns as Ot, PlanPayload as P, sumRunCosts as Pt, useInteractionsActions as Q, matchesBinding as Qt, Question as R, updateToolEventOutcomes as Rt, splitMarkdownCodeBlocks as S, StateStoreApi as St, ConfirmQuestion as T, createStateStore as Tt, QuestionType as U, KeyAction as Ut, QuestionRequest as V, KEYBINDING_DEF_BY_ACTION as Vt, SelectQuestion as W, KeyBindingDef as Wt, pendingInteractionsFromTurns as X, groupBindings as Xt, makeRequestInteraction as Y, formatBindingForDisplay as Yt, serializeInteractionResponse as Z, keybindingsPath as Zt, SessionExportTarget as _, DEFAULT_PERSIST_EXCLUDE_TOOLS as _n, ResolveStorageDirsOptions as _t, ChipColorMap as a, EMPTY_HINTS as an, DiscoveryResult as at, writeSessionExport as b, resolveAgentId as bn, StorageSlot as bt, SyntaxTokenStyle as c, hintsLength as cn, discoverProjectMcps as ct, ThemeSelect as d, AgentProfile as dn, ChatOptions as dt, parseBindingSpec as en, EnabledAllowlistKey as et, ThemeSurfaces as f, AgentRegistry as fn, ProviderRegistry as ft, SessionExportFormat as g, DEFAULT_BUDGET_EXCLUDE_TOOLS as gn, resolveStoragePaths as gt, SessionExportAnchor as h, DEFAULT_AGENT_ID as hn, resolveConfig as ht, ChipColor as i, useCompletion as in, DiscoveryError as it, PRESENT_PLAN_TOOL as j, marginTopFor as jt, InteractionsActions as k, listSessionMeta as kt, Theme as l, truncateTrailing as ln, parseMcpsFile as lt, resolveTheme as m, BUILTIN_AGENTS as mn, ResolvedPaths as mt, computeTurnAnchors as n, stripJsonComments as nn, useEnabledToggleSet as nt, DEFAULT_THEME as o, Hint as on, buildMcpServers as ot, resolveChipColor as p, BUILD_AGENT as pn, ResolvedConfig as pt, createInteractionTools as q, ParsedBinding as qt, BUILTIN_THEMES as r, CompletionState as rn, DiscoveredMcp as rt, SyntaxStyles as s, clipHintsToWidth as sn, defaultMcpsConfigPaths as st, TranscriptItem as t, readKeybindings as tn, EnabledToggleSet as tt, ThemeColors as u, AgentAccent as un, AutoUpdateConfig as ut, renderSession as v, PLAN_AGENT as vn, StorageDirs as vt, AnswerValue as w, compactSummaryEvent as wt, MarkdownSegment as x, singleAgentRegistry as xn, resolveStorageDirs as xt, resolveSessionExportTarget as y, accentColor as yn, StorageMode as yt, QuestionChoice as z, DEFAULT_KEYBINDINGS as zt };
-//# sourceMappingURL=transcript-anchors-BHIgMlPq.d.ts.map
+export { KeyBindingDef as $, resolveStorageDirs as A, marginTopFor as B, ResolvedPaths as C, StorageDirs as D, ResolveStorageDirsOptions as E, deriveSessionTitle as F, toolCallPreview as G, stripSpawnTokensLine as H, eventsFromTurns as I, DEFAULT_KEYBINDINGS as J, toolResultText as K, lastContextSizeFromTurns as L, TuiState as M, compactSummaryEvent as N, StorageMode as O, createStateStore as P, KeyAction as Q, listSessionMeta as R, ResolvedConfig as S, resolveStoragePaths as T, sumRunCosts as U, saveState as V, titleFromTurns as W, KEYBINDING_DEF_BY_ACTION as X, KEYBINDING_DEFS as Y, KEYBINDING_KEY_COL_WIDTH as Z, discoverProjectMcps as _, clipHintsToWidth as _t, SessionExportTarget as a, formatBindingForDisplay as at, ChatOptions as b, writeSessionExport as c, matchesBinding as ct, useEnabledToggleSet as d, readKeybindings as dt, KeyBindingSection as et, DiscoveredMcp as f, readKeybindingsRaw as ft, defaultMcpsConfigPaths as g, Hint as gt, buildMcpServers as h, EMPTY_HINTS as ht, SessionExportFormat as i, ensureKeybindingsFile as it, StateStoreApi as j, StorageSlot as k, EnabledAllowlistKey as l, mergeKeybindings as lt, DiscoveryResult as m, stripJsonComments as mt, computeTurnAnchors as n, ParsedBinding as nt, renderSession as o, groupBindings as ot, DiscoveryError as p, resolveExtensionKeybindings as pt, updateToolEventOutcomes as q, SessionExportAnchor as r, ResolvedExtensionKeybinding as rt, resolveSessionExportTarget as s, keybindingsPath as st, TranscriptItem as t, KeyBindings as tt, EnabledToggleSet as u, parseBindingSpec as ut, parseMcpsFile as v, hintsLength as vt, resolveConfig as w, ProviderRegistry as x, AutoUpdateConfig as y, truncateTrailing as yt, loadState as z };
+//# sourceMappingURL=transcript-anchors-Cb-bDbNH.d.ts.map