zidane 4.1.8 → 5.0.0

package/dist/theme-pJv47erq.d.ts

@@ -0,0 +1,1202 @@
+import { Dt as SessionTurn, Nt as ToolResultContent, O as SessionRun, U as Provider, ht as McpServerConfig, k as SessionStore } from "./agent-JhicgLOV.js";
+import { t as Preset } from "./index-2yLUyTbc.js";
+import { OAuthProviderInterface } from "@mariozechner/pi-ai/oauth";
+import { ReactNode } from "react";
+import * as _$react_jsx_runtime0 from "react/jsx-runtime";
+
+//#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';
+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>>;
+/**
+ * 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.
+ */
+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
+//#region src/chat/providers.d.ts
+/**
+ * Structural model metadata — compatible with pi-ai's `Model` interface but
+ * not coupled to it, so hosts can pass either pi-ai-shaped objects or a
+ * custom registry of their own.
+ *
+ * Deliberately a structural duplicate of pi-ai's `Model` rather than a
+ * re-export: keeps the public API stable when pi-ai bumps shape, and lets
+ * hosts implement their own registry without depending on pi-ai's types.
+ *
+ * Lives here (rather than `./config`) because `ProviderDescriptor.models`
+ * needs it — pushing it to `config.tsx` created an import cycle.
+ */
+interface ModelInfo {
+  id: string;
+  name?: string;
+  contextWindow: number;
+  maxTokens?: number;
+  reasoning?: boolean;
+  input?: readonly ('text' | 'image')[];
+  cost?: {
+    input: number;
+    output: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+  };
+  provider?: string;
+}
+interface ProviderDescriptor {
+  /**
+   * Unique identifier. Used as the registry key, persisted in `state.json`
+   * as the resumed provider, and (by default) as the credential-file key.
+   */
+  key: string;
+  /** Display name shown in the TUI's provider picker and labels. */
+  label: string;
+  /**
+   * Factory that builds a fresh `Provider` instance. Called on every session
+   * activation. Some factories (e.g. zidane's built-in `anthropic`) eagerly
+   * resolve credentials at construction time and throw when none are
+   * configured — set {@link defaultModel} on the descriptor to avoid the TUI
+   * calling the factory before the user has picked + authed a provider.
+   */
+  factory: () => Provider;
+  /**
+   * Default model id to seed the picker with. When omitted, the TUI falls
+   * back to `descriptor.factory().meta.defaultModel`, which constructs the
+   * provider — fine for lazy-credential factories, but breaks for factories
+   * that throw on missing credentials before the wizard runs. Setting this
+   * eagerly lets the TUI render the auth wizard without ever instantiating
+   * the provider.
+   */
+  defaultModel?: string;
+  /**
+   * Env var checked when detecting whether the user has an API key
+   * configured for this provider. Optional — set to `undefined` when the
+   * provider only supports OAuth (or only credentials via a custom path).
+   */
+  envKey?: string;
+  /**
+   * Key under which credentials live in `credentials.json`. Defaults to
+   * `key`. The only built-in that overrides this is OpenAI Codex
+   * (`openai` → `openai-codex`) to stay compatible with the harness
+   * provider's existing lookup.
+   */
+  credentialFileKey?: string;
+  /** Placeholder shown in the wizard's API-key input. */
+  apiKeyPlaceholder?: string;
+  /**
+   * pi-ai (or compat) OAuth provider. When present, the wizard offers an
+   * OAuth option in addition to API key.
+   */
+  oauthProvider?: OAuthProviderInterface;
+  /**
+   * Optional copy appended to the wizard's "OAuth" method description.
+   * Use to communicate why a user might pick OAuth (e.g. subscription tier,
+   * org-wide SSO). Shown after `browser-based sign-in`. Skip the leading
+   * space — the wizard adds it. Example: `'Claude Pro/Max subscription'`.
+   */
+  oauthHint?: string;
+  /**
+   * pi-ai provider id used to look up models in pi-ai's built-in registry.
+   * Defaults to `key`. Only Codex differs (`openai` → `openai-codex`).
+   */
+  piProviderId?: string;
+  /**
+   * Override the model list returned for this provider's picker. When set,
+   * skips pi-ai's registry entirely. Useful for hosts maintaining their
+   * own model catalogue or for custom providers pi-ai doesn't know about.
+   */
+  models?: readonly ModelInfo[];
+}
+/** Convenience accessor — returns `credentialFileKey ?? key`. */
+declare function credKeyOf(desc: ProviderDescriptor): string;
+/** Convenience accessor — returns `piProviderId ?? key`. */
+declare function piIdOf(desc: ProviderDescriptor): string;
+declare const anthropicDescriptor: ProviderDescriptor;
+declare const openaiDescriptor: ProviderDescriptor;
+declare const openrouterDescriptor: ProviderDescriptor;
+declare const cerebrasDescriptor: ProviderDescriptor;
+/**
+ * Default provider registry. Passed verbatim when `runTui` is invoked without
+ * an explicit `providers` option. Hosts that want to override per-provider
+ * metadata can spread this and replace specific entries:
+ *
+ * ```ts
+ * runTui({ providers: { ...BUILTIN_PROVIDERS, anthropic: myOwnAnthropicDescriptor } })
+ * ```
+ */
+declare const BUILTIN_PROVIDERS: Readonly<Record<string, ProviderDescriptor>>;
+/**
+ * Resolve the model list for a given provider. Honors `descriptor.models`
+ * when set; otherwise queries pi-ai via `descriptor.piProviderId`. Returns
+ * `[]` for descriptors with no known mapping (custom providers without a
+ * model list) — callers should hide the model picker in that case.
+ */
+declare function modelsForDescriptor(descriptor: ProviderDescriptor): readonly ModelInfo[];
+/**
+ * Look up the model's max context window via the descriptor's model source.
+ * Returns `null` when the model isn't known (custom slugs, providers without
+ * a registry); callers should hide the context indicator in that case.
+ */
+declare function getContextWindow(descriptor: ProviderDescriptor, modelId: string): number | null;
+//#endregion
+//#region src/chat/auth.d.ts
+/**
+ * Provider identifier as known to the TUI. Built-in keys are `anthropic`,
+ * `openai`, `openrouter`, `cerebras`, but hosts can register additional
+ * keys via {@link ProviderDescriptor} — so the type is open.
+ */
+type ProviderKey = string;
+interface AuthMethod {
+  source: 'env' | 'oauth' | 'apikey';
+  /** Human-readable detail (env var name, expiry timestamp, …). */
+  detail: string;
+}
+interface ProviderAuth {
+  key: ProviderKey;
+  label: string;
+  /** True when at least one credential source is present. */
+  available: boolean;
+  methods: AuthMethod[];
+}
+/**
+ * Detect available auth for every registered provider.
+ *
+ * Resolution order per provider (a method appears in `methods` for each
+ * layer that has a credential — the agent itself resolves them in the same
+ * order via its provider factories):
+ *
+ *   1. `kind: 'apikey'` from `credentials.json` (injected into env at TUI launch)
+ *   2. explicit env var (descriptor's `envKey`)
+ *   3. `kind: 'oauth'` from `credentials.json` (or legacy `cwd/.credentials.json`)
+ *
+ * Pure read — never refreshes or rewrites the credentials file.
+ */
+declare function detectAuth(dataDir: string, registry: Readonly<Record<string, ProviderDescriptor>>, env?: Record<string, string | undefined>): ProviderAuth[];
+//#endregion
+//#region src/chat/completion.d.ts
+/**
+ * Prompt autocompletion framework.
+ *
+ * Renderer-agnostic. Providers plug in by registering a `trigger` character
+ * (e.g. `/` for skills, `@` for files) and exposing two operations:
+ *
+ *   1. `suggest(query)` — return ranked items for the live query.
+ *   2. `parseReferences(text)` — find all references to the provider's
+ *      items in arbitrary text. Used to highlight in-prompt mentions and
+ *      drive submit-time side effects (activate the skill, attach the
+ *      file, …).
+ *
+ * The TUI consumes `useCompletion()` to drive a popover above the textarea.
+ * A future GUI consumes the same hook to drive a dropdown. The popup
+ * component itself only reads `label` + `description` on each item, so
+ * provider-specific typing (`TItem`) stays at the registration boundary
+ * and never leaks into the renderer.
+ */
+/**
+ * A discoverable, selectable thing — one row in the autocomplete popover.
+ * `TItem` is provider-specific; consumers can inspect `data` when they
+ * need the originating payload (e.g. the full `SkillConfig` for tooltips).
+ */
+interface CompletionItem<TItem = unknown> {
+  /** Stable identifier within the provider. Used as React key + selection equality. */
+  id: string;
+  /** User-visible primary string ("research"). */
+  label: string;
+  /** Optional one-line secondary string ("In-depth research with citations"). */
+  description?: string;
+  /**
+   * Text that replaces the active span (trigger + query) on commit. Usually
+   * `${trigger}${label}` with a trailing space so the cursor lands ready
+   * for the next token.
+   */
+  insertText: string;
+  /** Original provider-specific payload. */
+  data: TItem;
+}
+/**
+ * A reference to a provider item inside arbitrary prompt text. Producers:
+ * `provider.parseReferences(text)`. Consumers: the TUI for highlighting,
+ * the run flow for "activate every referenced skill before agent.run()".
+ *
+ * Spans are half-open `[start, end)` codepoint offsets into the source
+ * string. Overlapping spans from the same or different providers are
+ * caller-resolved — the helpers below ship a "first wins" merger.
+ */
+interface CompletionReference<TItem = unknown> {
+  providerId: string;
+  start: number;
+  end: number;
+  itemId: string;
+  data: TItem;
+}
+/**
+ * Provider contract. Implementations decide their own ranking, fuzzy-match
+ * rules, async loading behavior, and reference grammar.
+ */
+interface CompletionProvider<TItem = unknown> {
+  /** Stable id used for tagging references + React keys. */
+  id: string;
+  /**
+   * Single character that activates this provider. The engine considers a
+   * trigger "active" when it appears at the start of the buffer or
+   * immediately after whitespace, and is not closed by whitespace before
+   * the cursor (so a trigger plus query is a contiguous token).
+   */
+  trigger: string;
+  /** Human-readable name. Reserved for future multi-provider popover headers. */
+  label: string;
+  /**
+   * Returns items for the active `query` (the text between the trigger and
+   * the cursor, excluding the trigger itself). Synchronous return is the
+   * common case; promises let providers paginate or hit a backend.
+   *
+   * `signal` is aborted when the query changes or the popover closes —
+   * use it to cancel in-flight network calls.
+   */
+  suggest: (query: string, ctx: CompletionContext, signal: AbortSignal) => CompletionItem<TItem>[] | Promise<CompletionItem<TItem>[]>;
+  /**
+   * Find every reference to this provider's items in `text`. Pure: must not
+   * mutate ctx. The TUI calls this on every keystroke for highlighting, so
+   * keep it cheap (linear scan, no I/O).
+   */
+  parseReferences: (text: string, ctx: CompletionContext) => CompletionReference<TItem>[];
+}
+/**
+ * Read-only view of the active prompt buffer + cursor passed to provider
+ * callbacks. Kept minimal so providers stay portable across renderers.
+ */
+interface CompletionContext {
+  /** Full prompt text. */
+  text: string;
+  /** Codepoint offset of the cursor (0-based). */
+  cursor: number;
+}
+/**
+ * Identified active trigger span. Returned by `findActiveTrigger` so
+ * callers can show the popover, query the provider, and on commit replace
+ * the span with the selected item's `insertText`.
+ */
+interface ActiveTrigger<TItem = unknown> {
+  provider: CompletionProvider<TItem>;
+  /** Substring after the trigger, up to the cursor. Empty if cursor sits right after the trigger. */
+  query: string;
+  /** `[start, end)` — span covered by the trigger + query in the source. */
+  span: {
+    start: number;
+    end: number;
+  };
+}
+/**
+ * Resolve the provider trigger active at `cursor`, or `null` when none fits.
+ *
+ * Rules:
+ *   - The trigger character must sit at position 0 of the buffer OR be
+ *     preceded by whitespace. This prevents `http://` from triggering the
+ *     `/`-bound skills provider mid-URL.
+ *   - The cursor must be at or past the trigger position.
+ *   - Nothing between the trigger and the cursor may be whitespace (the
+ *     query is one contiguous token).
+ *   - The query length is bounded — `maxQueryLength` defaults to 64 — so
+ *     a runaway buffer scan can't pin the renderer.
+ */
+declare function findActiveTrigger<TItem>(text: string, cursor: number, providers: readonly CompletionProvider<TItem>[], options?: {
+  maxQueryLength?: number;
+}): ActiveTrigger<TItem> | null;
+/**
+ * Replace `[span.start, span.end)` in `text` with `insertText`. Returns the
+ * mutated text and the new cursor position (end of insertion).
+ */
+declare function applyInsert(text: string, span: {
+  start: number;
+  end: number;
+}, insertText: string): {
+  text: string;
+  cursor: number;
+};
+/**
+ * Merge reference lists from multiple providers into one ordered list with
+ * earlier-start-wins disambiguation when spans overlap. Ties broken by
+ * insertion order. Spans are sorted ascending so renderers can walk them
+ * sequentially with a cursor through the source string.
+ */
+declare function mergeReferences<TItem>(refs: readonly CompletionReference<TItem>[]): CompletionReference<TItem>[];
+/**
+ * Collect every provider's references in one pass. Convenience wrapper —
+ * the TUI textarea component calls this on every keystroke to highlight
+ * in-prompt mentions.
+ */
+declare function collectReferences<TItem>(text: string, providers: readonly CompletionProvider<TItem>[], cursor?: number): CompletionReference<TItem>[];
+/** 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/chat/types.d.ts
+type Screen = 'auth' | 'sessions' | 'chat';
+/** Identifies the agent that produced a streaming event. */
+type Owner = 'parent' | string;
+interface StreamEvent {
+  kind: 'thinking' | 'tool' | 'tool-result' | 'error'
+  /**
+   * Echo of a submitted user prompt — the `❯` chevron block in the
+   * transcript. Distinct from `'info'` (generic informational text)
+   * so consumers can count user messages and rebuild prompt history
+   * without filtering by text-prefix regex.
+   *
+   * `text` is the **raw** prompt without the `❯ ` prefix; renderers
+   * prepend the chevron. `refs` offsets are aligned to this raw text.
+   */
+  | 'user-prompt'
+  /**
+   * Generic informational banner — status notice, transient message.
+   * Reserved for non-user content; user prompts use `'user-prompt'`.
+   */
+  | 'info' | 'separator' | 'markdown' | 'spawn-start' | 'spawn-end';
+  text: string;
+  /**
+   * For `markdown` events: true while the block is still receiving deltas.
+   * Renderers keep their markdown parser in streaming mode while this is
+   * true (OpenTUI's `<markdown streaming>` leaves the trailing block
+   * unstable to absorb tokens as they arrive). Flipped to false on
+   * `turn:after`.
+   */
+  streaming?: boolean;
+  /** Subagent that produced this event. Absent / 'parent' = top-level agent. */
+  childId?: string;
+  /** Nesting depth — 0 = parent, ≥ 1 = subagent (matches zidane's spawn depth). */
+  depth?: number;
+  /**
+   * Canonical tool name for `tool` / `tool-result` events. Lets the renderer
+   * filter by tool — e.g. hide the parent's `spawn` tool-result when
+   * `hideSubagentOutput` is on, since the spawn-end marker already shows the
+   * same stats. Absent for non-tool events.
+   */
+  tool?: string;
+  /**
+   * Highlighted spans within `text`, in source order. Used by the renderer
+   * to colorize completion references in submitted prompts (`user-prompt`
+   * events). Provider-agnostic — the renderer only reads `start`, `end`,
+   * `providerId`. Spans are half-open `[start, end)`; overlapping spans
+   * are caller-resolved before reaching here. Field name matches
+   * `CompletionReference.providerId` and `PromptSegment.providerId` so
+   * the same identifier flows end-to-end.
+   */
+  refs?: readonly {
+    start: number;
+    end: number;
+    providerId: string;
+  }[];
+  /**
+   * `SessionTurn.id` the event was emitted by — set both on historical
+   * events synthesized in `eventsFromTurns` and on live events tagged by
+   * the agent hooks (via `StreamHookContext.turnId` / `ToolHookContext.turnId`).
+   * Drives the TUI's "select turn" mode: each turn is addressable as a
+   * highlightable group of events.
+   *
+   * Absent on synthetic events that don't map to a turn (`spawn-start`,
+   * `spawn-end`, `separator`, etc.) and on events emitted before the
+   * first `turn:before` fires on a freshly-mounted session.
+   */
+  turnId?: string;
+}
+interface Picked {
+  provider: ProviderAuth;
+  model: string;
+}
+interface SessionMeta {
+  id: string;
+  title: string;
+  /** Total turns (user + assistant + system). */
+  turnCount: number;
+  /** Count of `role: 'user'` turns — the volume of human messages. */
+  userMessageCount: number;
+  /** Top-level runs recorded against the session (one per `agent.run()` call). */
+  runCount: number;
+  /**
+   * Project this session was created under (see {@link SessionData.projectRoot}).
+   * Surfaced on the meta row so the sessions screen can show a
+   * per-project label when `Settings.showAllProjects` is on. Absent
+   * for legacy pre-tagging sessions.
+   */
+  projectRoot?: string;
+  updatedAt: number;
+}
+/** Persisted, user-toggleable transcript filters and modes. */
+interface Settings {
+  showThinking: boolean;
+  showToolCalls: boolean;
+  showToolResults: boolean;
+  /**
+   * Safe mode — when enabled, every tool call requires explicit user
+   * approval unless it's covered by the project safelist (`projects.json`)
+   * or the implicit read-only allow-list. Default: on.
+   */
+  safeMode: boolean;
+  /**
+   * Hide a subagent's internal events (its streamed markdown, thinking,
+   * tool calls, and tool results) from the transcript. The `🌱` start and
+   * `✓` end markers stay visible so the user still sees that a subagent
+   * is working and when it finished. Default: on — subagent runs are
+   * usually noisy and the parent's final response already summarizes them.
+   *
+   * When off, those events are visible and wrapped in a dim bordered box
+   * for clear visual hierarchy.
+   */
+  hideSubagentOutput: boolean;
+  /**
+   * Active theme id — looked up in `BUILTIN_THEMES` to resolve the palette,
+   * select styling, syntax highlight tokens, etc. Default: `'default'`.
+   * Unknown ids fall back to `DEFAULT_THEME` rather than throwing.
+   */
+  theme: string;
+  /**
+   * Show sessions from every project (and pre-tagging legacy ones)
+   * in the sessions list, instead of filtering to the current
+   * project. Off by default — each project shows only its own
+   * conversations. Flip on to inspect / jump across projects without
+   * leaving the TUI. Per-row project labels appear when on.
+   */
+  showAllProjects: boolean;
+  /**
+   * Allowlist of skill names to expose to the agent + slash-command picker.
+   * `undefined` means "every discovered skill" (default). An empty array
+   * fully disables the skills subsystem (no scan, no tool injection).
+   */
+  enabledSkills?: readonly string[];
+  /**
+   * Allowlist of MCP server names (from `.{prefix}/mcps.json`). Same
+   * semantics as `enabledSkills`: `undefined` enables every discovered
+   * server; `[]` disables all.
+   */
+  enabledMcps?: readonly 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-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.
+   */
+  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. The literal `'untitled'`.
+ *
+ * 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.
+ */
+declare function eventsFromTurns(turns: SessionTurn[], runs?: readonly SessionRun[]): StreamEvent[];
+/** Shared formatter for the `↳ name(args)` line shown on tool calls. */
+declare function toolCallPreview(name: string, input: Record<string, unknown>): string;
+/** 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;
+/**
+ * Deduplicated, in-order list of **parent-conversation** turn ids that appear
+ * in a rendered transcript — the navigation index for the TUI's select-turn
+ * mode. Subagent (`childId` set) events are deliberately skipped:
+ *
+ *   - With `hideSubagentOutput: true` (default), child events are filtered
+ *     out of the transcript by `isVisible`, so allowing the user to "select"
+ *     them would highlight nothing and scroll to nowhere.
+ *   - With `hideSubagentOutput: false`, child events are visible but they're
+ *     nested execution detail; the user's mental model of a "message" is
+ *     the conversational exchange, not each spawn turn.
+ *
+ * Synthetic events (separator, spawn-start, spawn-end) have no `turnId` and
+ * are skipped naturally. Pure function over the event stream — no settings
+ * dependency, no host concerns — so it composes the same in TUI / SDK
+ * consumers.
+ */
+declare function selectableTurnIds(events: readonly StreamEvent[]): string[];
+/** 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.
+ *
+ * `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;
+//#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 activated on first launch. Resolved against `agents`;
+   * unknown ids fall through to the registry's first key. Persisted
+   * `state.lastAgent` overrides this on subsequent launches.
+   */
+  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. When `true` (default), launching
+   * inside a git repo 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: `options.projectDb` > `~/.{prefix}/config.json`
+   * `projectDb` > `true`. The env var `ZIDANE_PROJECT_DB=0` flips it
+   * off too, for one-shot CLI invocations.
+   *
+   * When `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;
+}
+/** Resolved on-disk layout produced by {@link resolveConfig}. */
+interface ResolvedPaths {
+  /**
+   * Effective data root — equals `userDir` 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 `userDir` /
+   * `projectDir` / the explicit `db` / `state` paths instead.
+   */
+  dir: string;
+  /**
+   * User-scoped data root. Always `<storageDir>/<prefix>` (default
+   * `~/.zidane/`). Credentials, the project-keyed safelist, and the
+   * user-level `config.json` live here regardless of project mode —
+   * they MUST NOT leak into a checked-in project 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 `userDir`. */
+  db: string;
+  /** Resolved `state.json` path. Same scoping rule as `db`. */
+  state: string;
+}
+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;
+}
+/** Resolve user options into a fully-bound runtime config. Pure aside from disk reads. */
+declare function resolveConfig(options: ChatOptions): ResolvedConfig;
+//#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';
+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;
+}): EnabledToggleSet;
+//#endregion
+//#region src/chat/mcps-discovery.d.ts
+/**
+ * One entry in the discovered list. `path` is the source file so a Settings
+ * picker can show "Defined in ~/.zidane/mcps.json" tooltips.
+ */
+interface DiscoveredMcp {
+  config: McpServerConfig;
+  source: 'project' | 'user';
+  path: string;
+}
+/**
+ * Search order for `mcps.json` — see {@link projectUserPaths}. Project
+ * beats user; the first file found for each (name) wins. 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. Accepts:
+ *   - A raw `McpServerConfig[]` array — host-SDK convention.
+ *   - An object with `{ "mcpServers": { name: {...} } }` — Claude Desktop
+ *     + many client wrappers. The `mcpServers` value is unwrapped before
+ *     normalization (otherwise `normalizeMcpServers` would treat the whole
+ *     wrapper as a single server).
+ *   - A name-keyed map (`{ fs: {...}, github: {...} }`) — host-SDK
+ *     convenience shape.
+ *
+ * Validation flows through `normalizeMcpServers` so the result matches
+ * what `createAgent` accepts. Throws on malformed JSON; the caller decides
+ * whether to surface or swallow.
+ */
+declare function parseMcpsFile(text: string): McpServerConfig[];
+/**
+ * Walk the default config paths, parse every file that exists, and return
+ * `DiscoveredMcp[]` in source-priority order. Project entries appear
+ * before user entries; first occurrence of a `name` wins (later
+ * duplicates dropped).
+ *
+ * Parse errors are logged under `ZIDANE_DEBUG` and the file skipped so a
+ * single malformed `mcps.json` can't take down the picker.
+ */
+declare function discoverProjectMcps(opts?: {
+  cwd?: string;
+  home?: string;
+  prefix?: string;
+}): DiscoveredMcp[];
+/**
+ * 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.
+ *
+ * Returns a fresh array — callers can mutate without affecting the
+ * underlying discovery list.
+ */
+declare function buildMcpServers(opts: {
+  discovered: readonly DiscoveredMcp[];
+  enabled?: readonly string[];
+}): McpServerConfig[];
+//#endregion
+//#region src/chat/prompt-segments.d.ts
+/**
+ * Pure string + reference math for rendering a submitted prompt with chip
+ * pills around completion references. Renderer-agnostic — the TUI walks
+ * the segments into OpenTUI `<text>` nodes, a GUI walks them into JSX
+ * spans + `<span class="chip">` pills. No layout engine assumptions.
+ */
+/**
+ * Highlight span — half-open `[start, end)` over the source string.
+ *
+ * Offsets are JS string indices (UTF-16 code units) — the same convention used
+ * everywhere else in the chat layer (`text[i]`, `m.index`, `String.slice`).
+ * Surrogate pairs that straddle a span boundary would render malformed, but
+ * realistic prompts in this surface (terminal text + ASCII triggers) keep that
+ * risk theoretical; callers feeding emoji-heavy content should normalize to
+ * codepoint walks upstream.
+ */
+interface PromptSegmentRef {
+  start: number;
+  end: number;
+  /** Provider id tagging this span (`'skills'`, `'files'`, …). Free-form. */
+  providerId: string;
+}
+/**
+ * One atomic unit emitted by {@link splitPromptSegments}. Plain segments
+ * are word-sized so wraps land cleanly between words; chip segments
+ * carry the source `providerId` (`'skills'`, `'files'`, …) so renderers
+ * can pick per-kind colors without re-walking the ref list.
+ */
+type PromptSegment = {
+  kind: 'plain';
+  text: string;
+} | {
+  kind: 'chip';
+  text: string;
+  providerId: string;
+};
+/**
+ * Split a prompt buffer into word-sized atomic segments suitable for a
+ * flex-row + flex-wrap renderer (TUI) or a `display: inline` flow with
+ * inline-block chips (GUI). Each chip becomes one segment (atomic —
+ * never broken across rows); each plain run is split into "word +
+ * trailing space" units so wraps land at clean word boundaries.
+ *
+ * Robust to:
+ *   - Overlapping refs — sorted by start; later refs that overlap are
+ *     dropped via the first-wins rule.
+ *   - Out-of-bounds refs — dropped entirely when `end > text.length` or
+ *     `start >= text.length`. Partial clipping would silently truncate
+ *     a chip's label; the caller is in a better position to surface the
+ *     mismatch (typically a stale `refs` array referencing a previous text).
+ *   - Whitespace-only plain runs — emitted as their own plain segment
+ *     so chip-adjacent-to-chip cases keep the original spacing.
+ *
+ * Word splitter rationale: `\S+\s*` keeps trailing whitespace attached
+ * to its preceding word so wrap boundaries land between words (cleanly).
+ * A leading-whitespace-only segment is captured by `\s+` so we don't
+ * drop it entirely when the plain run starts with a space.
+ */
+declare function splitPromptSegments(text: string, refs: readonly PromptSegmentRef[]): PromptSegment[];
+//#endregion
+//#region src/chat/safe-mode-context.d.ts
+type ApprovalDecision = 'accept-once' | 'accept-safelist' | 'deny';
+interface ApprovalRequest {
+  id: string;
+  tool: string;
+  input: Record<string, unknown>;
+  resolve: (decision: ApprovalDecision) => void;
+}
+/** Function signature consumed by `tool:gate` handlers + the child-tool wrap. */
+type RequestApproval = (tool: string, input: Record<string, unknown>) => Promise<ApprovalDecision>;
+interface SafeModeActions {
+  /** Request a decision; resolves once the user picks. */
+  requestApproval: RequestApproval;
+  /** Resolve the head and shift the queue forward. */
+  resolveHead: (decision: ApprovalDecision) => void;
+  /** Resolve all pending with `deny`. Used on abort / hard exit. */
+  denyAll: () => void;
+}
+/**
+ * Owns the queue + actions. Splits the value across two contexts so a queue
+ * change doesn't invalidate every callback memo that closes over the actions.
+ */
+declare function SafeModeProvider({
+  children
+}: {
+  children: ReactNode;
+}): _$react_jsx_runtime0.JSX.Element;
+declare function useSafeModeQueue(): readonly ApprovalRequest[];
+declare function useSafeModeActions(): SafeModeActions;
+//#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;
+}
+/** 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 {
+  /** 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;
+}
+/**
+ * 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
+export { Settings as $, useEnabledToggleSet as A, BUILD_AGENT as At, lastContextSizeFromTurns as B, DiscoveredMcp as C, modelsForDescriptor as Ct, parseMcpsFile as D, AgentAccent as Dt, discoverProjectMcps as E, piIdOf as Et, StateStoreApi as F, singleAgentRegistry as Ft, stripSpawnTokensLine as G, loadState as H, TuiState as I, toolResultText as J, titleFromTurns as K, createStateStore as L, ProviderRegistry as M, DEFAULT_AGENT_ID as Mt, ResolvedConfig as N, PLAN_AGENT as Nt, EnabledAllowlistKey as O, AgentProfile as Ot, resolveConfig as P, resolveAgentId as Pt, SessionMeta as Q, deriveSessionTitle as R, splitPromptSegments as S, getContextWindow as St, defaultMcpsConfigPaths as T, openrouterDescriptor as Tt, saveState as U, listSessionMeta as V, selectableTurnIds as W, Picked as X, Owner as Y, Screen as Z, SafeModeProvider as _, ModelInfo as _t, SyntaxStyles as a, CompletionReference as at, PromptSegment as b, cerebrasDescriptor as bt, ThemeColors as c, collectReferences as ct, resolveChipColor as d, useCompletion as dt, StreamEvent as et, resolveTheme as f, AuthMethod as ft, SafeModeActions as g, BUILTIN_PROVIDERS as gt, RequestApproval as h, detectAuth as ht, DEFAULT_THEME as i, CompletionProvider as it, ChatOptions as j, BUILTIN_AGENTS as jt, EnabledToggleSet as k, AgentRegistry as kt, ThemeSelect as l, findActiveTrigger as lt, ApprovalRequest as m, ProviderKey as mt, ChipColor as n, CompletionContext as nt, SyntaxTokenStyle as o, CompletionState as ot, ApprovalDecision as p, ProviderAuth as pt, toolCallPreview as q, ChipColorMap as r, CompletionItem as rt, Theme as s, applyInsert as st, BUILTIN_THEMES as t, ActiveTrigger as tt, ThemeSurfaces as u, mergeReferences as ut, useSafeModeActions as v, ProviderDescriptor as vt, buildMcpServers as w, openaiDescriptor as wt, PromptSegmentRef as x, credKeyOf as xt, useSafeModeQueue as y, anthropicDescriptor as yt, eventsFromTurns as z };
+//# sourceMappingURL=theme-pJv47erq.d.ts.map