zidane 5.0.6 → 5.1.0

package/dist/{theme-C3JHZ5y9.d.ts → theme-CcGLMJrn.d.ts}

@@ -1,5 +1,5 @@
-import { At as ThinkingLevel, 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 { A as SessionStore, O as SessionData, Ot as SessionTurn, Pt as ToolResultContent, W as Provider, gt as McpServerConfig, jt as ThinkingLevel, k as SessionRun, y as ToolDef } from "./agent-B0vrSTQ9.js";
+import { t as Preset } from "./index-CFxhms_B.js";
 import { OAuthProviderInterface } from "@mariozechner/pi-ai/oauth";
 import { ReactNode } from "react";
 import * as _$react_jsx_runtime0 from "react/jsx-runtime";
@@ -29,10 +29,37 @@ interface AgentProfile {
   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.
+ * - `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[];
 /**
  * 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;
 /**
@@ -195,6 +222,29 @@ declare function getModelInfo(descriptor: ProviderDescriptor, modelId: string):
  * a registry); callers should hide the context indicator in that case.
  */
 declare function getContextWindow(descriptor: ProviderDescriptor, modelId: string): number | null;
+/**
+ * Reserved output budget subtracted from the raw context window when
+ * computing the effective ceiling for compaction / warning thresholds.
+ *
+ * Aligned with Claude Code's `COMPACT_MAX_OUTPUT_TOKENS = 20_000`
+ * (`utils/context.ts:12`) — covers p99.99 of summary + response output.
+ * A turn that consumed N input tokens leaves `effectiveWindow - N`
+ * headroom for the next prompt's response; once headroom shrinks
+ * below the threshold, auto-compaction fires.
+ */
+declare const OUTPUT_RESERVE_TOKENS = 20000;
+/**
+ * Effective context window — what the next user turn can actually pack
+ * before the provider reserves space for the assistant's reply. Equals
+ * `rawWindow - OUTPUT_RESERVE_TOKENS`, clamped to `>= 1` so a tiny
+ * (or absurd) window doesn't yield zero / negative thresholds.
+ *
+ * Used by both the footer's context indicator and the auto-compact
+ * trigger so the two surfaces agree on "how full are we, really".
+ * Pass `null` through unchanged so callers can pipe `getContextWindow`
+ * directly without an intermediate check.
+ */
+declare function effectiveContextWindow(rawWindow: number | null): number | null;
 /**
  * Whether the given model exposes a reasoning / extended-thinking knob.
  * Drives the TUI's effort picker visibility — the `ctrl+n` shortcut and
@@ -436,6 +486,149 @@ declare function useCompletion<TItem = unknown>(input: {
   maxQueryLength?: number;
 }): CompletionState<TItem>;
 //#endregion
+//#region src/chat/keybindings.d.ts
+/**
+ * Keybindings — a single source of truth for the app's global shortcuts.
+ *
+ * Every customizable action is declared once in {@link KEYBINDING_DEFS}
+ * with its default trigger, label, and description. The TUI imports
+ * `DEFAULT_KEYBINDINGS` for the baked-in defaults; on launch we load
+ * `<userDir>/keybindings.json` (when present) and merge user overrides
+ * on top so the user can rebind any action without recompiling.
+ *
+ * Scope (deliberate):
+ *
+ *   - We expose only the **global, action-opening** shortcuts here —
+ *     "open the Settings modal", "cycle agent profile", "enter
+ *     select-turn mode", etc. Modal-internal letter shortcuts (`f`
+ *     fork, `d` delete, `c` copy on the turn-details modal) and
+ *     universal navigation (`↑/↓/↵/⎋`) stay hardcoded — they live
+ *     too close to a renderable's input contract to remap safely.
+ *
+ *   - Storage lives at the **user level** (`<userDir>/keybindings.json`),
+ *     never inside a project's `.{prefix}/`. Shortcut muscle memory is
+ *     a per-user concern, not a per-repo one.
+ *
+ * Format on disk: JSON with `//` and `/* … *\/` comments allowed
+ * (parsed via a small JSONC stripper). Each entry maps an action id
+ * to a binding spec string. Specs are parsed by {@link parseBindingSpec};
+ * unknown / malformed entries fall back to the default for that action
+ * (with a debug log under `ZIDANE_DEBUG`) so a syntax slip never bricks
+ * the TUI.
+ */
+/**
+ * Every action the keybindings system can drive. Adding a new action
+ * here forces every consumer (TUI keyboard handler, hint rows, settings
+ * UI) to handle it, and ships a default that the user can override.
+ */
+type KeyAction = 'openSettings' | 'openSessionDetails' | 'openModelPicker' | 'openEffortPicker' | 'cycleAgent' | 'enterSelectTurnMode' | 'enterQueueSelection' | 'pushQueuedMessage' | 'dropQueuedMessage' | 'turnFork' | 'turnDelete' | 'turnCopy' | 'sessionDelete' | 'sessionCopyId' | 'sessionGenerateTitle' | 'sessionExportMarkdown' | 'sessionExportJson' | 'sessionCompact';
+/** Resolved keybindings — every action has a current spec string. */
+type KeyBindings = Record<KeyAction, string>;
+/** Static metadata for one action — used by the loader, hint rows, settings UI. */
+interface KeyBindingDef {
+  /** Stable identifier — JSON key + TS union member. */
+  action: KeyAction;
+  /** Default trigger spec (e.g. `'ctrl+o'`). */
+  default: string;
+  /** Short label used in shortcut hint rows. */
+  label: string;
+  /** Longer description for the settings UI and the annotated JSON file. */
+  description: string;
+}
+/**
+ * The canonical action catalog. Order is the source of truth for the
+ * generated keybindings file and the settings UI.
+ */
+declare const KEYBINDING_DEFS: readonly KeyBindingDef[];
+/** Index by action for O(1) lookup of label / description / default. */
+declare const KEYBINDING_DEF_BY_ACTION: Readonly<Record<KeyAction, KeyBindingDef>>;
+/** Defaults, derived from {@link KEYBINDING_DEFS} so the two never drift. */
+declare const DEFAULT_KEYBINDINGS: KeyBindings;
+/** Parsed shape of a `"ctrl+shift+o"` spec. */
+interface ParsedBinding {
+  ctrl: boolean;
+  shift: boolean;
+  alt: boolean;
+  meta: boolean;
+  /** The key name (e.g. `'o'`, `'tab'`, `'escape'`). Always lowercase. */
+  name: string;
+}
+/**
+ * Parse a `'ctrl+shift+o'`-style spec into structured fields. Returns
+ * `null` for empty / malformed inputs; the caller falls back to the
+ * default for that action.
+ *
+ * Tolerant by design:
+ *   - Case-insensitive (`Ctrl+O` → same as `ctrl+o`).
+ *   - Modifier order doesn't matter (`shift+ctrl+o` works).
+ *   - Mixed `+` and `-` separators allowed (`ctrl-o`, `ctrl+o`).
+ *   - Trailing / leading whitespace is stripped.
+ *   - Duplicate modifiers collapse silently.
+ */
+declare function parseBindingSpec(spec: string | undefined | null): ParsedBinding | null;
+/**
+ * Test a KeyEvent against a parsed-or-string binding. Accepts either
+ * form so callers can pre-parse (hot path) or pass the raw spec for
+ * one-off checks.
+ *
+ * Modifier semantics: ALL declared modifiers must be pressed AND no
+ * extra modifiers may be pressed. So `'o'` does NOT match `ctrl+o`,
+ * and `'ctrl+o'` does NOT match `ctrl+shift+o`. This avoids surprises
+ * where a binding that should be specific accidentally fires for a
+ * superset of key combinations.
+ */
+declare function matchesBinding(event: {
+  name?: string;
+  ctrl?: boolean;
+  shift?: boolean;
+  meta?: boolean;
+  option?: boolean;
+  alt?: boolean;
+}, spec: string | ParsedBinding): boolean;
+/**
+ * Merge a partial map of user overrides into the defaults. Unknown
+ * action keys are dropped (a future TUI version may have retired the
+ * action); invalid spec strings (parse fails) fall back to the default
+ * for that action.
+ */
+declare function mergeKeybindings(overrides: Readonly<Record<string, unknown>> | null | undefined): KeyBindings;
+/** Path of the user-level keybindings file. */
+declare function keybindingsPath(userDir: string): string;
+/**
+ * Load + merge the user's keybindings file (when present). Always
+ * returns a fully-resolved {@link KeyBindings} — defaults fill in for
+ * any missing / invalid entries so consumers can treat the result as
+ * total.
+ *
+ * Failure modes (all tolerated, all fall back to defaults):
+ *   - File missing
+ *   - File not valid JSON / JSONC (after comment stripping)
+ *   - Top-level is not an object
+ *   - Individual entries have invalid spec strings
+ */
+declare function readKeybindings(userDir: string): KeyBindings;
+/**
+ * Create the user-level `keybindings.json` if it doesn't exist,
+ * prefilled with every default. Returns the absolute file path either
+ * way so the caller can open it in `$EDITOR`. Idempotent: an existing
+ * user file is NEVER overwritten — the user's customizations are
+ * sacred.
+ */
+declare function ensureKeybindingsFile(userDir: string): string;
+/**
+ * Strip `//` line comments and `/* … *\/` block comments from a JSONC
+ * source string. Stays out of string literals so a `"foo // bar"` value
+ * keeps its slashes. Exported for unit-tests; the only runtime caller
+ * is {@link readKeybindings}.
+ *
+ * Trade-off: this is a tiny state-machine, not a full JSONC parser. It
+ * doesn't understand `\\` outside strings (irrelevant for JSON) and
+ * doesn't track line numbers in error messages. Good enough for a
+ * config file — corruption in production gracefully falls back to the
+ * defaults via the try/catch in `readKeybindings`.
+ */
+declare function stripJsonComments(input: string): string;
+//#endregion
 //#region src/chat/types.d.ts
 type Screen = 'auth' | 'sessions' | 'chat';
 /** Identifies the agent that produced a streaming event. */
@@ -456,8 +649,34 @@ interface StreamEvent {
    * Generic informational banner — status notice, transient message.
    * Reserved for non-user content; user prompts use `'user-prompt'`.
    */
-  | 'info' | 'separator' | 'markdown' | 'spawn-start' | 'spawn-end';
+  | 'info' | 'separator' | 'markdown' | 'spawn-start' | 'spawn-end'
+  /**
+   * Compaction boundary — produced by `eventsFromTurns` when a turn
+   * carries a `compact-summary` block. Marks the point at which the
+   * model's view of history was replaced by an LLM-generated summary.
+   * `text` is the summary body; `compact` carries the extra metadata
+   * needed for the visual card (replaced-turn count, model, usage).
+   *
+   * The renderer is free to style this as a collapsed card; the user
+   * can still scroll above the marker to see the original turns —
+   * compaction never deletes from disk.
+   */
+  | 'compact-summary';
   text: string;
+  /**
+   * Compaction metadata — only set on `compact-summary` events. Mirrors
+   * the underlying `SessionContentBlock` shape but flattened to numbers
+   * so the renderer doesn't need to import the agent's TurnUsage type.
+   */
+  compact?: {
+    /** Number of turns the summary replaces (renderer shows "N turns compacted"). */replacedCount: number; /** Model used for the summary call. */
+    model: string; /** Unix-ms when compaction completed. */
+    compactedAt: number; /** Token usage from the summary call. Renderer formats for display. */
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheCreationTokens: number;
+  };
   /**
    * For `markdown` events: true while the block is still receiving deltas.
    * Renderers keep their markdown parser in streaming mode while this is
@@ -477,6 +696,21 @@ interface StreamEvent {
    * same stats. Absent for non-tool events.
    */
   tool?: string;
+  /**
+   * Raw tool input arguments — only set on `tool` events. Carried so the
+   * renderer can run per-tool formatters (e.g. `↳ Read src/foo.ts L10-25`)
+   * without parsing JSON back out of `text`. Plain object, same shape the
+   * model emitted; renderers must treat unexpected fields as optional.
+   */
+  input?: Record<string, unknown>;
+  /**
+   * Structured payload for `edit` / `multi_edit` / `write_file` tool calls,
+   * extracted from the model's `input` and (for `write_file`) paired with
+   * a pre-write snapshot read at hook time. Drives the `EditDiffBlock`
+   * renderer when {@link Settings.showEditDiffs} is on; absent means
+   * "render as a plain `↳ name(args)` line" (the unstructured fallback).
+   */
+  edit?: EditPayload;
   /**
    * Highlighted spans within `text`, in source order. Used by the renderer
    * to colorize completion references in submitted prompts (`user-prompt`
@@ -504,6 +738,38 @@ interface StreamEvent {
    */
   turnId?: string;
 }
+/**
+ * Structured edit data attached to a `tool` event for `edit` /
+ * `multi_edit` / `write_file`. Lets the renderer compute a unified diff
+ * without re-parsing the JSON input string.
+ *
+ * - `edit` produces one hunk with `replaceAll` defaulting to false.
+ * - `multi_edit` produces one hunk per `edits[]` step (in order).
+ * - `write_file` produces a single hunk where `oldString` is the
+ *   pre-write file content (empty for a fresh create) and `newString`
+ *   is the new content; `replaceAll` is meaningless here and absent.
+ *
+ * Live capture happens in the TUI's `tool:before` hook (where the
+ * pre-write snapshot can be read off disk before the tool runs).
+ * Historical replay from persisted turns can only reconstruct the
+ * edit/multi_edit shape — write_file historical events have no
+ * pre-write content and render with `oldString: ''` (= every line is
+ * an addition), matching git's "new file" diff convention.
+ */
+interface EditPayload {
+  /** Tool name that produced this payload — drives the header glyph + result-suppression matrix. */
+  tool: 'edit' | 'multi_edit' | 'write_file';
+  /** Workspace-relative file path. Used as the diff header. */
+  path: string;
+  /** Ordered list of `(old, new)` pairs. Each rendered as one hunk. */
+  hunks: readonly EditHunk[];
+}
+interface EditHunk {
+  oldString: string;
+  newString: string;
+  /** Mirrored from the tool's `replace_all` flag — surfaced as `× N` in the hunk header. */
+  replaceAll?: boolean;
+}
 interface Picked {
   provider: ProviderAuth;
   model: string;
@@ -533,10 +799,30 @@ interface SessionMeta {
   projectRoot?: string;
   updatedAt: number;
 }
+/**
+ * How `tool` events render in the transcript. Drives `Settings.toolCallDisplay`.
+ *
+ *   - `'hidden'` — `tool` events filtered out entirely (the matching
+ *     `tool-result` block still shows unless its own toggle suppresses
+ *     it). Use when the transcript should read like a chat log.
+ *   - `'formatted'` (default) — each tool renders a clean per-tool
+ *     summary line (e.g. `↳ Read src/foo.ts`, `↳ Shell git status`).
+ *     Native tools have curated formatters; unknown / MCP tools fall
+ *     back to a compact `↳ <name>` line.
+ *   - `'full'` — debug view: `↳ <name>` header plus the entire raw
+ *     `input` rendered as syntax-highlighted JSON. Useful for
+ *     inspecting what the model actually sent.
+ */
+type ToolCallDisplay = 'hidden' | 'formatted' | 'full';
 /** Persisted, user-toggleable transcript filters and modes. */
 interface Settings {
   showThinking: boolean;
-  showToolCalls: boolean;
+  /**
+   * Rendering mode for `tool` events. See {@link ToolCallDisplay}.
+   * Replaces the legacy `showToolCalls: boolean` (TUI auto-migrates
+   * old `state.json` files on first launch).
+   */
+  toolCallDisplay: ToolCallDisplay;
   showToolResults: boolean;
   /**
    * Safe mode — when enabled, every tool call requires explicit user
@@ -569,6 +855,78 @@ interface Settings {
    * leaving the TUI. Per-row project labels appear when on.
    */
   showAllProjects: boolean;
+  /**
+   * Auto-resume the previously-active session on launch. Default: on.
+   * When off, the TUI always lands on the sessions list (or a fresh
+   * session if the list is empty), regardless of what `state.json`
+   * remembers as the last session id.
+   *
+   * The setting is read once on launch — toggling it mid-session
+   * affects the NEXT start, not the current one. `state.lastSessionId`
+   * is still tracked underneath so flipping the setting back on
+   * restores the resume behavior without losing the pointer.
+   */
+  resumeLastSession: boolean;
+  /**
+   * Persist large `tool_result` outputs to disk and substitute a
+   * `<persisted-output>` stub (preview + filesystem path) inline. Built-in
+   * profiles default to 8 KiB threshold via `behavior.persistThreshold`;
+   * this setting is the user-facing kill-switch. When off, the TUI
+   * overrides `behavior.persistThreshold = 0` at agent build time so the
+   * loop's persistence branch never fires.
+   *
+   * The setting takes effect on the next session activation — toggling
+   * mid-stream doesn't tear down an in-flight tool call. Persisted blobs
+   * already on disk stay readable via `read_file`; only future tool
+   * results are affected by the flip.
+   *
+   * Default: on.
+   */
+  persistToolResults: boolean;
+  /**
+   * Fire {@link compactConversation} automatically when the latest turn's
+   * input-token usage crosses {@link Settings.autoCompactThreshold} of the
+   * model's effective context window (raw window minus a fixed output
+   * reserve — see `OUTPUT_RESERVE_TOKENS` in `chat/providers.ts`).
+   *
+   * When the trigger fires, the TUI:
+   * - Appends an `info` event to the transcript announcing the compaction.
+   * - Runs `compactConversation` in the background — the prompt area stays
+   *   visible so the user can compose the next message while it runs.
+   * - The next prompt submission `await`s the in-flight compaction before
+   *   calling `agent.run()`, so the new run sees the post-compaction
+   *   message history (no race with the summary's `appendTurns`).
+   * - Does NOT auto-continue the conversation after compaction completes
+   *   — the user controls when the next turn fires.
+   *
+   * Default: on.
+   */
+  autoCompact: boolean;
+  /**
+   * Threshold for {@link Settings.autoCompact}, expressed as a fraction of
+   * the effective context window. `0.8` means "fire when the latest turn
+   * used 80% of the effective window". Values outside `(0, 1)` are
+   * treated as misconfiguration and skip the trigger.
+   *
+   * The settings modal cycles through `0.6 / 0.7 / 0.8 / 0.9` — coarse
+   * enough that users don't get lost, fine enough to tune for verbose
+   * workflows (lower) versus context-heavy ones (higher).
+   *
+   * Default: `0.8`.
+   */
+  autoCompactThreshold: number;
+  /**
+   * Render `edit` / `multi_edit` / `write_file` tool calls as a clean
+   * unified diff (red `-` / green `+` lines) instead of the raw
+   * `↳ name({"path":"…","old_string":"…"})` JSON dump. When on, the
+   * paired successful `tool-result` ("Edited path: …") is suppressed
+   * too since the diff already conveys success; errors still show.
+   *
+   * Off falls back to the unstructured `↳ name(args)` line + the
+   * regular `tool-result` block — same display the TUI had before
+   * the diff feature shipped. Default: on.
+   */
+  showEditDiffs: boolean;
   /**
    * Allowlist of skill names to expose to the agent + slash-command picker.
    * `undefined` means "every discovered skill" (default). An empty array
@@ -868,6 +1226,13 @@ interface ResolvedConfig {
   initialSettings: Partial<Settings>;
   resumeProvider: ProviderAuth | null;
   initialPicked: Picked | null;
+  /**
+   * Effective keybindings — defaults merged with the user-level
+   * `<userDir>/keybindings.json` (when present). Always fully-resolved
+   * so consumers can treat the record as total. See `./keybindings.ts`
+   * for the action catalog + spec format.
+   */
+  keybindings: KeyBindings;
 }
 /** Resolve user options into a fully-bound runtime config. Pure aside from disk reads. */
 declare function resolveConfig(options: ChatOptions): ResolvedConfig;
@@ -915,6 +1280,223 @@ declare function useEnabledToggleSet<T>(opts: {
   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`).
+   */
+  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;
+}): _$react_jsx_runtime0.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/mcps-discovery.d.ts
 /**
  * One entry in the discovered list. `path` is the source file so a Settings
@@ -939,34 +1521,65 @@ declare function defaultMcpsConfigPaths(opts?: {
   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.
+ * Parse one `mcps.json` file. Canonical zidane shape is a flat array; the
+ * other shapes exist for copy-paste from neighboring tools:
+ *
+ *   - `McpServerConfig[]` — flat array (recommended).
+ *   - `{ name: {...} }` — name-keyed map.
+ *   - `{ "mcpServers": { name: {...} } }` — Claude Desktop / Claude Code /
+ *     Cursor wrapper. Unwrapped before normalization (otherwise
+ *     `normalizeMcpServers` would treat the whole wrapper as a single server).
+ *
+ * Per-entry `enabled: false` (Cursor runtime state) drops the entry — same
+ * intent as the source tool. Use the TUI toggle list for "show but disabled".
+ *
+ * Tolerant to common copy-paste artifacts: when strict `JSON.parse` fails,
+ * retries after normalizing invisible whitespace that's valid Unicode but
+ * not valid JSON whitespace (BOM, NBSP, zero-width spaces, line/paragraph
+ * separators) — only OUTSIDE string literals, so user data isn't mutated.
+ * If the sanitized version still fails, throws the original error with a
+ * targeted hint when NBSPs are present.
  *
  * Validation flows through `normalizeMcpServers` so the result matches
- * what `createAgent` accepts. Throws on malformed JSON; the caller decides
- * whether to surface or swallow.
+ * what `createAgent` accepts. Throws on truly malformed JSON; the caller
+ * decides whether to surface or swallow.
  */
 declare function parseMcpsFile(text: string): McpServerConfig[];
+/**
+ * Per-file failure surfaced from {@link discoverProjectMcps}. The TUI shows
+ * these in the MCP settings empty / preamble state so a malformed
+ * `mcps.json` doesn't look identical to a missing one.
+ */
+interface DiscoveryError {
+  path: string;
+  source: 'project' | 'user';
+  message: string;
+}
+/**
+ * Result of {@link discoverProjectMcps}. `servers` is the per-source-priority
+ * merged list (project beats user, first-found wins on name collision).
+ * `errors` is one entry per file that existed but failed to parse — empty
+ * on the happy path.
+ */
+interface DiscoveryResult {
+  servers: DiscoveredMcp[];
+  errors: DiscoveryError[];
+}
 /**
  * Walk the default config paths, parse every file that exists, and return
- * `DiscoveredMcp[]` in source-priority order. Project entries appear
+ * `{ servers, errors }` 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.
+ * Parse failures are captured into `errors` rather than thrown — the picker
+ * surfaces them while still showing whatever DID parse. A `ZIDANE_DEBUG`
+ * log line is also emitted for ops visibility.
  */
 declare function discoverProjectMcps(opts?: {
   cwd?: string;
   home?: string;
   prefix?: string;
-}): DiscoveredMcp[];
+}): DiscoveryResult;
 /**
  * Map a user-toggled enable list onto the `mcpServers` array the agent
  * receives. Conventions match `buildSkillsConfig`:
@@ -1075,6 +1688,80 @@ declare function SafeModeProvider({
 declare function useSafeModeQueue(): readonly ApprovalRequest[];
 declare function useSafeModeActions(): SafeModeActions;
 //#endregion
+//#region src/chat/session-export.d.ts
+/** File format supported by the exporter. */
+type SessionExportFormat = 'markdown' | 'json';
+/**
+ * Anchor for the resolved destination directory:
+ *   - `project` — the nearest enclosing git repository (`<repoRoot>/.{prefix}/sessions`)
+ *   - `home`    — fallback when no repo was found (`~/.{prefix}/sessions`)
+ */
+type SessionExportAnchor = 'project' | 'home';
+/** Resolved file destination for a session export. */
+interface SessionExportTarget {
+  /** Absolute directory holding the file. May not exist yet — `writeSessionExport` creates it on demand. */
+  dir: string;
+  /** Absolute path of the file (`dir/{id}.{ext}`). */
+  filepath: string;
+  /** Where the destination was anchored. */
+  anchor: SessionExportAnchor;
+}
+/** Options shared by every resolve / write entry-point. */
+interface ResolveOptions {
+  /** Discovery cwd. Defaults to `process.cwd()`. */
+  cwd?: string;
+  /** User home directory. Defaults to `os.homedir()`. */
+  home?: string;
+  /**
+   * Storage prefix. Leading dot tolerated (`zidane` and `.zidane` are
+   * equivalent). Defaults to `'.zidane'`.
+   */
+  prefix?: string;
+}
+/**
+ * Resolve the export target for a session id + format. Pure: no fs
+ * write happens here, the caller decides whether to `existsSync` the
+ * directory or hand the path to `writeSessionExport`.
+ *
+ * Anchor selection walks upward from `cwd` looking for a `.git` entry;
+ * the first hit anchors to that repo's root (`project`). When the walk
+ * exits without finding `.git`, the destination anchors to `home`.
+ *
+ * @throws RangeError when `sessionId` would resolve to an empty / `..`
+ *   filename — defensive guard against malicious or buggy callers
+ *   crossing into a sibling directory via the id.
+ */
+declare function resolveSessionExportTarget(opts: {
+  sessionId: string;
+  format: SessionExportFormat;
+} & ResolveOptions): SessionExportTarget;
+/**
+ * Render a session into a string in the requested format.
+ *
+ * `markdown` produces a human-readable transcript: a YAML-free header
+ * block with the title and a one-line `id · created · turns` summary,
+ * a stats section (turns / runs / tokens / cost / status), then a
+ * `## Conversation` block where each turn renders as `### N. role ·
+ * run_X · ISO-date` with text, thinking, tool calls, and tool results
+ * formatted as appropriate fenced blocks. Useful for sharing a session
+ * with a teammate or pasting into an issue tracker.
+ *
+ * `json` returns a 2-space-indented, deterministic dump of the full
+ * `SessionData` blob. Useful for re-importing into the store or for
+ * post-hoc analysis tooling.
+ */
+declare function renderSession(session: SessionData, format: SessionExportFormat): string;
+/**
+ * Render `session` and write the resulting bytes to disk. Returns the
+ * resolved target so the caller can show the user where the file
+ * landed. The parent directory is created on demand (`recursive: true`)
+ * — first-time exports don't need any pre-flight setup.
+ */
+declare function writeSessionExport(opts: {
+  session: SessionData;
+  format: SessionExportFormat;
+} & ResolveOptions): Promise<SessionExportTarget>;
+//#endregion
 //#region src/chat/theme.d.ts
 /**
  * Renderer-agnostic theme system.
@@ -1174,6 +1861,31 @@ interface ThemeSurfaces {
    * 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`
@@ -1226,5 +1938,5 @@ 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, AgentProfile as At, lastContextSizeFromTurns as B, DiscoveredMcp as C, getModelInfo as Ct, parseMcpsFile as D, openrouterDescriptor as Dt, discoverProjectMcps as E, openaiDescriptor as Et, StateStoreApi as F, PLAN_AGENT as Ft, stripSpawnTokensLine as G, loadState as H, TuiState as I, resolveAgentId as It, toolResultText as J, titleFromTurns as K, createStateStore as L, singleAgentRegistry as Lt, ProviderRegistry as M, BUILD_AGENT as Mt, ResolvedConfig as N, BUILTIN_AGENTS as Nt, EnabledAllowlistKey as O, piIdOf as Ot, resolveConfig as P, DEFAULT_AGENT_ID as Pt, SessionMeta as Q, deriveSessionTitle as R, splitPromptSegments as S, getContextWindow as St, defaultMcpsConfigPaths as T, modelsForDescriptor 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, AgentRegistry as jt, EnabledToggleSet as k, AgentAccent 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, modelSupportsReasoning as wt, PromptSegmentRef as x, credKeyOf as xt, useSafeModeQueue as y, anthropicDescriptor as yt, eventsFromTurns as z };
-//# sourceMappingURL=theme-C3JHZ5y9.d.ts.map
+export { QuestionPayload as $, readKeybindings as $t, DiscoveryError as A, piIdOf as An, stripSpawnTokensLine as At, InteractionRequest as B, singleAgentRegistry as Bn, StreamEvent as Bt, SafeModeProvider as C, effectiveContextWindow as Cn, deriveSessionTitle as Ct, PromptSegmentRef as D, modelsForDescriptor as Dn, loadState as Dt, PromptSegment as E, modelSupportsReasoning as En, listSessionMeta as Et, parseMcpsFile as F, BUILTIN_AGENTS as Fn, Owner as Ft, PendingInteractionEntry as G, KeyBindingDef as Gt, InteractionsActions as H, KEYBINDING_DEFS as Ht, ASK_USER_TOOL as I, DEFAULT_AGENT_ID as In, Picked as It, PlanRequest as J, ensureKeybindingsFile as Jt, PlanDecision as K, KeyBindings as Kt, AnswerValue as L, DEFAULT_PERSIST_EXCLUDE_TOOLS as Ln, Screen as Lt, buildMcpServers as M, AgentProfile as Mn, toolCallPreview as Mt, defaultMcpsConfigPaths as N, AgentRegistry as Nn, toolResultText as Nt, splitPromptSegments as O, openaiDescriptor as On, saveState as Ot, discoverProjectMcps as P, BUILD_AGENT as Pn, EditPayload as Pt, QuestionChoice as Q, parseBindingSpec as Qt, ConfirmQuestion as R, PLAN_AGENT as Rn, SessionMeta as Rt, SafeModeActions as S, credKeyOf as Sn, createStateStore as St, useSafeModeQueue as T, getModelInfo as Tn, lastContextSizeFromTurns as Tt, InteractionsProvider as U, KEYBINDING_DEF_BY_ACTION as Ut, InteractionResponse as V, DEFAULT_KEYBINDINGS as Vt, PRESENT_PLAN_TOOL as W, KeyAction as Wt, PlanStep as X, matchesBinding as Xt, PlanResponse as Y, keybindingsPath as Yt, Question as Z, mergeKeybindings as Zt, resolveSessionExportTarget as _, ModelInfo as _n, ProviderRegistry as _t, SyntaxStyles as a, CompletionReference as an, buildResumedToolResultsTurn as at, ApprovalRequest as b, anthropicDescriptor as bn, StateStoreApi as bt, ThemeColors as c, collectReferences as cn, makeRequestInteraction as ct, resolveChipColor as d, useCompletion as dn, useInteractionsActions as dt, stripJsonComments as en, QuestionRequest as et, resolveTheme as f, AuthMethod as fn, useInteractionsQueue as ft, renderSession as g, BUILTIN_PROVIDERS as gn, ChatOptions as gt, SessionExportTarget as h, detectAuth as hn, useEnabledToggleSet as ht, DEFAULT_THEME as i, CompletionProvider as in, TextQuestion as it, DiscoveryResult as j, AgentAccent as jn, titleFromTurns as jt, DiscoveredMcp as k, openrouterDescriptor as kn, selectableTurnIds as kt, ThemeSelect as l, findActiveTrigger as ln, pendingInteractionsFromTurns as lt, SessionExportFormat as m, ProviderKey as mn, EnabledToggleSet as mt, ChipColor as n, CompletionContext as nn, QuestionType as nt, SyntaxTokenStyle as o, CompletionState as on, createInteractionTools as ot, SessionExportAnchor as p, ProviderAuth as pn, EnabledAllowlistKey as pt, PlanPayload as q, ParsedBinding as qt, ChipColorMap as r, CompletionItem as rn, SelectQuestion as rt, Theme as s, applyInsert as sn, isInteractionTool as st, BUILTIN_THEMES as t, ActiveTrigger as tn, QuestionResponse as tt, ThemeSurfaces as u, mergeReferences as un, serializeInteractionResponse as ut, writeSessionExport as v, OUTPUT_RESERVE_TOKENS as vn, ResolvedConfig as vt, useSafeModeActions as w, getContextWindow as wn, eventsFromTurns as wt, RequestApproval as x, cerebrasDescriptor as xn, TuiState as xt, ApprovalDecision as y, ProviderDescriptor as yn, resolveConfig as yt, CreateInteractionToolsOptions as z, resolveAgentId as zn, Settings as zt };
+//# sourceMappingURL=theme-CcGLMJrn.d.ts.map