zidane 5.0.6 → 5.1.1

package/dist/chat.d.ts

@@ -1,10 +1,269 @@
-import { D as SessionData, Dt as SessionTurn, Lt as TurnUsage, U as Provider, b as SkillConfig, w as SkillsConfig } from "./agent-JhicgLOV.js";
-import { m as SourcedScanPath } from "./index-t_W9i7Ql.js";
-import { $ as Settings, A as useEnabledToggleSet, At as AgentProfile, B as lastContextSizeFromTurns, C as DiscoveredMcp, Ct as getModelInfo, D as parseMcpsFile, Dt as openrouterDescriptor, E as discoverProjectMcps, Et as openaiDescriptor, F as StateStoreApi, Ft as PLAN_AGENT, G as stripSpawnTokensLine, H as loadState, I as TuiState, It as resolveAgentId, J as toolResultText, K as titleFromTurns, L as createStateStore, Lt as singleAgentRegistry, M as ProviderRegistry, Mt as BUILD_AGENT, N as ResolvedConfig, Nt as BUILTIN_AGENTS, O as EnabledAllowlistKey, Ot as piIdOf, P as resolveConfig, Pt as DEFAULT_AGENT_ID, Q as SessionMeta, R as deriveSessionTitle, S as splitPromptSegments, St as getContextWindow, T as defaultMcpsConfigPaths, Tt as modelsForDescriptor, U as saveState, V as listSessionMeta, W as selectableTurnIds, X as Picked, Y as Owner, Z as Screen, _ as SafeModeProvider, _t as ModelInfo, a as SyntaxStyles, at as CompletionReference, b as PromptSegment, bt as cerebrasDescriptor, c as ThemeColors, ct as collectReferences, d as resolveChipColor, dt as useCompletion, et as StreamEvent, f as resolveTheme, ft as AuthMethod, g as SafeModeActions, gt as BUILTIN_PROVIDERS, h as RequestApproval, ht as detectAuth, i as DEFAULT_THEME, it as CompletionProvider, j as ChatOptions, jt as AgentRegistry, k as EnabledToggleSet, kt as AgentAccent, l as ThemeSelect, lt as findActiveTrigger, m as ApprovalRequest, mt as ProviderKey, n as ChipColor, nt as CompletionContext, o as SyntaxTokenStyle, ot as CompletionState, p as ApprovalDecision, pt as ProviderAuth, q as toolCallPreview, r as ChipColorMap, rt as CompletionItem, s as Theme, st as applyInsert, t as BUILTIN_THEMES, tt as ActiveTrigger, u as ThemeSurfaces, ut as mergeReferences, v as useSafeModeActions, vt as ProviderDescriptor, w as buildMcpServers, wt as modelSupportsReasoning, x as PromptSegmentRef, xt as credKeyOf, y as useSafeModeQueue, yt as anthropicDescriptor, z as eventsFromTurns } from "./theme-C3JHZ5y9.js";
+import { Ot as SessionTurn, Rt as TurnUsage, T as SkillsConfig, W as Provider, x as SkillConfig } from "./agent-B0vrSTQ9.js";
+import { K as McpCredentialEntry, q as McpCredentialStore } from "./index-CFxhms_B.js";
+import { m as SourcedScanPath } from "./index-X6Q9PN_A.js";
+import { $ as PlanRequest, $n as singleAgentRegistry, $t as DEFAULT_KEYBINDINGS, A as useSafeModeQueue, An as OUTPUT_RESERVE_TOKENS, At as isEditErrorResult, B as parseMcpsFile, Bn as openaiDescriptor, Bt as titleFromTurns, C as writeSessionExport, Cn as useCompletion, Ct as ResolvedConfig, D as SafeModeActions, Dn as detectAuth, Dt as createStateStore, E as RequestApproval, En as ProviderKey, Et as TuiState, F as DiscoveryError, Fn as effectiveContextWindow, Ft as loadState, G as InteractionRequest, Gn as AgentRegistry, Gt as EditPayload, H as AnswerValue, Hn as piIdOf, Ht as toolResultText, I as DiscoveryResult, In as getContextWindow, It as marginTopFor, J as InteractionsProvider, Jn as DEFAULT_AGENT_ID, Jt as Screen, K as InteractionResponse, Kn as BUILD_AGENT, Kt as Owner, L as buildMcpServers, Ln as getModelInfo, Lt as saveState, M as PromptSegmentRef, Mn as anthropicDescriptor, Mt as isVisible, N as splitPromptSegments, Nn as cerebrasDescriptor, Nt as lastContextSizeFromTurns, O as SafeModeProvider, On as BUILTIN_PROVIDERS, Ot as deriveSessionTitle, P as DiscoveredMcp, Pn as credKeyOf, Pt as listSessionMeta, Q as PlanPayload, Qn as resolveAgentId, Qt as ToolCallDisplay, R as defaultMcpsConfigPaths, Rn as modelSupportsReasoning, Rt as selectableTurnIds, S as resolveSessionExportTarget, Sn as mergeReferences, St as ProviderRegistry, T as ApprovalRequest, Tn as ProviderAuth, Tt as StateStoreApi, U as ConfirmQuestion, Un as AgentAccent, Ut as turnSelectionOwnership, V as ASK_USER_TOOL, Vn as openrouterDescriptor, Vt as toolCallPreview, W as CreateInteractionToolsOptions, Wn as AgentProfile, Wt as EditHunk, X as PendingInteractionEntry, Xn as PLAN_AGENT, Xt as Settings, Y as PRESENT_PLAN_TOOL, Yn as DEFAULT_PERSIST_EXCLUDE_TOOLS, Yt as SessionMeta, Z as PlanDecision, Zn as accentColor, Zt as StreamEvent, _ as resolveTheme, _n as CompletionReference, _t as useInteractionsQueue, a as formatToolCall, an as ParsedBinding, at as QuestionRequest, b as SessionExportTarget, bn as collectReferences, bt as useEnabledToggleSet, c as ChipColorMap, cn as matchesBinding, ct as SelectQuestion, d as SyntaxTokenStyle, dn as readKeybindings, dt as createInteractionTools, en as KEYBINDING_DEFS, et as PlanResponse, f as Theme, fn as stripJsonComments, ft as isInteractionTool, g as resolveChipColor, gn as CompletionProvider, gt as useInteractionsActions, h as ThemeSurfaces, hn as CompletionItem, ht as serializeInteractionResponse, i as displayNameFor, in as KeyBindings, it as QuestionPayload, j as PromptSegment, jn as ProviderDescriptor, jt as isTurnHighlighted, k as useSafeModeActions, kn as ModelInfo, kt as eventsFromTurns, l as DEFAULT_THEME, ln as mergeKeybindings, lt as TextQuestion, m as ThemeSelect, mn as CompletionContext, mt as pendingInteractionsFromTurns, n as ToolDisplayMeta, nn as KeyAction, nt as Question, o as BUILTIN_THEMES, on as ensureKeybindingsFile, ot as QuestionResponse, p as ThemeColors, pn as ActiveTrigger, pt as makeRequestInteraction, q as InteractionsActions, qn as BUILTIN_AGENTS, qt as Picked, r as ToolFormatLine, rn as KeyBindingDef, rt as QuestionChoice, s as ChipColor, sn as keybindingsPath, st as QuestionType, t as TOOL_DISPLAY, tn as KEYBINDING_DEF_BY_ACTION, tt as PlanStep, u as SyntaxStyles, un as parseBindingSpec, ut as buildResumedToolResultsTurn, v as SessionExportAnchor, vn as CompletionState, vt as EnabledAllowlistKey, w as ApprovalDecision, wn as AuthMethod, wt as resolveConfig, x as renderSession, xn as findActiveTrigger, xt as ChatOptions, y as SessionExportFormat, yn as applyInsert, yt as EnabledToggleSet, z as discoverProjectMcps, zn as modelsForDescriptor, zt as stripSpawnTokensLine } from "./tool-formatters-D7cN3T_W.js";
 import { OAuthCredentials } from "@mariozechner/pi-ai/oauth";
 import { Dispatch, ReactNode, SetStateAction } from "react";
 import * as _$react_jsx_runtime0 from "react/jsx-runtime";
-
+//#region src/chat/agent-prompt.d.ts
+/**
+ * Agent system-prompt fragments — composable doctrine for built-in profiles.
+ *
+ * Each `const` below is one self-contained section of a system prompt. They
+ * exist as exports so SDK consumers can pick and choose: build a custom
+ * profile by spreading them in {@link buildBuildSystem} order, drop a fragment
+ * for a stricter / looser agent, or compose with project-specific prose.
+ *
+ * The fragments are deliberately byte-stable across sessions — every doctrine
+ * piece reads the same on every turn so the system-prompt cache breakpoint
+ * (anthropic ephemeral, `src/providers/anthropic.ts:327`) keeps hitting cache.
+ * Runtime-derived content (cwd, date) lives in {@link envSection} and is
+ * computed at agent-build time, not per-turn — same anchor, same cache.
+ *
+ * The TUI overrides `agent.run({ system })` with the composed string at
+ * session activation so a moved cwd or rolled-over date refreshes the
+ * prefix; SDK consumers calling `createAgent({ system })` directly get the
+ * cwd-less variant from the preset and can wrap their own env section.
+ */
+/**
+ * Lead line — short, version-stable, written in the same key as Claude Code's
+ * identity prefix (`constants/system.ts:10` in claude-code). Models trained
+ * on similar prefixes anchor faster; keep this immutable across releases.
+ */
+declare const IDENTITY_PREFIX = "You are zidane, a terminal-based coding agent that helps the user with software-engineering tasks.";
+interface EnvSectionOptions {
+  /**
+   * The agent's actual working directory — what `process.cwd()` reports
+   * and what its tool calls resolve relative paths against. Distinct
+   * from {@link EnvSectionOptions.projectRoot}, which carries the
+   * project anchor when the user spawned from a subdirectory.
+   */
+  cwd: string;
+  /**
+   * Project root (typically the git root). When set AND different from
+   * `cwd`, the rendered env block discloses both AND adds a path-
+   * convention note — file paths coming from the user's `@`-completion
+   * are project-root-relative, NOT cwd-relative, so the model needs to
+   * know there's a wider anchor to resolve them against. When omitted
+   * or equal to `cwd`, the block stays compact (no project-root line,
+   * no note) — same wording as before the subdirectory disclosure
+   * landed, so users running from a project's root see no extra text.
+   */
+  projectRoot?: string;
+  /** ISO date (YYYY-MM-DD). Defaults to today. Pinned for tests. */
+  date?: string;
+  /** Platform string. Defaults to `process.platform`. Pinned for tests. */
+  platform?: string;
+}
+/**
+ * Render the env anchor block. Plain text — XML tags only because models
+ * lean on them as structural cues, not because we parse them anywhere.
+ *
+ * Kept narrow on purpose: cwd / projectRoot / date / platform are the
+ * knobs the model can't infer from the conversation. Anything else
+ * (git branch, project name) belongs in CLAUDE.md / project-level
+ * prompts where the user opts in.
+ *
+ * Cache-stability: outputs are byte-stable per `(cwd, projectRoot,
+ * date, platform)` tuple. Repeated session activations against the
+ * same workspace produce the same prefix → provider's prompt cache
+ * hits across turns + across sessions in the same host process.
+ */
+declare function envSection(opts: EnvSectionOptions): string;
+/**
+ * Software-engineering doctrine. Lifted in spirit from claude-code's
+ * `# Doing tasks` (`constants/prompts.ts:199-253`). Key levers:
+ *
+ * - Stick to scope — prevents speculative refactors that double output tokens.
+ * - No narration comments — prevents inflating diffs with `// Import the module` lines.
+ * - Verify before claiming done — prevents false-positive reports that force a follow-up turn.
+ */
+declare const DOING_TASKS_DOCTRINE = "# Doing tasks\n- Stick to the scope you were asked for. Don't add features, refactor unrelated code, or \"improve\" things beyond the request. A bug fix doesn't need surrounding cleanup; a small feature doesn't need extra configurability.\n- Don't add comments, docstrings, or type annotations to code you didn't change. Only comment where the WHY is non-obvious (hidden constraint, subtle invariant, workaround). Never narrate WHAT the code does \u2014 well-named identifiers already do that.\n- Trust internal code and framework guarantees. Validate at system boundaries (user input, external APIs), not everywhere. Skip backwards-compat shims unless asked.\n- Don't create helpers, utilities, or abstractions for one-time operations. Three similar lines beat a premature abstraction. The right amount of complexity is what the task actually requires.\n- Before reporting a task complete, verify it actually works: run the test, execute the script, check the output. Report outcomes faithfully \u2014 if tests fail, say so with the relevant output. Never claim \"all tests pass\" when output shows failures.\n- If you spot a bug adjacent to what was asked, or notice the request is based on a misconception, say so. You are a collaborator, not just an executor.";
+/**
+ * zidane-specific token-economy doctrine. No claude-code analog — this is
+ * the prose half of the `behavior.{compactStrategy, elideStaleReads,
+ * toolDisclosure, toolOutputBudget}` defaults. The behavior flags do the
+ * heavy lifting at the wire level; this prompt nudges the model away from
+ * the access patterns that defeat them.
+ */
+declare const TOKEN_DISCIPLINE_DOCTRINE = "# Working efficiently\n- Read a file once. Re-reading the same file in the same session wastes context \u2014 the prior `read_file` result is still in your view (and stale reads after an edit are elided automatically).\n- Narrow before you read. `grep` / `glob` to locate, then `read_file` on the specific file. Don't open a 2000-line file when you only need one function.\n- Prefer `edit` / `multi_edit` over `write_file` for surgical changes \u2014 full overwrites are larger payloads and easier to get wrong.\n- Spawn a subagent (`spawn`) for self-contained research dives or codegen passes that don't need the parent's context. The child runs in its own context window \u2014 you only get its final report back.\n- Don't grep for things already shown to you, list directories you already saw, or re-execute commands whose output is still above. Tool budgets nudge against runaway exploration but the cheaper fix is to not start the loop.\n\nTool results may be elided, persisted, or replaced as the conversation grows: stale `read_file` outputs become short stubs after the file is edited, older tool results may be tail-compacted, and large outputs are written to disk and replaced inline with a `<persisted-output tool=\"\u2026\" bytes=\"\u2026\" path=\"\u2026\">` block carrying a 2 KiB head preview plus the filesystem path. Copy load-bearing data into your own response text before you'd need to recover it later \u2014 and when you see a `<persisted-output>` block whose preview isn't enough, call `read_file` on the persisted path to retrieve the full payload.";
+/**
+ * User-facing communication style. Lifted from claude-code's
+ * `# Communicating with the user` + `# Tone and style` sections (~404-442).
+ * The "no colon before tool calls" rule matters because models often
+ * generate "Let me check this file:" right before a tool call that the
+ * user never sees rendered.
+ */
+declare const COMMUNICATION_DOCTRINE = "# Communicating with the user\n- You're writing for a person, not logging to a console. Tool calls and reasoning are not visible \u2014 only your text output is. Before your first tool call, briefly state what you're about to do.\n- Give short updates at load-bearing moments: root cause found, direction change, real progress. Skip play-by-play.\n- Write in flowing prose. Avoid excessive em dashes, fragments, symbols, or notation. Tables when they help, not by default.\n- Don't use a colon before tool calls. \"Let me read the file:\" + tool call reads as broken \u2014 write \"Let me read the file.\" with a period.\n- Reference code as `file:line` so the user can navigate (e.g. `src/agent.ts:1213`).\n- No emojis unless the user explicitly asks.";
+/**
+ * Reversibility / blast-radius doctrine. Mirrors claude-code's `# Executing
+ * actions with care` (255-267). The TUI's safe-mode already gates risky
+ * tool calls behind explicit approval, but this prompt teaches the model
+ * to anticipate the gate rather than be surprised by it — and to ask
+ * before reaching for destructive shortcuts.
+ */
+declare const ACTIONS_WITH_CARE_DOCTRINE = "# Executing actions with care\nReversibility scales the required caution. Local edits, tests, and reads are free to take. Destructive or shared-state actions need explicit user confirmation \u2014 `rm -rf`, dropping tables, force-pushing, modifying CI, sending messages, posting to external services. A user approving an action once does NOT mean they approve it in all contexts.\n\nWhen you hit an obstacle, do not use destructive actions as a shortcut to make it go away. Measure twice, cut once.";
+/**
+ * How to brief a subagent. Spawning a child agent is the highest-leverage
+ * token move in zidane — a 5k-token research dive becomes a 200-token
+ * summary in the parent's context. But shallow prompts produce shallow
+ * work, so the doctrine is mostly about quality of the briefing.
+ *
+ * Lifted from claude-code's `## Writing the prompt` tool-prompt
+ * (`tools/AgentTool/prompt.ts:99-113`).
+ */
+declare const SUBAGENT_GUIDANCE = "# When spawning subagents\nBrief the child agent like a smart colleague who just walked in \u2014 it has not seen this conversation and doesn't know what you've tried or why this matters.\n- Explain what you're trying to accomplish and why.\n- Describe what you've already learned or ruled out.\n- Give enough context that the child can make judgment calls, not just follow narrow steps.\n- For investigations, hand over the question. For lookups, hand over the exact command.\n- Never delegate understanding (\"based on your findings, fix the bug\"). Synthesize yourself \u2014 include file paths, line numbers, and the specific change you want.\n\nTerse command-style prompts produce shallow, generic work.";
+/**
+ * Plan-mode framing. Replaces the previous one-liner with explicit phases
+ * (explore → propose → submit), drawing on claude-code's iterative-plan
+ * mode (`utils/messages.ts:3323-3383`). Always paired with the read-only
+ * tool set in {@link PLAN_AGENT}.
+ */
+declare const PLAN_MODE_DOCTRINE = "# Plan mode \u2014 read-only\nYou are in PLAN mode. You can read files, list directories, and search the codebase \u2014 but you CANNOT modify files, run shell commands, or spawn subagents. Use this mode to investigate, understand, and design a proposal.\n\n## Loop\n1. **Explore** \u2014 Read code. Look for existing functions, utilities, and patterns to reuse.\n2. **Ask** \u2014 When you hit an ambiguity only the user can resolve (requirements, preferences, tradeoffs), call `ask_user` with the full batch of questions.\n3. **Propose** \u2014 When the plan is ready, submit it via `present_plan` with a concrete title, the markdown body, and optional structured steps. The user approves, rejects, or asks for revisions.\n\n## Good plans\n- Cover what to change, which files to modify, what existing code to reuse (with file paths), and how to verify the change end-to-end.\n- Reference real symbols and line numbers from your exploration.\n- Surface only your recommended approach, not every alternative.\n\nThe user will switch to Build mode to execute an approved plan.";
+/**
+ * How to use `present_plan` / `ask_user`. Kept short — the tool descriptions
+ * carry the schema details; this prompt covers the cross-cutting *when*.
+ *
+ * Previously lived inline in `src/chat/agents.ts` as `INTERACTION_GUIDANCE`.
+ * Moved here so a custom profile can pull it in independently.
+ */
+declare const INTERACTION_GUIDANCE = "# Interacting with the user\n- Call `present_plan` when you have a concrete proposal that materially changes the workspace and want explicit confirmation before executing.\n- Call `ask_user` when clarifying answers materially change the next steps. Batch related questions into one call \u2014 every call pauses the conversation.\n- Use both sparingly. Don't ask what you could find out by reading the code.";
+interface BuildSystemOptions {
+  /** Actual working directory. Omitted ⇒ no env section is rendered. */
+  cwd?: string;
+  /**
+   * Project root (typically the git root), when different from `cwd`.
+   * When the user spawned the agent from a subdirectory of a larger
+   * project, this enables the env block's two-line disclosure + path-
+   * resolution note (see {@link envSection}). Same-as-`cwd` or
+   * omitted ⇒ the env block stays compact.
+   */
+  projectRoot?: string;
+  /** Override date for tests. */
+  date?: string;
+  /** Override platform for tests. */
+  platform?: string;
+}
+/**
+ * Compose the Build-mode system prompt.
+ *
+ * Order matters for cache stability: identity → env → doctrine → guidance.
+ * Env comes before doctrine so a cwd change rebuilds only the head of the
+ * prompt; the doctrine tail stays byte-identical across sessions and rides
+ * the cache.
+ *
+ * The fragments are joined with blank lines so the model sees clean section
+ * breaks. Don't reorder lightly — every reorder costs one cache miss across
+ * every active session.
+ */
+declare function buildBuildSystem(opts?: BuildSystemOptions): string;
+/**
+ * Compose the Plan-mode system prompt. Subset of Build: drops the
+ * subagent + actions-with-care fragments (no shell, no spawn in plan
+ * mode) and uses `PLAN_MODE_DOCTRINE` instead of `DOING_TASKS_DOCTRINE`.
+ */
+declare function buildPlanSystem(opts?: BuildSystemOptions): string;
+//#endregion
+//#region src/chat/auto-compact.d.ts
+/**
+ * Auto-compaction trigger policy — decide whether the latest turn's usage
+ * has crossed the threshold that should fire `compactConversation` against
+ * the active session.
+ *
+ * Pure function, no I/O. Sits next to the chat-layer settings + providers
+ * so the same decision is reusable from a non-TUI host (a future GUI shell
+ * that wants to surface "Compact now" suggestions, a CI runner that wants
+ * to auto-compact between batches, …).
+ *
+ * Wire contract:
+ *
+ *  - Inputs are the bits the TUI already tracks: latest `usage.input` (from
+ *    `turn:after`), the model's raw context window (`getContextWindow`),
+ *    and the user's settings (`autoCompact` + `autoCompactThreshold`).
+ *  - Output is a discriminated outcome — `'fire'` when the trigger should
+ *    run, `'skip'` with a reason otherwise. The reason is diagnostic only;
+ *    callers don't branch on it but tests + debug logs need it.
+ *
+ * No state. Same inputs → same answer.
+ */
+/**
+ * Inputs to {@link shouldAutoCompact}.
+ *
+ * Kept as a struct so the call site reads as the predicate it is, and so
+ * future inputs (per-session opt-out, recent-compaction cooldown, …) land
+ * without re-threading every consumer.
+ */
+interface AutoCompactInput {
+  /** User's master toggle. `false` → trigger never fires. */
+  enabled: boolean;
+  /**
+   * Threshold expressed as a fraction of the effective context window
+   * (e.g. `0.8` = 80%). Values outside the open interval `(0, 1)` are
+   * rejected with `'invalid-threshold'` — `<= 0` is meaningless, and
+   * `>= 1` would schedule the trigger for "after we've already
+   * overflowed" which is too late to be useful.
+   */
+  threshold: number;
+  /**
+   * Latest input-token count from the last `turn:after`. Must be a
+   * non-negative finite number; `NaN` / `±Infinity` / negative values
+   * are treated as "no usable signal" and the trigger skips
+   * conservatively (we'd rather defer compaction than fire on garbage).
+   */
+  inputTokens: number;
+  /**
+   * Model's raw context window from `getContextWindow(descriptor, model)`.
+   * `null` for unknown / custom models — the trigger skips since we can't
+   * compute a ratio.
+   */
+  rawContextWindow: number | null;
+  /**
+   * Whether a compaction is already in flight for this session. The TUI
+   * tracks this with a ref + Promise; passing it through the predicate
+   * lets the test suite assert "doesn't double-fire" without spinning up
+   * the agent loop.
+   */
+  alreadyCompacting?: boolean;
+}
+type AutoCompactDecision = {
+  kind: 'fire';
+  usedFraction: number;
+  effectiveWindow: number;
+} | {
+  kind: 'skip';
+  reason: 'disabled' | 'unknown-window' | 'invalid-threshold' | 'invalid-input-tokens' | 'under-threshold' | 'already-compacting';
+};
+/**
+ * Decide whether auto-compaction should fire for the latest turn.
+ *
+ * Order of checks is deliberate: cheapest / most common skips first
+ * (`disabled` is one boolean read; `unknown-window` is the predictable
+ * miss for custom models), invariant violations next, then the actual
+ * threshold math. `already-compacting` runs last so the diagnostic
+ * surfaces correctly when the predicate is called inside an existing
+ * compaction window.
+ */
+declare function shouldAutoCompact(input: AutoCompactInput): AutoCompactDecision;
+//#endregion
+//#region src/chat/browser.d.ts
+/**
+ * Best-effort cross-platform browser open.
+ *
+ * macOS uses `open`, Linux uses `xdg-open`, Windows uses `start`. Failures
+ * are swallowed — both callers (AI-provider OAuth + MCP-server OAuth) show
+ * the URL on-screen for manual click anyway, and the underlying flows have
+ * their own progress/cancel paths.
+ *
+ * Uses `spawn` (not `exec`) so the URL is passed as an argv element rather
+ * than interpolated into a shell command — URLs containing `&`, `?`, `"`,
+ * or other shell metacharacters don't need quoting.
+ *
+ * Detached + unref so the spawned helper outlives the parent: the user
+ * can finish authorizing in the browser even if the TUI is later
+ * suspended (Ctrl-Z) or killed.
+ */
+declare function tryOpenBrowser(url: string): void;
+//#endregion
 //#region src/chat/files-discovery.d.ts
 /**
  * Project file discovery for the `@`-prefixed files completion provider.
@@ -167,6 +426,41 @@ declare function removeProviderCredential(dataDir: string, descriptor: ProviderD
  */
 declare function applyApiKeyEnv(dataDir: string, registry: Readonly<Record<string, ProviderDescriptor>>): void;
 //#endregion
+//#region src/chat/edit-diff.d.ts
+declare function extractEditPayload(name: string, input: Record<string, unknown>, priorContent?: string): EditPayload | undefined;
+type DiffOp = 'context' | 'add' | 'remove';
+interface DiffLine {
+  op: DiffOp;
+  text: string;
+}
+declare function computeLineDiff(oldString: string, newString: string): DiffLine[];
+/**
+ * Split a string into lines preserving empty lines but dropping the
+ * implicit trailing `""` produced by a final `\n`. Exported only for
+ * its tests — callers should use `computeLineDiff`.
+ */
+declare function splitLines(s: string): string[];
+interface InlineSegment {
+  text: string;
+  changed: boolean;
+}
+interface InlineDiff {
+  oldSegments: InlineSegment[];
+  newSegments: InlineSegment[];
+}
+declare function computeInlineDiff(oldLine: string, newLine: string): InlineDiff;
+/**
+ * Tokenize on word / non-word boundaries. Each run of `\w+` is one
+ * token; each run of `\W+` (whitespace, punctuation) is another. This
+ * gives the right granularity for renames (`oldName` → `newName`) and
+ * for symbol swaps (`+ → -`) without exploding into per-char segments.
+ *
+ * Exported only for its tests.
+ */
+declare function tokenize(s: string): string[];
+declare function buildUnifiedDiff(payload: EditPayload): string;
+declare function filetypeFromPath(path: string): string | undefined;
+//#endregion
 //#region src/chat/format.d.ts
 /** Compact token formatter — 12_415 → "12.4k", 1_234_567 → "1.23M". */
 declare function fmtTokens(n: number): string;
@@ -174,6 +468,21 @@ declare function fmtTokens(n: number): string;
 declare function ageString(ts: number, now?: number): string;
 /** Six-char short form of a session id for headers and lists. */
 declare function shortId(id: string): string;
+/**
+ * Compact an absolute path for display: replace the user's `$HOME`
+ * prefix with `~` (so `/Users/yael/Code/zidane` → `~/Code/zidane`),
+ * and optionally left-truncate with an ellipsis when the result
+ * still exceeds `maxWidth` (so the path's *tail* — the part the user
+ * recognizes — stays visible: `…/zidane` rather than `/Users/yaeluil…`).
+ *
+ * `maxWidth` is the maximum *display width* in cells. Omit to skip
+ * truncation. Paths outside `$HOME` are returned verbatim modulo
+ * truncation. The ellipsis (`…`) counts as one cell.
+ *
+ * `home` overrides `os.homedir()` for tests; production callers leave
+ * it undefined and pay the cheap one-syscall lookup per call.
+ */
+declare function compactPath(path: string, maxWidth?: number, home?: string): string;
 //#endregion
 //#region src/chat/generate-title.d.ts
 interface GenerateSessionTitleOptions {
@@ -220,6 +529,137 @@ declare function generateSessionTitle({
  */
 declare function cleanTitle(raw: string): string;
 //#endregion
+//#region src/chat/mcp-auth-state.d.ts
+/**
+ * Per-server MCP OAuth status tracking, decoupled from the renderer.
+ *
+ * The TUI keeps a `Record<serverName, McpAuthStatus>` so it can render a
+ * "needs-auth" / "authorizing" / "error" badge in the MCP picker. The
+ * status map is driven entirely by hooks fired from the agent's MCP
+ * bootstrap + the interactive `loginMcpServer` flow — the reducer below
+ * is pure, makes no FS or network calls, and is shared between the live
+ * TUI store and the test harness.
+ *
+ * Status lifecycle:
+ *
+ *   idle ──mcp:connect──▶  authed
+ *                         (bootstrap succeeded with stored tokens)
+ *
+ *   idle ──mcp:auth:required──▶ needs-auth
+ *                              (bootstrap saw no/invalid tokens)
+ *
+ *   needs-auth ──login()──▶ authorizing ──mcp:auth:url──▶ authorizing(url)
+ *                                       ──mcp:auth:success──▶ authed
+ *                                       ──mcp:auth:error──▶ error
+ *
+ *   any         ──logout──▶ idle
+ *
+ * Multiple servers progress through the lifecycle independently; the map
+ * is keyed by `McpServerConfig.name`.
+ */
+type McpAuthStatus = {
+  kind: 'idle';
+} | {
+  kind: 'needs-auth';
+  reason: 'no-tokens' | 'auto-promoted';
+} | {
+  kind: 'authorizing';
+  url?: string;
+} | {
+  kind: 'authed';
+} | {
+  kind: 'error';
+  error: string;
+};
+/**
+ * Map of server name → status. `idle` is the implicit default for any
+ * server NOT present in the map, so the renderer treats `undefined` as
+ * `{ kind: 'idle' }` and the map can stay sparse.
+ */
+type McpAuthStateMap = Readonly<Record<string, McpAuthStatus>>;
+/**
+ * Events the reducer accepts. Names mirror the agent hooks 1:1 plus two
+ * UI-only verbs (`login:start` / `login:cancel`) so the renderer can
+ * optimistically flip a row to `authorizing` before the SDK has emitted
+ * `mcp:auth:url` — useful when the loopback callback is slow to bind.
+ */
+type McpAuthEvent = {
+  type: 'auth-required';
+  name: string;
+  reason: 'no-tokens' | 'auto-promoted';
+} | {
+  type: 'auth-url';
+  name: string;
+  url: string;
+} | {
+  type: 'auth-success';
+  name: string;
+} | {
+  type: 'auth-error';
+  name: string;
+  error: string;
+} | {
+  type: 'connected';
+  name: string;
+} | {
+  type: 'login:start';
+  name: string;
+} | {
+  type: 'login:cancel';
+  name: string;
+} | {
+  type: 'logout';
+  name: string;
+} | {
+  type: 'reset';
+  name: string;
+};
+/**
+ * Apply one event to the state map. Pure, immutable — returns a new map
+ * with only the affected key reassigned.
+ *
+ * State transitions are simple "last write wins"; we don't gate (e.g.) a
+ * `login:start` from overriding `authorizing` because the loop layer
+ * never doubles those up — interactive login is serialized in the TUI.
+ */
+declare function reduceMcpAuth(state: McpAuthStateMap, event: McpAuthEvent): McpAuthStateMap;
+/** Convenience getter — treats `undefined` as `idle`. */
+declare function getMcpAuthStatus(state: McpAuthStateMap, name: string): McpAuthStatus;
+//#endregion
+//#region src/chat/mcp-auth-context.d.ts
+/**
+ * Mount once near the top of the React tree (above `ModalRoot`). Children
+ * use `useMcpAuthState()` to read and `useMcpAuthDispatch()` to fire events.
+ */
+declare function McpAuthProvider({
+  children
+}: {
+  children: ReactNode;
+}): _$react_jsx_runtime0.JSX.Element;
+declare function useMcpAuthState(): McpAuthStateMap;
+declare function useMcpAuthDispatch(): (event: McpAuthEvent) => void;
+//#endregion
+//#region src/chat/mcp-credentials.d.ts
+declare function mcpCredentialsPath(dataDir: string): string;
+/**
+ * Build a file-backed `McpCredentialStore`. All per-server reads / writes
+ * funnel through the single `mcp-credentials.json` file — this keeps
+ * concurrent flows for different servers from clobbering each other since
+ * each save reads-modifies-writes the full file atomically.
+ *
+ * Two flows for the same server name CAN race (last write wins). MCP OAuth
+ * flows are user-driven and serial in practice (one login modal at a time),
+ * so this is acceptable; a per-server file split + cross-process lock would
+ * be required to handle a multi-process scenario.
+ */
+declare function createFileMcpCredentialStore(dataDir: string): McpCredentialStore;
+/**
+ * Convenience patches for individual sub-fields. The provider class uses
+ * these so a `saveTokens` call doesn't have to round-trip `clientInformation`
+ * + `discoveryState` it never touched.
+ */
+declare function patchMcpCredential(store: McpCredentialStore, name: string, patch: Partial<McpCredentialEntry>): void;
+//#endregion
 //#region src/chat/model-catalog.d.ts
 /** A model entry as displayed in the cross-provider picker. */
 interface CatalogEntry {
@@ -298,6 +738,77 @@ interface OAuthFlowOptions {
  */
 declare function runOAuthLogin(descriptor: ProviderDescriptor, options: OAuthFlowOptions): Promise<OAuthCredentials>;
 //#endregion
+//#region src/chat/project-root.d.ts
+/**
+ * Git root detection — walks parents from `cwd` looking for a `.git`
+ * entry, returning the absolute path of the repo root or `null` when
+ * the search reaches the filesystem root.
+ *
+ * Why parent-walk over `git rev-parse --show-toplevel`:
+ *
+ *   - Zero dependencies (no shell-out, no git binary requirement,
+ *     works even when `git` is missing from `PATH`).
+ *   - Pure-sync, deterministic, easy to test against tmp dirs.
+ *   - Equally fast in practice — most lookups are a single `existsSync`.
+ *
+ * Recognizes `.git` as either:
+ *
+ *   - A directory (standard repo layout).
+ *   - A file containing `gitdir: …` (worktrees + submodules).
+ *
+ * Bare repos (no working tree) are intentionally NOT detected here —
+ * the TUI's data dir contract is "project working tree", and a bare
+ * repo has no working files to scope sessions against.
+ */
+/**
+ * Walk parents of `cwd` looking for a `.git` entry. Returns the
+ * absolute path of the directory containing `.git`, or `null` when no
+ * git repo is found above `cwd`.
+ *
+ * Stops at the filesystem root (`/`) — no infinite loop on `dirname`'s
+ * idempotent root case (`dirname('/')` returns `/`).
+ */
+declare function findGitRoot(cwd?: string): string | null;
+//#endregion
+//#region src/chat/project-user-paths.d.ts
+/**
+ * Shared search-path builder for project + user config discovery.
+ *
+ * Both Skills (`skills/<name>/SKILL.md`) and MCP servers (`mcps.json`)
+ * follow the same first-found-wins order:
+ *
+ *   1. `{project-root}/.agents/<sub>`   — project, agnostic convention
+ *   2. `{project-root}/.{prefix}/<sub>` — project, zidane (`.zidane` default)
+ *   3. `~/.agents/<sub>`                — user, agnostic
+ *   4. `~/.{prefix}/<sub>`              — user, zidane
+ *
+ * `{project-root}` is the git root walked up from `cwd` when present,
+ * else `cwd` itself. This pairs with the project-scoped session
+ * storage (`resolveStoragePaths`) so all three project-aware surfaces
+ * — sessions, mcps, skills — anchor at the same `.{prefix}/`.
+ *
+ * Centralizing the pattern keeps the four paths in one place — a third
+ * discovery surface (hooks, rules, …) gets the same convention for free
+ * and stays in lock-step on a prefix bump.
+ */
+/** A discovered path tagged with whether it lives in the project or the user dir. */
+interface ProjectUserPath {
+  path: string;
+  source: 'project' | 'user';
+}
+/**
+ * Resolve the four search paths for a given subdirectory (`skills`,
+ * `mcps.json`, …). Returns absolute paths regardless of whether they
+ * exist — the caller chooses to `existsSync`-filter or feed straight
+ * into a tolerant discovery routine.
+ */
+declare function projectUserPaths(opts: {
+  /** Subdirectory or filename relative to each search root. E.g. `'skills'`, `'mcps.json'`. */subPath: string; /** Discovery cwd. Default: `process.cwd()`. */
+  cwd?: string; /** User home directory. Default: `os.homedir()`. */
+  home?: string; /** Storage prefix. Leading dot tolerated. Default: `'.zidane'`. */
+  prefix?: string;
+}): ProjectUserPath[];
+//#endregion
 //#region src/chat/safe-mode.d.ts
 /**
  * Safe-mode storage + matching for the TUI.
@@ -339,8 +850,16 @@ declare function addToSafelist(dataDir: string, projectDir: string, entry: strin
 /** Read the safelist for one project. Returns `[]` for unknown projects. */
 declare function getSafelist(dataDir: string, projectDir: string): readonly string[];
 /**
- * Tools that always pass without prompting — pure file/dir reads with no
- * side effects. Users who want to gate them must disable safe-mode entirely
+ * Tools that always pass without prompting. Two categories:
+ *
+ *   - **Pure reads** (`read_file`, `list_files`, `glob`, `grep`) — no
+ *     side effects on disk or the model's own state.
+ *   - **Interaction tools** (`ask_user`, `present_plan`) — the call
+ *     itself surfaces a TUI picker the user has to answer, so prompting
+ *     for approval first would mean "approve this prompt before you see
+ *     the prompt": redundant + breaks the flow. The picker IS the gate.
+ *
+ * Users who want to gate any of these must disable safe-mode entirely
  * (or fork this list in their own embedding).
  */
 declare const IMPLICITLY_SAFE_TOOLS: readonly string[];
@@ -374,80 +893,6 @@ declare function isOnSafelist(entries: readonly string[], tool: string, input: R
  */
 declare function suggestSafelistEntry(tool: string, input: Record<string, unknown>): string;
 //#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/settings-context.d.ts
 declare const DEFAULT_SETTINGS: Settings;
 interface SettingsContextValue {
@@ -688,5 +1133,5 @@ declare function countNeighbors(turnIds: readonly string[], turnId: string): {
   after: number;
 } | null;
 //#endregion
-export { type ActiveTrigger, type AgentAccent, type AgentProfile, type AgentRegistry, type ApiKeyCredential, type ApprovalDecision, type ApprovalRequest, type AuthMethod, BUILD_AGENT, BUILTIN_AGENTS, BUILTIN_PROVIDERS, BUILTIN_THEMES, type BooleanSettingKey, CATPPUCCIN_FRAPPE, CATPPUCCIN_LATTE, CATPPUCCIN_MACCHIATO, CATPPUCCIN_MOCHA, type CatalogEntry, type ChatOptions, type ChipColor, type ChipColorMap, type CompletionContext, type CompletionItem, type CompletionProvider, type CompletionReference, type CompletionState, ConfigProvider, type CredentialsFile, DEFAULT_AGENT_ID, DEFAULT_SETTINGS, DEFAULT_THEME, type DiscoveredMcp, type EnabledAllowlistKey, type EnabledToggleSet, FILES_TRIGGER, type FileEntry, type GenerateSessionTitleOptions, IMPLICITLY_SAFE_TOOLS, type ListProjectFilesOptions, type ModelInfo, type OAuthCredential, type OAuthFlowOptions, type Owner, PLAN_AGENT, type Picked, type ProjectEntry, type ProjectsFile, type PromptSegment, type PromptSegmentRef, type ProviderAuth, type ProviderCredential, type ProviderDescriptor, type ProviderKey, type ProviderRegistry, type RequestApproval, type ResolvedConfig, SETTINGS_CHOICES, SETTINGS_TOGGLES, SKILLS_TRIGGER, type SafeModeActions, SafeModeProvider, type Screen, type SessionExportAnchor, type SessionExportFormat, type SessionExportTarget, type SessionMeta, type Settings, type SettingsChoice, SettingsProvider, type SettingsToggle, type StateStoreApi, type StreamBuffer, type StreamEvent, type StreamSource, type SyntaxStyles, type SyntaxTokenStyle, type Theme, type ThemeColors, ThemeProvider, type ThemeSelect, type ThemeSurfaces, type TuiState, VAPORWAVE_THEME, addToSafelist, ageString, anthropicDescriptor, applyApiKeyEnv, applyInsert, buildMcpServers, buildModelCatalog, buildSkillsConfig, cerebrasDescriptor, cleanTitle, collectReferences, countNeighbors, createFilesCompletionProvider, createSkillsCompletionProvider, createStateStore, credKeyOf, credentialsPath, defaultMcpsConfigPaths, defaultSkillScanPaths, deleteTurnSafely, deriveSessionTitle, detectAuth, discoverProjectMcps, discoverProjectSkills, eventsFromTurns, filterModelCatalog, finalizeStreamingMarkdown, finalizeStreamingMarkdownForOwner, findActiveTrigger, fmtTokens, generateSessionTitle, getContextWindow, getModelInfo, getSafelist, indexOfEntry, isOnSafelist, lastContextSizeFromTurns, listProjectFiles, listSessionMeta, loadState, matchesSafelistEntry, mergeReferences, modelSupportsReasoning, modelsForDescriptor, openaiDescriptor, openrouterDescriptor, parseMcpsFile, piIdOf, projectsFilePath, readCredentials, readProjects, readProviderCredential, removeProviderCredential, renderSession, resolveAgentId, resolveChipColor, resolveConfig, resolveSessionExportTarget, resolveTheme, runOAuthLogin, saveState, selectableTurnIds, setProviderCredential, shortId, singleAgentRegistry, splitPromptSegments, stripSpawnTokensLine, suggestSafelistEntry, supportsOAuth, titleFromTurns, toolCallPreview, toolResultText, truncateTurnsAt, turnAsText, turnContextSize, uniqueFilesFromReferences, uniqueSkillNamesFromReferences, useColors, useCompletion, useConfig, useEnabledToggleSet, useSafeModeActions, useSafeModeQueue, useSelectStyle, useSettings, useStreamBuffer, useSurfaces, useSyntaxStyles, useTheme, writeCredentials, writeProjects, writeSessionExport };
+export { ACTIONS_WITH_CARE_DOCTRINE, ASK_USER_TOOL, type ActiveTrigger, type AgentAccent, type AgentProfile, type AgentRegistry, type AnswerValue, type ApiKeyCredential, type ApprovalDecision, type ApprovalRequest, type AuthMethod, type AutoCompactDecision, type AutoCompactInput, BUILD_AGENT, BUILTIN_AGENTS, BUILTIN_PROVIDERS, BUILTIN_THEMES, type BooleanSettingKey, type BuildSystemOptions, CATPPUCCIN_FRAPPE, CATPPUCCIN_LATTE, CATPPUCCIN_MACCHIATO, CATPPUCCIN_MOCHA, COMMUNICATION_DOCTRINE, type CatalogEntry, type ChatOptions, type ChipColor, type ChipColorMap, type CompletionContext, type CompletionItem, type CompletionProvider, type CompletionReference, type CompletionState, ConfigProvider, type ConfirmQuestion, type CreateInteractionToolsOptions, type CredentialsFile, DEFAULT_AGENT_ID, DEFAULT_KEYBINDINGS, DEFAULT_PERSIST_EXCLUDE_TOOLS, DEFAULT_SETTINGS, DEFAULT_THEME, DOING_TASKS_DOCTRINE, type DiffLine, type DiffOp, type DiscoveredMcp, type DiscoveryError, type DiscoveryResult, type EditHunk, type EditPayload, type EnabledAllowlistKey, type EnabledToggleSet, type EnvSectionOptions, FILES_TRIGGER, type FileEntry, type GenerateSessionTitleOptions, IDENTITY_PREFIX, IMPLICITLY_SAFE_TOOLS, INTERACTION_GUIDANCE, type InlineDiff, type InlineSegment, type InteractionRequest, type InteractionResponse, type InteractionsActions, InteractionsProvider, KEYBINDING_DEFS, KEYBINDING_DEF_BY_ACTION, type KeyAction, type KeyBindingDef, type KeyBindings, type ListProjectFilesOptions, type McpAuthEvent, McpAuthProvider, type McpAuthStateMap, type McpAuthStatus, type ModelInfo, type OAuthCredential, type OAuthFlowOptions, OUTPUT_RESERVE_TOKENS, type Owner, PLAN_AGENT, PLAN_MODE_DOCTRINE, PRESENT_PLAN_TOOL, type ParsedBinding, type PendingInteractionEntry, type Picked, type PlanDecision, type PlanPayload, type PlanRequest, type PlanResponse, type PlanStep, type ProjectEntry, type ProjectUserPath, type ProjectsFile, type PromptSegment, type PromptSegmentRef, type ProviderAuth, type ProviderCredential, type ProviderDescriptor, type ProviderKey, type ProviderRegistry, type Question, type QuestionChoice, type QuestionPayload, type QuestionRequest, type QuestionResponse, type QuestionType, type RequestApproval, type ResolvedConfig, SETTINGS_CHOICES, SETTINGS_TOGGLES, SKILLS_TRIGGER, SUBAGENT_GUIDANCE, type SafeModeActions, SafeModeProvider, type Screen, type SelectQuestion, type SessionExportAnchor, type SessionExportFormat, type SessionExportTarget, type SessionMeta, type Settings, type SettingsChoice, SettingsProvider, type SettingsToggle, type StateStoreApi, type StreamBuffer, type StreamEvent, type StreamSource, type SyntaxStyles, type SyntaxTokenStyle, TOKEN_DISCIPLINE_DOCTRINE, TOOL_DISPLAY, type TextQuestion, type Theme, type ThemeColors, ThemeProvider, type ThemeSelect, type ThemeSurfaces, type ToolCallDisplay, type ToolDisplayMeta, type ToolFormatLine, type TuiState, VAPORWAVE_THEME, accentColor, addToSafelist, ageString, anthropicDescriptor, applyApiKeyEnv, applyInsert, buildBuildSystem, buildMcpServers, buildModelCatalog, buildPlanSystem, buildResumedToolResultsTurn, buildSkillsConfig, buildUnifiedDiff, cerebrasDescriptor, cleanTitle, collectReferences, compactPath, computeInlineDiff, computeLineDiff, countNeighbors, createFileMcpCredentialStore, createFilesCompletionProvider, createInteractionTools, createSkillsCompletionProvider, createStateStore, credKeyOf, credentialsPath, defaultMcpsConfigPaths, defaultSkillScanPaths, deleteTurnSafely, deriveSessionTitle, detectAuth, discoverProjectMcps, discoverProjectSkills, displayNameFor, effectiveContextWindow, ensureKeybindingsFile, envSection, eventsFromTurns, extractEditPayload, filetypeFromPath, filterModelCatalog, finalizeStreamingMarkdown, finalizeStreamingMarkdownForOwner, findActiveTrigger, findGitRoot, fmtTokens, formatToolCall, generateSessionTitle, getContextWindow, getMcpAuthStatus, getModelInfo, getSafelist, indexOfEntry, isEditErrorResult, isInteractionTool, isOnSafelist, isTurnHighlighted, isVisible, keybindingsPath, lastContextSizeFromTurns, listProjectFiles, listSessionMeta, loadState, makeRequestInteraction, marginTopFor, matchesBinding, matchesSafelistEntry, mcpCredentialsPath, mergeKeybindings, mergeReferences, modelSupportsReasoning, modelsForDescriptor, openaiDescriptor, openrouterDescriptor, parseBindingSpec, parseMcpsFile, patchMcpCredential, pendingInteractionsFromTurns, piIdOf, projectUserPaths, projectsFilePath, readCredentials, readKeybindings, readProjects, readProviderCredential, reduceMcpAuth, removeProviderCredential, renderSession, resolveAgentId, resolveChipColor, resolveConfig, resolveSessionExportTarget, resolveTheme, runOAuthLogin, saveState, selectableTurnIds, serializeInteractionResponse, setProviderCredential, shortId, shouldAutoCompact, singleAgentRegistry, splitLines, splitPromptSegments, stripJsonComments, stripSpawnTokensLine, suggestSafelistEntry, supportsOAuth, titleFromTurns, tokenize, toolCallPreview, toolResultText, truncateTurnsAt, tryOpenBrowser, turnAsText, turnContextSize, turnSelectionOwnership, uniqueFilesFromReferences, uniqueSkillNamesFromReferences, useColors, useCompletion, useConfig, useEnabledToggleSet, useInteractionsActions, useInteractionsQueue, useMcpAuthDispatch, useMcpAuthState, useSafeModeActions, useSafeModeQueue, useSelectStyle, useSettings, useStreamBuffer, useSurfaces, useSyntaxStyles, useTheme, writeCredentials, writeProjects, writeSessionExport };
 //# sourceMappingURL=chat.d.ts.map