zidane 8.2.3 → 8.2.4

package/dist/{index-DyQyDLX1.d.ts → index-4mDRyTGJ.d.ts}

@@ -43,8 +43,8 @@
  * `/// <reference types="zidane" />` or an `import type { ExtensionContext } from 'zidane'`
  * (type-only imports don't need a runtime resolution) to recover it.
  */
-import { C as TaskExitInfo, g as ExecutionHandle, h as ExecutionContext, m as ExecResult, n as IsolationPolicy, v as ListFilesEntry, y as ListFilesOptions } from "./isolation-CbGNAEhQ.js";
 import { m as RunErrorDetail, u as ClassifiedError } from "./timeout-BcfGsZZG.js";
+import { C as TaskExitInfo, g as ExecutionHandle, h as ExecutionContext, m as ExecResult, n as IsolationPolicy, v as ListFilesEntry, y as ListFilesOptions } from "./isolation-CbGNAEhQ.js";
 import { a as getOAuthApiKey, n as OAuthCallbackPageRenderer, r as OAuthProviderInterface } from "./oauth-callback-page-B3Xo3X2J.js";
 import { Hookable } from "hookable";
 import { AssistantMessage, AssistantMessageEventStream, Message, Model, SimpleStreamOptions, TranscriptContext } from "@earendil-works/pi-ai";
@@ -76,1870 +76,1883 @@ interface ProviderDiagnostic {
   retryAfter?: string;
 }
 //#endregion
-//#region src/providers/model-catalog.d.ts
-/**
- * Model catalog override — the one seam for replacing model metadata.
- *
- * zidane resolves model metadata (output ceiling, pricing, context window,
- * reasoning support) from pi-ai's bundled registry. That registry is a
- * snapshot: it can't know a gateway alias, a private deployment, a model
- * released after our dependency pin, or a non-Anthropic model served over the
- * Anthropic wire. Without a seam, consumers either patch our source (the
- * `EXTRA_COST_RATES` table in `cost.ts` exists because of exactly that) or
- * mutate pi-ai's unfrozen catalog behind our back.
- *
- * Two ways to supply one, both first-class:
- *
- *   - `behavior.modelCatalog` — per agent, and per run like every other
- *     behavior field. No process-wide state, so two agents can carry
- *     different catalogs.
- *   - {@link setModelCatalog} — process-wide default. Also the only source
- *     the chat/TUI layer can see (the model picker resolves metadata before
- *     any agent exists).
- *
- * Resolution, first hit wins: run behavior → agent behavior → global →
- * pi-ai's bundled registry → local fallback tables.
- *
- * Everything stays keyed by `(provider, modelId)`: nothing is flattened
- * across providers, and overriding one provider leaves the others fully
- * bundled. The provider key is the pi-ai registry id, which is usually the
- * factory name (`anthropic`, `cerebras`, `openrouter`, …) — with one
- * exception: the Codex provider stores model records under `openai-codex` and
- * prices them under `openai`, and accepts an entry keyed EITHER way — on the
- * wire via {@link aliasCatalogProviders} and in the host layer via the
- * descriptor's key set, so an override can't half-apply.
- *
- * Two operational notes:
- *
- *   - **Serialization.** The table form is plain JSON; the `{ get, list }`
- *     form holds functions. A durable / replay runtime that snapshots
- *     `behavior` can only round-trip the table form — build the source form
- *     inside the process that runs the agent, or install it with
- *     {@link setModelCatalog} at boot.
- *   - **Multi-tenancy.** {@link setModelCatalog} is process-wide, so in a
- *     shared server it applies to every tenant. Pass `behavior.modelCatalog`
- *     per agent / per run instead; the global is for a deployment-wide
- *     correction and for the host's model picker.
- */
-/**
- * Size class of a model within its provider's lineup. Drives the automatic
- * text model (titles, suggestions): the smallest current model of the
- * session's provider. Bundled models get it from a family heuristic
- * (`src/chat/text-model.ts`); a catalog entry's value wins over it.
- */
-type ModelTier = 'small' | 'medium' | 'large';
+//#region src/session/artifacts.d.ts
+/** Built-in kinds. Open set — extensions add their own. */
+declare const ARTIFACT_KINDS: {
+  readonly pullRequest: "pull_request";
+  readonly branch: "branch";
+  readonly commit: "commit";
+  readonly file: "file";
+};
 /**
- * Metadata for one model. Every field is optional and merges FIELD-LEVEL over
- * the bundled entry, so `{ maxTokens: 128000 }` corrects the ceiling and
- * leaves pricing and context window to the registry.
+ * Reserved tool-result metadata namespace. Tools (and extension
+ * `detect` hooks) emit `metadata.artifacts = ArtifactInput[]` and the
+ * loop lifts each entry into the session's artifact store.
  */
-interface ModelCatalogEntry {
-  /** Model id. Required only for entries surfaced through {@link ModelCatalogSource.list}. */
-  id?: string;
-  /** Display name for pickers. */
-  name?: string;
-  /** Max output tokens — the provider's `max_tokens` default and hard clamp. */
-  maxTokens?: number;
-  /** Total context window, in tokens (drives the host-layer context gauge). */
-  contextWindow?: number;
-  /** Whether the model supports reasoning/thinking. */
-  reasoning?: boolean;
-  /** Accepted input modalities. */
-  input?: readonly ('text' | 'image')[];
+declare const ARTIFACTS_METADATA_KEY = "artifacts";
+/** Maximum size of an artifact `meta` value, in bytes of its JSON encoding. Larger values are dropped. */
+declare const ARTIFACT_META_MAX_BYTES = 16384;
+/** Maximum number of artifacts kept per session. Stores evict the oldest `file` artifacts first. */
+declare const ARTIFACTS_PER_SESSION_CAP = 200;
+/** A recorded output of a session, such as a pull request, a branch, a commit or a file. */
+interface SessionArtifact {
+  /** Stable id (uuid). Preserved across upserts of the same `(kind, uri)`. */
+  id: string;
+  /** Id of the session the artifact belongs to. */
+  sessionId: string;
   /**
-   * Per-MTok rates used for cost estimation. Merges PER-RATE over the bundled
-   * rates, so `{ cost: { output: 30 } }` corrects the output rate and keeps the
-   * registry's input / cache rates rather than zeroing them.
+   * Run that produced it. A `persist`-spawned subagent shares the parent
+   * session and records under its OWN run id (detection reaches it via the
+   * `child:tool:transform` bubble; see `presets/artifacts.ts`).
    */
-  cost?: {
-    input?: number;
-    output?: number;
-    cacheRead?: number;
-    cacheWrite?: number;
-  };
-  /** Size class; overrides the family heuristic. */
-  tier?: ModelTier;
-}
-/**
- * Programmatic catalog. Both members are optional and both fall through on
- * `undefined`, which is what keeps overrides scoped to the providers you
- * actually own.
- */
-interface ModelCatalogSource {
+  runId?: string;
+  /** Tool-result turn that produced it — the transcript anchor. */
+  turnId?: string;
+  /** Open kind string. Built-ins in {@link ARTIFACT_KINDS}. */
+  kind: string;
+  /** Canonical locator: PR URL, `git:<repo>#<branch>`, `file://<abs path>`, … */
+  uri: string;
+  /** Human line. Always present — the rendering fallback for unknown kinds. */
+  label: string;
   /**
-   * Resolve one model. Return `undefined` to fall through to the bundled
-   * entry for that `(provider, modelId)`.
+   * Project the artifact landed in, resolved at emission time from where
+   * the thing actually is (a worktree, a sibling repo), defaulting to the
+   * session's own `projectRoot`. Drives "everything produced from this
+   * repo" queries.
    */
-  get?: (provider: string, modelId: string) => ModelCatalogEntry | undefined;
+  projectRoot?: string;
+  /** Kind-specific payload, ≤ {@link ARTIFACT_META_MAX_BYTES}. */
+  meta?: JsonValue;
+  /** Creation time as epoch milliseconds. */
+  createdAt: number;
+  /** Last update time as epoch milliseconds. */
+  updatedAt: number;
+}
+/** What a producer hands to `session.addArtifact` / the metadata namespace. */
+interface SessionArtifactInput {
+  /** Open kind string. See `ARTIFACT_KINDS` for the built-in ones. */
+  kind: string;
+  /** Canonical locator of the artifact. */
+  uri: string;
+  /** Human-readable line shown for the artifact. */
+  label: string;
+  /** Project the artifact landed in. Default: the session project. */
+  projectRoot?: string;
+  /** Kind-specific payload, at most `ARTIFACT_META_MAX_BYTES`. */
+  meta?: JsonValue;
+}
+/** Filter for listing artifacts. Fields combine with AND. */
+interface ArtifactFilter {
+  /** Only artifacts of this session. */
+  sessionId?: string;
   /**
-   * Enumerate a provider's models (model pickers, `modelsForDescriptor`).
-   *
-   *   - `undefined` → use the bundled list for that provider (the default).
-   *   - `[…]`       → you own that provider's list; bundled entries are not
-   *                   consulted, so this both adds and hides.
-   *   - `[]`        → you own it and it has no models (hides the picker).
+   * Tri-state like `SessionStore.list`: string → that project only,
+   * `null` → artifacts with no project, omitted → axis ignored.
    */
-  list?: (provider: string) => readonly ModelCatalogEntry[] | undefined;
+  projectRoot?: string | null;
+  /** Only artifacts of this kind. */
+  kind?: string;
+  /** Exact locator match — reverse lookup ("who produced PR #123?"). Pair with `kind`. */
+  uri?: string;
+  /** Only artifacts with `updatedAt >= since`. */
+  since?: number;
+  /** Maximum number of artifacts to return. */
+  limit?: number;
 }
 /**
- * A catalog: either a {@link ModelCatalogSource} or the table shorthand —
- * a plain record keyed `"<provider>:<modelId>"`.
- *
- * The table form is a pure OVERLAY: entries patch or add models, and each
- * provider keeps every bundled model the table doesn't name. Hiding bundled
- * models requires the `list` function, so the easy path can't accidentally
- * blank a provider's picker.
- *
- * ```ts
- * setModelCatalog({ 'openai:gpt-5.6': { maxTokens: 128000 } })
- * ```
+ * Validate + normalize a raw input (typically from tool-result metadata,
+ * i.e. an untrusted boundary). Returns `null` when the entry is unusable
+ * — missing kind/uri/label or oversized in a way truncation can't fix.
+ * `label` is clipped, `meta` is dropped (not the artifact) when it exceeds
+ * the byte bound.
+ * @param raw - Untrusted value, typically from tool-result metadata.
  */
-type ModelCatalog = ModelCatalogSource | Readonly<Record<string, ModelCatalogEntry>>;
+declare function normalizeArtifactInput(raw: unknown): SessionArtifactInput | null;
 /**
- * Install (or clear, with `null`) the process-wide catalog. Latest call wins.
- *
- * Prefer `behavior.modelCatalog` when you can: it needs no global state and
- * scopes to one agent or one run. Use this for a deployment-wide correction,
- * or when the host's model picker must see the override too.
- *
- * @param catalog - Catalog to install, or `null` to clear it.
+ * Apply an upsert to an existing row: identity fields (`id`, `runId`,
+ * `turnId`, `createdAt`) stay, `label` refreshes, `meta` and `projectRoot`
+ * refresh when the incoming artifact has them, and `updatedAt` becomes the
+ * later of the two. Shared by every store so the
+ * merge semantics can't drift.
+ * @param existing - Stored artifact.
+ * @param incoming - Artifact being upserted.
  */
-declare function setModelCatalog(catalog: ModelCatalog | null): void;
-/** The process-wide catalog, normalized to source form. */
-declare function getModelCatalog(): ModelCatalogSource | undefined;
-//#endregion
-//#region src/thinking-levels.d.ts
+declare function mergeArtifact(existing: SessionArtifact, incoming: SessionArtifact): SessionArtifact;
 /**
- * Thinking / extended-reasoning configuration. Dependency-free, so the
- * browser-safe surfaces (`zidane/chat/pure`) can validate a stored effort.
- *
- * - `'off'` — no thinking.
- * - `'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max'` — explicit
- *   effort tier. Maps to provider-specific reasoning controls (Anthropic
- *   `output_config.effort`; OpenAI-compatible providers clamp to their
- *   supported tiers).
- * - `'adaptive'` — let the model decide per-turn whether and how much to think.
- *   Anthropic-only (`thinking.type='adaptive'`). Other providers fall back to
- *   no reasoning when this value is supplied.
+ * Which artifacts to evict so a session stays at or under `cap` after
+ * one more insert. `file` artifacts go first (noisiest, cheapest to
+ * regenerate), oldest first within a kind; ties keep the caller's order
+ * (stable sort), so pass rows in insertion order. Pure — callers delete
+ * the returned ids.
+ * @param current - Artifacts currently stored for the session, in insertion order.
+ * @param cap - Maximum number of artifacts per session.
  */
-declare const THINKING_LEVELS: readonly ["off", "minimal", "low", "medium", "high", "xhigh", "max", "adaptive"];
-/** One of the {@link THINKING_LEVELS} strings: how much the model reasons before it answers. */
-type ThinkingLevel = (typeof THINKING_LEVELS)[number];
+declare function selectArtifactEvictions(current: readonly SessionArtifact[], cap?: number): string[];
 /**
- * Type guard for canonical `ThinkingLevel` strings (e.g. `metadata.effort` read off a persisted session).
+ * Tests an artifact against a filter. An undefined filter matches everything. `limit` is not applied here.
  *
- * @param value - Any value, usually a string read from storage or settings.
+ * @param artifact - Artifact to test.
+ * @param filter - Filter to apply.
  */
-declare function isThinkingLevel(value: unknown): value is ThinkingLevel;
-//#endregion
-//#region src/mcp/transport.d.ts
+declare function matchesArtifactFilter(artifact: SessionArtifact, filter: ArtifactFilter | undefined): boolean;
 /**
- * Line-splitting core shared by the two stderr pumps: the Node-stream one
- * below (host stdio children) and the async-iterable one in
- * `./context-transport.ts` (children living in an execution context).
- * Same buffering, same overlong-line cap, same fire-and-forget `mcp:warn`.
- * @param serverName - Server name reported in each `mcp:warn` payload.
- * @param hooks - Agent hooks to fire `mcp:warn` on. Lines are dropped when `undefined`.
+ * Newest first, stable on id.
+ * @param artifacts - Artifacts to sort. The array is sorted in place.
  */
-declare function createStderrLineEmitter(serverName: string, hooks: Hookable<AgentHooks> | undefined): {
-  push: (text: string) => void;
-  flush: () => void;
-};
-/**
- * Reads a stdio child's stderr to the end and fires `mcp:warn` for each non-empty line. Does nothing when the transport has no stderr stream.
- *
- * @param transport - Transport that may expose a `stderr` stream.
- * @param serverName - Server name reported in each `mcp:warn` payload.
- * @param hooks - Agent hooks to fire `mcp:warn` on.
+declare function sortArtifacts(artifacts: SessionArtifact[]): SessionArtifact[];
+//#endregion
+//#region src/session/messages-pairing.d.ts
+/**
+ * Placeholder content inserted into a synthetic `tool_result` when the harness
+ * has to repair an orphan `tool_use`. Exported so downstream consumers
+ * (training-data collectors, HFI submission) can reject any payload containing
+ * it — the marker satisfies the wire-level pairing contract structurally but
+ * the content itself is fake and would poison fine-tuning data.
  */
-declare function attachStderrWarnPump(transport: {
-  stderr?: {
-    on: (event: string, listener: (...args: unknown[]) => void) => unknown;
-  } | null;
-}, serverName: string, hooks: Hookable<AgentHooks> | undefined): void;
+declare const SYNTHETIC_TOOL_RESULT_PLACEHOLDER = "[Tool result missing due to internal error]";
 /**
- * The execution context + live handle a `scope: 'context'` stdio server is
- * spawned into. Supplied by the agent once its handle exists; absent for
- * host-only setups, which is why every field is required here but the
- * binding itself is optional at the call site.
+ * Replacement text for an assistant message whose every content block was
+ * stripped during pairing repair (e.g. the only blocks were orphan
+ * `tool_call`s). Providers reject empty `content` arrays — the marker keeps
+ * the turn shape valid while signaling "this assistant turn lost its
+ * outputs" to the model so it can recover.
  */
-interface McpExecutionBinding {
-  /** Execution context that hosts the server process. */
-  context: ExecutionContext;
+declare const TOOL_USE_INTERRUPTED_MARKER = "[Tool use interrupted]";
+/**
+ * Replacement text for a user message whose every content block was a
+ * `tool_result` with no matching upstream `tool_call` (e.g. the assistant
+ * pair was stripped by an earlier compaction). Same role as
+ * {@link TOOL_USE_INTERRUPTED_MARKER} on the user side.
+ */
+declare const ORPHANED_TOOL_RESULT_MARKER = "[Orphaned tool result removed due to conversation resume]";
+/**
+ * Classification of a single repair the pairing pass performed. Surfaced via
+ * {@link EnsureToolResultPairingOptions.onRepair} so consumers can wire
+ * telemetry, debug logs, or strict-mode rejection without re-implementing the
+ * walk.
+ *
+ * Each entry corresponds to one of the corruption modes documented on
+ * {@link ensureToolResultPairing}.
+ */
+type PairingRepairMode = 'orphan-tool-use-prepend' | 'orphan-tool-use-append' | 'orphan-tool-result-strip' | 'duplicate-tool-use-strip' | 'duplicate-tool-result-strip' | 'empty-assistant-marker' | 'duplicate-tool-use-remint';
+/** One repair made by {@link ensureToolResultPairing}. */
+interface PairingRepair {
+  /** Which repair was performed. See {@link PairingRepairMode}. */
+  mode: PairingRepairMode;
+  /** Tool-use / tool-result id this repair concerns. Absent for empty-marker repairs. */
+  callId?: string;
+  /** Zero-based index into the INPUT `messages` array where the corruption was found. */
+  messageIndex: number;
+}
+/** Options for {@link ensureToolResultPairing}. */
+interface EnsureToolResultPairingOptions {
   /**
-   * Resolve the execution handle, invoked ONLY when a `scope: 'context'`
-   * stdio server actually builds its transport.
-   *
-   * Lazy on purpose. An eagerly-resolved handle would make merely *having* a
-   * context-scoped server in the config force a sandbox spawn — including
-   * for sub-agents, which inherit `mcpServers` but reuse the parent's live
-   * connection through `nonOwningMcpConnector` and never touch this binding.
-   * That would cold-boot a fresh sandbox per `spawn()` for nothing. Deferring
-   * also means the agent needs no ordering special case: the handle is
-   * created at the moment of first use, which is necessarily before the
-   * `execStream` call that needs it.
+   * Fired once per repair the pass performed. Synchronous so the loop can
+   * stay on its hot path. Throwing from the callback aborts the pass —
+   * consumers wanting fail-fast (strict mode) can re-throw with their own
+   * typed error.
    */
-  getHandle: () => Promise<ExecutionHandle>;
+  onRepair?: (repair: PairingRepair) => void;
 }
-//#endregion
-//#region src/mcp/origin-pinned-fetch.d.ts
 /**
- * The transport-reachability rule for a remote MCP endpoint: HTTPS anywhere,
- * plaintext HTTP only when it stays on the machine, nothing else.
+ * Defensive repair pass that rewrites a message list so it satisfies the
+ * wire-level `tool_use` ↔ `tool_result` adjacency contract every modern
+ * provider enforces.
  *
- * THE single encoding of that policy. It's enforced at two points on opposite
- * sides of the plugin boundary — once when validating a plugin's `mcp.json`
- * (`plugins/mcp.ts`), and again per redirect hop inside
- * {@link originPinnedFetch} — and those two must never disagree. If they did,
- * a URL the loader refused could still be reached by redirect, which is the
- * exact hole the pinning exists to close. Relaxing the rule (private ranges,
- * `*.localhost`, …) is then a one-line change that both sites inherit.
+ * Anthropic 400s on orphans with `'tool_use' ids were found without
+ * 'tool_result' blocks immediately after` (and its inverse, `tool_result
+ * must be preceded by a tool_call with the same toolCallId`). OpenAI's
+ * Chat Completions API rejects most mismatches with a 400 too.
  *
- * Scheme and host only. Authoring rules that apply to a CONFIGURED url but
- * have no meaning for a redirect target — no userinfo, no fragment — stay with
- * the loader.
- * @param url - Endpoint to check.
- */
-declare function isAllowedRemoteUrl(url: URL): boolean;
-/**
- * The fetch shape this wrapper supports — deliberately narrower than
- * `typeof fetch`, matching the MCP SDK's `FetchLike`.
+ * Six repair modes — modeled after Anthropic's Claude Code defenses:
  *
- * A `Request` input is NOT accepted: the wrapper rebuilds each hop from
- * `init`, so it would silently drop a Request's method, headers and body and
- * issue a bare credential-less GET. Narrowing the type makes that shape
- * unrepresentable rather than a quiet failure on a security-relevant helper.
- * Both SDK transports only ever pass a URL plus init.
- */
-type PinnedFetch = (url: string | URL, init?: RequestInit) => Promise<Response>;
-/**
- * Wrap `baseFetch` so `headerNames` are dropped on any hop that leaves the
- * origin of `configuredUrl`, and so a redirect cannot downgrade the session
- * to cleartext.
+ * | # | Corruption | Repair |
+ * |---|------------|--------|
+ * | 1 | assistant `tool_use` whose next user msg lacks a matching `tool_result` | **Prepend** a synthetic `tool_result` block carrying {@link SYNTHETIC_TOOL_RESULT_PLACEHOLDER} with `isError: true` |
+ * | 2 | assistant `tool_use` followed by nothing (or by a non-user msg) | **Insert** a new synthetic user message with the same placeholder |
+ * | 3 | user `tool_result` with no preceding assistant `tool_call` | **Strip** the orphan block; if it empties the msg, replace with {@link ORPHANED_TOOL_RESULT_MARKER} text block |
+ * | 4 | duplicate `tool_call.id` across assistant messages (CC-1212) | **Strip** later instances + their matching tool_results |
+ * | 5 | duplicate `tool_result.callId` within a single user message | **Dedupe** by `callId`, keep first |
+ * | 6 | assistant message emptied by mode-4 stripping | **Replace** content with {@link TOOL_USE_INTERRUPTED_MARKER} text block |
  *
- * `authorization` is ALWAYS protected, whether or not the caller listed it.
- * The MCP SDK's OAuth provider injects that header per request rather than
- * through `McpServerConfig.headers` — `bootstrapServer` attaches a provider to
- * a flagless server whenever stored tokens exist — so a strip list derived
- * only from the configured header names would leave the bearer token exposed
- * on exactly the servers that have one.
- * @param configuredUrl - Configured server URL. Its origin is the pinned origin.
- * @param headerNames - Configured header names to drop when a redirect leaves the pinned origin.
- * @param baseFetch - Fetch implementation to wrap. Default: the global `fetch`.
+ * **Repair, not drop.** Dropping orphan blocks would (a) silently rewrite
+ * history the model had reasoned over and (b) cascade — dropping an assistant
+ * tool_call would orphan its tool_result, which would then get dropped too,
+ * removing any trace of "what the model tried to do" from the transcript. This
+ * pass preserves the model's tool_use shape and patches the dangling result
+ * with an `is_error` placeholder so the model sees "I tried X, the result was
+ * lost" and can retry intelligently.
+ *
+ * Adjacency contract: `tool_result` blocks must live in the user message
+ * IMMEDIATELY following the assistant message that emitted the matching
+ * `tool_use`. The pass enforces strict adjacency — a tool_result two
+ * messages downstream of its tool_call is still an orphan.
+ *
+ * Idempotent: returns the input reference unchanged when no repairs were
+ * necessary. Re-running on already-repaired output is a no-op.
+ *
+ * Pure: does not mutate input messages or their content arrays — every
+ * repair allocates a fresh array / object.
+ * @param messages - Wire messages to repair. They are not modified.
+ * @param options - Repair callback. See {@link EnsureToolResultPairingOptions}.
  */
-declare function originPinnedFetch(configuredUrl: string, headerNames: readonly string[], baseFetch?: PinnedFetch): PinnedFetch;
-//#endregion
-//#region src/mcp/server-config.d.ts
+declare function ensureToolResultPairing(messages: SessionMessage[], options?: EnsureToolResultPairingOptions): SessionMessage[];
+/** Result of {@link remintDuplicateToolCallIds}. */
+interface RemintResult {
+  /** Tool calls with duplicate ids replaced. Same reference when unchanged. */
+  toolCalls: Array<{
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+  }>;
+  /** Assistant content with matching `tool_call` block ids rewritten. Same reference when unchanged. */
+  content: SessionContentBlock[];
+  /** One entry per re-minted occurrence, in emission order. */
+  reminted: Array<{
+    oldId: string;
+    newId: string;
+  }>;
+}
 /**
- * The config a transport is actually built from.
+ * Re-mint tool-call ids that collide with ids already present in the
+ * transcript (or with an earlier sibling in the same turn), BEFORE the turn
+ * is persisted and its tools dispatched.
  *
- * `${VAR}` placeholders resolve HERE, not at normalize time — see
- * {@link expandMcpConfigEnv} for why (config writers round-trip normalized
- * configs to disk; expanded secrets must never ride along).
+ * Why this exists: some providers/serving stacks emit non-globally-unique
+ * tool_use ids (per-turn counters like `call_0`, retry-replay duplicates,
+ * Kimi-K2.6 on Fireworks). The wire-time pairing pass
+ * ({@link ensureToolResultPairing}) can only STRIP such duplicates — which
+ * erases the model's tool calls and results from the wire view, stalls
+ * progress, and re-accumulates repairs quadratically because the persisted
+ * session keeps the corrupted ids. Re-minting at persist time keeps the
+ * pairing intact instead: the call, its execution, and its tool_result all
+ * carry the fresh id, so the pairing pass has nothing to strip on any later
+ * turn.
  *
- * A `preExpanded` config skips the pass entirely. The Agent Plugins loader
- * has already substituted the only two placeholders that spec permits, in
- * only the three fields it permits, so a second pass would both widen the
- * scope (into `command` / `url` / `headers`) and let an ambient
- * `PLUGIN_ROOT` env var reach text the spec says stays literal. See
- * {@link McpServerConfig.preExpanded}.
- * @param config - Normalized server config.
+ * Fresh ids are `${oldId}_r{n}` with `n` bumped until unique — deterministic
+ * shape, Anthropic-wire-safe charset (given a safe input id), and visibly
+ * traceable back to the original.
+ *
+ * Alignment contract: `toolCalls` and the `tool_call` blocks inside
+ * `content` are two views of the same emission and MUST be in the same
+ * order (true for every provider — both are built from one source array).
+ * Occurrences are matched positionally per old id so intra-turn duplicates
+ * map to distinct fresh ids on both views.
+ *
+ * Pure: returns the input references unchanged when no id collides.
+ * @param toolCalls - Tool calls of the new assistant turn.
+ * @param content - Content blocks of the same turn, with `tool_call` blocks in the same order as `toolCalls`.
+ * @param priorIds - Tool call ids already in the transcript.
  */
-declare function resolveTransportConfig(config: McpServerConfig): McpServerConfig;
+declare function remintDuplicateToolCallIds(toolCalls: ReadonlyArray<{
+  id: string;
+  name: string;
+  input: Record<string, unknown>;
+}>, content: readonly SessionContentBlock[], priorIds: ReadonlySet<string>): RemintResult;
 /**
- * Expand environment-variable placeholders in one config string. The
- * `:-default` form follows shell semantics — the default substitutes when
- * the variable is unset OR EMPTY (that's what `:-` means in every shell,
- * and what users pasting the form expect; empty-but-set without a default
- * still expands to the empty string, as `${VAR}` does in a shell). An
- * unset variable without a default is left VERBATIM (matching Claude
- * Code) — a literal `${…}` failing loudly at the server beats an empty
- * token failing mysteriously — and a debug-gated warning names the
- * missing variable.
- * @param value - String that may contain `${VAR}`, `${VAR:-default}` or `${env:VAR}`.
- * @param env - Variables to resolve against. Default: `process.env`.
+ * Classification of a single deletion {@link dropInvalidToolPairings}
+ * performed. Surfaced via `onDrop` for telemetry.
  */
-declare function expandEnvPlaceholders(value: string, env?: Record<string, string | undefined>): string;
+type PairingDropKind = 'duplicate-tool-call' | 'duplicate-tool-result' | 'orphan-tool-result' | 'empty-turn';
+/** One deletion made by {@link dropInvalidToolPairings}. */
+interface PairingDrop {
+  /** What was dropped. See {@link PairingDropKind}. */
+  kind: PairingDropKind;
+  /** Tool-call / tool-result id the drop concerns. Absent for empty-turn drops. */
+  callId?: string;
+  /** Zero-based index into the INPUT `turns` array. */
+  index: number;
+}
 /**
- * Expanded COPY of a server config for runtime use — `${VAR}` placeholders
- * resolved across every string field that can carry secrets or
- * machine-specific paths (command, args, env/header values, url, cwd).
+ * Drop-only normalization of persisted history: delete structurally invalid
+ * tool blocks so the transcript never re-triggers wire-time pairing repairs
+ * turn after turn.
  *
- * Deliberately NOT part of `normalizeMcpServers`: normalized configs are
- * round-tripped back to disk by config writers (e.g. the Claude import
- * copies parsed entries into zidane-owned `mcps.json`), and expanding
- * there would MATERIALIZE resolved tokens into files. Expansion happens
- * only at the transport boundary ({@link createTransport}, the login
- * flow's mirror) — secrets exist in the connecting process's memory and
- * nowhere else.
- * @param config - Server config to expand.
- * @param env - Variables to resolve against. Default: `process.env`.
+ * Unlike {@link ensureToolResultPairing} — which SYNTHESIZES placeholder
+ * content and must therefore stay wire-only (fabricated results would poison
+ * persisted history and training data) — this pass performs pure deletions of
+ * blocks that are provably invalid regardless of interpretation:
+ *
+ * | Corruption | Action |
+ * |------------|--------|
+ * | duplicate `tool_call` id within one run lane (across or within turns) | drop the later instance |
+ * | duplicate `tool_result.callId` within one turn | drop the later instance |
+ * | `tool_result` with no matching `tool_call` in the immediately preceding same-lane assistant turn | drop the block |
+ * | turn emptied by the drops above (reasoning-only remainders count as empty) | drop the whole turn |
+ *
+ * Duplicate detection is scoped to the WIRE-VIEW lane: tool_call ids only
+ * collide when both instances reach one model request. By default a turn's
+ * lane is its raw `runId` — correct for parent/subagent interleaving, where
+ * providers minting per-conversation counter ids (`call_0`, `call_1`)
+ * legitimately reuse the same id across lanes. Callers that know the run
+ * topology (see `createSession`) pass `laneForRun` to widen lanes to true
+ * wire views: all depth-0 runs share the main conversation view, and a
+ * resumed subagent shares its resume-chain ancestors' view — duplicates
+ * across those runIds DO reach a single request (wire-time
+ * `ensureToolResultPairing` mode 4 would strip them on every send) and are
+ * healed here.
+ *
+ * Orphan `tool_use` blocks (a call whose result was never persisted —
+ * interrupted run) are deliberately KEPT: they are authentic model output,
+ * and the wire-time pass patches them with a synthetic result on every send
+ * without touching history.
+ *
+ * Deletions cascade by design: dropping a duplicate `tool_call` orphans its
+ * `tool_result`, which is then dropped too; a turn emptied by either is
+ * removed entirely.
+ *
+ * Safe to persist: deterministic, idempotent (re-running on healed output is
+ * a no-op returning the same reference), and fabricates nothing.
+ *
+ * Pure: does not mutate input turns or their content arrays.
+ * @param turns - Persisted turns, oldest first. They are not modified.
+ * @param options - `onDrop` is called once per deletion. `laneForRun` maps a `runId` to its wire-view lane.
  */
-declare function expandMcpConfigEnv(config: McpServerConfig, env?: Record<string, string | undefined>): McpServerConfig;
+declare function dropInvalidToolPairings<T extends {
+  role: string;
+  content: SessionContentBlock[];
+  runId?: string;
+}>(turns: T[], options?: {
+  onDrop?: (drop: PairingDrop) => void;
+  /**
+   * Map a turn's `runId` to its wire-view lane. Turns whose lanes differ
+   * never share a model request, so their tool_call ids may legitimately
+   * collide. Defaults to the raw `runId` (undefined runIds share one
+   * lane) — the conservative choice when run topology is unknown.
+   */
+  laneForRun?: (runId: string | undefined) => string;
+}): T[];
+//#endregion
+//#region src/session/messages.d.ts
 /**
- * A config from a source that must never read this process's environment
- * (a machine's project file, `docs/MACHINES.md`): every `${VAR}` placeholder
- * resolved NOW to its `:-default`, else to the empty string, so the
- * transport's own expansion has nothing of this process's secrets to put
- * into a command, an env value, a URL or a header.
- * @param config - Server config to strip.
+ * Converts an Anthropic wire message into a {@link SessionMessage}.
+ *
+ * @param msg - Anthropic message with a string or block-array `content`.
  */
-declare function withoutEnvPlaceholders(config: McpServerConfig): McpServerConfig;
+declare function fromAnthropic(msg: {
+  role: string;
+  content: unknown;
+}): SessionMessage;
 /**
- * Unprivileged TCP port: the loopback listener can't bind below 1024 without root.
- * @param port - Value to check.
+ * Converts an OpenAI wire message into a {@link SessionMessage}.
+ *
+ * @param msg - OpenAI message with a string or part-array `content`.
  */
-declare function isValidCallbackPort(port: unknown): port is number;
+declare function fromOpenAI(msg: {
+  role: string;
+  content: unknown;
+}): SessionMessage;
+/** What a wire builder should do with a reasoning block for a given target. */
+type ReasoningWireAction = 'keep' | 'drop' | 'strip-signature';
 /**
- * The loopback redirect a pinned `oauth.callbackPort` produces: the URL to
- * register with the provider. Pass the same `callbackPath` given to
- * `loginMcpServer`, if any.
- * @param config - Server config. Only `oauth.callbackPort` is read.
- * @param callbackPath - Path of the callback URL.
- * @returns The redirect URL, or `undefined` when no callback port is pinned.
+ * Provider a history is sent to, as {@link reasoningWireAction} tells them
+ * apart. A Gemini-wire target is its signature scope, so an extension's
+ * `googleCompatible` route keeps only the signatures it minted.
  */
-declare function pinnedMcpRedirectUri(config: Pick<McpServerConfig, 'oauth'>, callbackPath?: string): string | undefined;
+type ReasoningWireTarget = 'anthropic' | 'openai' | GeminiSignatureScope;
 /**
- * Normalize MCP server configs from any common shape to `McpServerConfig[]`.
+ * Single source of truth for whether a signature-bearing reasoning block
+ * (`thinking` / `redacted_thinking`) may be forwarded to a provider. The
+ * wire builders ({@link toAnthropic}, the OpenAI and Google message shapers)
+ * and the host-facing {@link sanitizeHistoryForProvider} apply this same
+ * policy — keeping them one function means the sanitizer can never drift
+ * from what the wire actually sends.
  *
- * Accepts:
- * - `McpServerConfig[]` — zidane native (pass-through).
- * - `McpServerConfig` — a single config object (wrapped to a 1-element array).
- * - `Record<string, RawShape>` — name-keyed map (common in host-SDK configs), where the key is the server name.
- * - Mixed shapes with `type` vs `transport`, `httpUrl`/`sseUrl` vs `url`.
+ * Rules, each driven by an API constraint hit in production:
  *
- * Returns `[]` when `input` is nullish. Throws a descriptive error when the transport
- * cannot be inferred from a given entry, or when the input shape is unsupported.
- * @param input - Server configs in any of the accepted shapes, or nullish.
- */
-declare function normalizeMcpServers(input: unknown): McpServerConfig[];
-//#endregion
-//#region src/mcp/tool-meta.d.ts
-/**
- * Non-owning view of a live MCP connection: the SAME tools and
- * instructions, but a no-op `close`. Handed to consumers that must never
- * tear down transports they don't own — the loop's per-call
- * `ToolContext.mcpConnection` and child agents spawned off the parent's
- * connection — because only the owning agent's destroy path may close the
- * real thing, and a doc comment alone is too weak a guard. Single shared
- * builder so the call sites can't drift when this shape grows a field.
- * @param connection - Connection to view. Only its `tools` and `instructions` are read.
+ * - target `anthropic`:
+ *   - `redacted_thinking` → keep (native Anthropic block; must be echoed).
+ *   - `thinking` tagged `openai`, `google` or `google-vertex` → drop
+ *     (OpenAI `encrypted_content` and Gemini thought signatures are not
+ *     valid Anthropic HMACs; 400s).
+ *   - unsigned `thinking` → drop (`ThinkingBlockParam` requires a
+ *     signature; unsigned blocks come from non-signing producers).
+ *   - signed but UNTAGGED `thinking` (pre-tagging sessions) → keep: it is
+ *     most plausibly legacy Anthropic output, and the signature-400
+ *     recovery converges if it is not.
+ *
+ * - target `openai` or a Gemini-wire scope (`google`, `google-vertex`, a
+ *   `googleCompatible` route's):
+ *   - `redacted_thinking` → drop (Anthropic-only block type).
+ *   - `thinking` tagged `anthropic` → drop (an Anthropic HMAC is valid
+ *     nowhere else).
+ *   - `thinking` signed by any other producer, or signed but UNTAGGED →
+ *     strip-signature: there is no signature-error recovery on these paths,
+ *     so forwarding a possibly-foreign signature risks an unrecoverable
+ *     400. The reasoning text survives; only the opaque signature is
+ *     withheld. Gemini's are kept only for the route that issued them.
+ * @param block - A `thinking` or `redacted_thinking` block.
+ * @param target - Provider the history is sent to.
  */
-declare function nonOwningMcpView(connection: Pick<McpConnection, 'tools' | 'instructions'>): McpConnection;
+declare function reasoningWireAction(block: {
+  type: 'thinking';
+  signature?: string;
+  signatureProducer?: SignatureProducer;
+} | {
+  type: 'redacted_thinking';
+}, target: ReasoningWireTarget): ReasoningWireAction;
 /**
- * Recover a discovered tool's `{ server, toolName }` from its namespaced name
- * (`mcp_<server>_<tool>`). Both server and tool names can contain underscores,
- * so this matches against the known server list by longest server-name prefix
- * rather than splitting blindly. Tools that match no configured server (custom
- * connectors with a different naming scheme) fall back to
- * `{ server: '', toolName: <namespacedName> }`.
- * @param namespacedName - Tool name of the form `mcp_<server>_<tool>`.
- * @param servers - Configured servers to match the prefix against.
+ * Host-facing history sanitizer — applies {@link reasoningWireAction} to a
+ * turn set BEFORE it is handed to an agent targeting `target`. The in-loop
+ * wire builders already enforce the same policy per call, so this is for
+ * hosts that seed history from an external durable store (or hydrate
+ * pre-provenance-tagging sessions) and want the poison removed from their
+ * source of truth in one call instead of re-deriving block semantics.
+ *
+ * Returns new turn objects only where something changed (unchanged turns
+ * pass through by reference). A turn whose content empties keeps the same
+ * neutral marker the wire repair uses, so role boundaries stay intact.
+ * @param turns - Turns to sanitize.
+ * @param target - Provider the history is sent to.
  */
-declare function deriveMcpToolMeta(namespacedName: string, servers: readonly McpServerConfig[]): McpToolMeta;
+declare function sanitizeHistoryForProvider<T extends {
+  content: SessionContentBlock[];
+}>(turns: readonly T[], target: ReasoningWireTarget): {
+  turns: T[];
+  removed: number;
+  stripped: number;
+};
 /**
- * Apply an {@link McpToolWrap} to every entry of a discovered-tool map,
- * resolving each tool's {@link McpToolMeta} from `servers`. Returns a fresh
- * map; the input is untouched. Used by the agent to apply the
- * `AgentOptions.mcpToolWrap` hook to discovered tools.
- * @param tools - Discovered tools keyed by namespaced name.
- * @param wrap - Wrapper applied to each tool.
- * @param servers - Configured servers used to resolve each tool's metadata.
+ * Converts a {@link SessionMessage} into an Anthropic wire message. Foreign reasoning blocks are dropped following {@link reasoningWireAction}.
+ *
+ * @param msg - Message to convert.
  */
-declare function wrapDiscoveredMcpTools(tools: Record<string, ToolDef>, wrap: McpToolWrap, servers: readonly McpServerConfig[]): Record<string, ToolDef>;
-//#endregion
-//#region src/mcp/tool-result.d.ts
+declare function toAnthropic(msg: SessionMessage): {
+  role: string;
+  content: unknown;
+};
 /**
- * Lossy flattener — converts MCP `CallToolResult.content` blocks to a single
- * string. Text blocks are extracted; non-text blocks are JSON-stringified.
+ * Converts a {@link SessionMessage} into an OpenAI wire message.
  *
- * Use this only at UI / log boundaries that require a string. The agent
- * loop itself routes through {@link normalizeMcpBlocks} so image blocks
- * survive into provider-native tool_result content (Anthropic blocks,
- * OpenAI companion-user-message).
- * @param content - `CallToolResult.content` from an MCP tool call. Anything other than an array gives an empty string.
+ * @param msg - Message to convert.
  */
-declare function resultToString(content: unknown): string;
+declare function toOpenAI(msg: SessionMessage): {
+  role: string;
+  content: unknown;
+};
 /**
- * Normalize MCP `CallToolResult.content` to zidane's {@link ToolResultContent[]} shape.
+ * Drop ASSISTANT turns whose every `tool_call` block is unresolved
+ * (no matching `tool_result` block anywhere later in the transcript).
+ * Tool_call blocks with at least one matching tool_result are kept — modes
+ * 1/3 of {@link ensureToolResultPairing} handle the partial-pair case at
+ * wire-send time.
  *
- * Handles the MCP content block types:
- * - `text` → preserved as `{type:'text', text}`
- * - `image` → preserved as `{type:'image', mediaType, data}` (MCP uses `mimeType`)
- * - `audio` → `{type:'audio', mediaType, data}`; mediaType reconciled/sniffed when
- *   the declared `mimeType` is missing or not an `audio/*` type
- * - `video` → `{type:'video', mediaType, data}` (non-standard, by analogy)
- * - `resource` with embedded text → flattened to a text block
- * - `resource` with embedded blob → routed to image/audio/video by sniffing bytes
- *   first, with declared `mimeType` as a fallback when bytes are unidentifiable
- *   (it's OPTIONAL on EmbeddedResource per the MCP spec, and often imprecise)
- * - Any unrecognized block → JSON-stringified fallback text block (lossy but safe)
+ * Use case: session resume. A turn that emitted three `tool_use` blocks but
+ * never persisted the matching `tool_result` turn (process death, crash,
+ * `kill -9`) leaves the transcript with an orphan that Anthropic rejects on
+ * the FIRST API call after reload. Dropping the whole assistant turn — not
+ * just the orphan blocks — preserves text-only turns that legitimately
+ * carry reasoning the model wants to see again.
  *
- * Returns `null` when the input is not an array — callers should fall back to an empty
- * result in that case.
- * @param content - `CallToolResult.content` from an MCP tool call.
+ * Does NOT mint fresh ids: re-id'ing on every resume would cause
+ * exponential transcript growth across repeated resumes of an interrupted
+ * session.
+ *
+ * Pure: returns the input reference unchanged when no turn was dropped.
+ * @param turns - Turns of the session, oldest first.
  */
-declare function normalizeMcpBlocks(content: unknown): ToolResultContent[] | null;
-//#endregion
-//#region src/mcp/index.d.ts
-/** A live connection to a set of MCP servers: the discovered tools and a way to close every transport. */
-interface McpConnection {
-  /** Discovered tools keyed by namespaced name, `mcp_<server>_<tool>`. */
-  tools: Record<string, ToolDef>;
-  /**
-   * Per-server `instructions` payload from the MCP `initialize` handshake,
-   * keyed by server name. Each server may return free-form guidance the
-   * model is meant to read alongside the tool catalog — typical content
-   * is "the database is already provisioned, use `apply_migration`
-   * directly" or "always wrap SELECTs in a transaction". The agent
-   * renders these into a system-prompt section when
-   * `behavior.surfaceMcpInstructions` is on (default).
-   *
-   * Servers that omit the field, return an empty string, or fail to
-   * connect contribute no entry. Lazy-connected servers contribute an
-   * entry only once their first connect resolves — until then the model
-   * never sees their instructions, matching the schema-loading semantics
-   * of `lazyConnect`.
-   *
-   * Map (not Record) so insertion order matches server config order and
-   * the rendered section is byte-stable for the cache breakpoint.
-   *
-   * Optional so custom `mcpConnector` implementations may omit it; the
-   * framework's own `connectMcpServers` always returns a Map (possibly
-   * empty).
-   */
-  instructions?: Map<string, string>;
-  /** Closes every server connection. Servers that fail to close in time are force-stopped. */
-  close: () => Promise<void>;
-}
+declare function filterUnresolvedToolUses<T extends {
+  role: string;
+  content: SessionContentBlock[];
+}>(turns: T[]): T[];
 /**
- * Optional knobs threaded into per-server bootstrap. Reserved for runtime
- * concerns the agent shell injects (credential storage, OAuth providers);
- * the `McpServerConfig` shape stays pure data.
+ * Classification of a session's tail state for resume purposes.
+ *
+ * - `'clean'` — the trailing turn is a user message (the model would respond
+ *   next), or the transcript is empty. Safe to resume by appending a fresh
+ *   user prompt.
+ * - `'interrupted'` — the trailing turn is an assistant message that has at
+ *   least one `tool_call` block with no matching `tool_result` anywhere
+ *   later. The run was almost certainly killed between persisting the
+ *   assistant turn and persisting its tool-results turn. Hosts that want
+ *   Claude-Code-style auto-resume can detect this and inject a
+ *   `"Continue from where you left off."` user message before the next run.
+ * - `'completed'` — the trailing turn is an assistant message with no
+ *   orphan tool_calls. The model considers itself done. Hosts that want to
+ *   resume must supply a new prompt; auto-continuation here would be a
+ *   non-sequitur.
  */
-interface ConnectMcpServersOptions {
+type TurnInterruptionState = 'clean' | 'interrupted' | 'completed';
+/**
+ * Inspect a session's trailing turn to classify whether the run was
+ * interrupted mid-tool-call. Pure / synchronous — does not modify the input.
+ *
+ * Pair with {@link filterUnresolvedToolUses} on the resume path: filter
+ * first so the result reflects the post-cleanup state (a turn whose orphans
+ * were stripped reads as 'completed', not 'interrupted').
+ * @param turns - Turns of the session, oldest first.
+ */
+declare function detectTurnInterruption<T extends {
+  role: string;
+  content: SessionContentBlock[];
+}>(turns: T[]): TurnInterruptionState;
+/**
+ * Guarantee a message list ends with a `role: 'user'` message, appending a
+ * synthetic directive when it doesn't.
+ *
+ * Why: Anthropic's API (and several OpenAI-compat reasoning models — opus
+ * 4.7, the o-series translation layers on Bedrock/Vertex) rejects requests
+ * whose final message is `role: 'assistant'` with
+ * "This model does not support assistant message prefill. The conversation
+ * must end with a user message."
+ *
+ * Triggers in zidane:
+ *   - Compaction over a session whose last turn is the agent's response
+ *     (the common case — autocompact fires right after `agent.run()`).
+ *   - Schema enforcement after an assistant text turn (no `tool_use`, so
+ *     `ensureToolResultPairing` doesn't synthesize a user tail).
+ *   - `context:transform` hooks that strip the trailing user turn.
+ *
+ * The pair-repair pass {@link ensureToolResultPairing} already covers the
+ * orphan-`tool_use` case via mode 2; this helper closes the plain-text
+ * assistant-tail case. They compose: run pair-repair first, then this
+ * pass, so an assistant turn with orphan tool_uses gets its synthetic
+ * `tool_result` user turn AND this pass is a no-op (the synthetic turn
+ * is already user-role).
+ *
+ * Empty input passes through unchanged — the caller's "nothing to send"
+ * guard is responsible for that case; we don't materialize a conversation
+ * out of an empty list.
+ *
+ * Idempotent: returns the input reference unchanged when the list is
+ * already user-terminated (or empty).
+ *
+ * @param messages   Wire-ready message list.
+ * @param provider   Provider whose `userMessage()` shape we use so the
+ *                   synthetic turn matches the wire format the rest of
+ *                   the list already follows.
+ * @param directive  Text to put in the synthetic user message. Defaults
+ *                   to {@link DEFAULT_USER_TAIL_DIRECTIVE} ("Continue.").
+ *                   Compaction overrides this with a summary-specific cue.
+ */
+declare function ensureEndsWithUserMessage(messages: SessionMessage[], provider: Provider, directive?: string): SessionMessage[];
+/** Options for {@link toWireMessages}. */
+interface ToWireMessagesOptions {
   /**
-   * Execution context binding for servers declaring `scope: 'context'`.
-   * Safe to pass unconditionally: the binding is lazy, and its
-   * `getHandle()` is invoked only when a context-scoped stdio server
-   * actually builds its transport — host-only configs never touch it, so
-   * no spawn cost is paid for merely supplying it. Omitting it simply
-   * makes any `scope: 'context'` server fail bootstrap with a pointed
-   * error.
+   * Pairing-repair telemetry. Fires once per repair the underlying
+   * {@link ensureToolResultPairing} pass performs. Mirrors the
+   * `pairing:repair` hook surface so consumers can wire structured logging
+   * without an agent instance.
    */
-  execution?: McpExecutionBinding;
+  onRepair?: (repair: PairingRepair) => void;
   /**
-   * Build a non-interactive `OAuthClientProvider` for a given server. Called
-   * lazily — only invoked when the bootstrap actually needs auth (explicit
-   * `auth: 'oauth'` flag, or a UnauthorizedError that meets the auto-detect
-   * criteria). Return `undefined` to opt this server out of OAuth even if it
-   * was requested (e.g. the host doesn't have a credential store for it).
-   *
-   * "Non-interactive" — the provider must NOT trigger a browser flow during
-   * bootstrap. Use a `redirectUri` of `undefined` so the SDK reads stored
-   * tokens, refreshes on expiry, and throws `UnauthorizedError` if tokens
-   * are missing or refresh fails. The host then surfaces an
-   * `mcp:auth:required` event so the user can opt in to interactive login.
+   * When set, also runs {@link ensureEndsWithUserMessage} so the result is
+   * safe for assistant-prefill-rejecting models (opus 4.7, o-series
+   * translation layers). Omit to skip — pure pairing repair only.
    */
-  buildAuthProvider?: (config: McpServerConfig) => OAuthClientProvider | undefined;
+  provider?: Provider;
+  /**
+   * Override for the synthetic user-tail directive. Only consulted when
+   * `provider` is set. Defaults to {@link DEFAULT_USER_TAIL_DIRECTIVE}.
+   */
+  userTailDirective?: string;
+  /**
+   * Resolve persisted content references into provider-native payload bytes.
+   * The returned data is wire-only and must not be written back to turns.
+   */
+  resolveContentRef?: ResolveContentRef;
 }
 /**
- * Internal: shape received by the `_clientFactory` test-injection seam.
- * Mirrors the subset of `TolerantClientOptions` the bootstrap path forwards
- * so a mock client can opt into the same lifecycle wiring (warning sink,
- * future seams) instead of silently bypassing it.
+ * Build a wire-ready `SessionMessage[]` from raw persisted `SessionTurn[]`.
+ *
+ * **The canonical "I want to send these to a provider" projection.** Use
+ * this — not raw `session.turns` / `store.getTurns()` — when constructing a
+ * provider request outside `agent.run()`. The agent's own wire pipeline
+ * (`executeTurn` in `src/loop-turn.ts`) applies the same repair just-in-time;
+ * downstream consumers that bypass the loop hit `tool_result must be
+ * preceded by a tool_call` 400s precisely because they shipped raw turns.
+ *
+ * Pipeline:
+ *   1. Filter out turns that never reach the model (`system` and `command`
+ *      roles).
+ *   2. Resolve content refs with `options.resolveContentRef`.
+ *   3. {@link ensureToolResultPairing} — repairs all six orphan / dup
+ *      corruption modes: synthetic placeholders for orphan tool_use blocks
+ *      (preserves the model's tool_use shape), strips for duplicates and
+ *      orphan tool_results.
+ *   4. {@link ensureEndsWithUserMessage} when `options.provider` is set —
+ *      guards against assistant-tail prefill rejection (opus 4.7, o-series).
+ *
+ * Pure + idempotent. Does not mutate the input turns. Re-running on the
+ * output is a no-op.
+ *
+ * **Do not feed the result back into `session.setTurns` / `appendTurns`.**
+ * The repair can insert `SYNTHETIC_TOOL_RESULT_PLACEHOLDER` / `[Orphaned
+ * tool result removed …]` markers; round-tripping those into persisted
+ * state contaminates the session's reasoning history and defeats the
+ * "don't rewrite the past" invariant the wire-only repair was designed
+ * around.
+ * @param turns - Persisted turns, oldest first.
+ * @param options - Repair and tail options. See {@link ToWireMessagesOptions}.
  */
-interface McpClientFactoryOptions {
-  /** See `TolerantClientOptions.onWarning`. */
-  onWarning?: (message: string) => void;
+declare function toWireMessages(turns: readonly {
+  role: 'user' | 'assistant' | 'system' | 'command';
+  content: SessionContentBlock[];
+}[], options?: ToWireMessagesOptions): Promise<SessionMessage[]>;
+/**
+ * Converts a wire message of unknown provider into a {@link SessionMessage}. Block types decide between {@link fromAnthropic} and {@link fromOpenAI}. Anthropic is the default.
+ *
+ * @param msg - Anthropic or OpenAI wire message.
+ */
+declare function autoDetectAndConvert(msg: {
+  role: string;
+  content: unknown;
+}): SessionMessage;
+//#endregion
+//#region src/session/metadata-merge.d.ts
+/** Options for `SessionStore.saveMeta`. */
+interface SaveMetaOptions {
+  /**
+   * The metadata keys this writer changed. When set, the store merges only
+   * these keys into the metadata it already holds (an `undefined` value
+   * removes the key) instead of replacing the whole record, so a stale copy
+   * of the session can't write back keys another writer changed since.
+   * Omitted: the whole `metadata` record is written.
+   */
+  metaKeys?: readonly string[];
 }
-type McpClientFactory = (opts?: McpClientFactoryOptions) => Client;
 /**
- * Connect to MCP servers and discover their tools.
+ * The metadata a `saveMeta` should store: `incoming` wholesale without
+ * `keys`, otherwise `stored` with only `keys` taken from `incoming`.
  *
- * Each tool is namespaced as `mcp_{serverName}_{toolName}` to avoid
- * collisions with agent tools or tools from other servers.
+ * @param stored - Metadata the store holds now; when absent, `incoming` is stored as is.
+ * @param incoming - Metadata the writer sends.
+ * @param keys - Keys the writer changed (`SaveMetaOptions.metaKeys`); an `undefined` value in `incoming` removes the key.
+ */
+declare function mergeSessionMetadata(stored: SessionData['metadata'] | undefined, incoming: SessionData['metadata'], keys: readonly string[] | undefined): SessionData['metadata'];
+//#endregion
+//#region src/session/file-map.d.ts
+/**
+ * Host-provided file-map adapter. Three methods exchanging `Record<string, string>`
+ * payloads — the whole persistence surface the wrapper needs.
+ */
+interface FileMapAdapter {
+  /** Load the current file map. Returns an empty `files` record when nothing is persisted. */
+  get: () => Promise<{
+    files: Record<string, string>;
+  }>;
+  /** Replace the persisted file map. Full-rewrite semantics. */
+  save: (files: Record<string, string>) => Promise<void>;
+  /** Delete all persisted state. */
+  delete: () => Promise<void>;
+}
+/** Options for {@link createFileMapStore}. */
+interface FileMapStoreOptions {
+  /** Filename for the JSONL turns log. Default: `turns.jsonl`. */
+  turnsFile?: string;
+  /** Filename for the metadata JSON. Default: `meta.json`. */
+  metaFile?: string;
+}
+/**
+ * Create a single-session `SessionStore` backed by a file-map adapter.
  *
- * @param configs - Array of MCP server configurations
- * @param _clientFactory - Internal: override client construction for testing
- * @param hooks - Optional agent hooks for firing mcp:connect, mcp:error, mcp:close events
- * @param options - Optional bootstrap knobs (e.g. OAuth provider injection)
+ * @param adapter - Host adapter that loads, saves and deletes the file map.
+ * @param options - File names to use. See {@link FileMapStoreOptions}.
  * @example
  * ```ts
- * import { connectMcpServers } from 'zidane/mcp'
- *
- * const connection = await connectMcpServers([
- *   { name: 'fs', transport: 'stdio', command: 'npx', args: ['-y', '@modelcontextprotocol/server-filesystem', '.'] },
- * ])
- * console.log(Object.keys(connection.tools))
- * await connection.close()
+ * const session = await createSession({
+ *   store: createFileMapStore(hostSessionStore),
+ * })
  * ```
  */
-declare function connectMcpServers(configs: McpServerConfig[], _clientFactory?: McpClientFactory, hooks?: Hookable<AgentHooks>, options?: ConnectMcpServersOptions): Promise<McpConnection>;
+declare function createFileMapStore(adapter: FileMapAdapter, options?: FileMapStoreOptions): SessionStore;
 //#endregion
-//#region src/session/artifacts.d.ts
-/** Built-in kinds. Open set — extensions add their own. */
-declare const ARTIFACT_KINDS: {
-  readonly pullRequest: "pull_request";
-  readonly branch: "branch";
-  readonly commit: "commit";
-  readonly file: "file";
-};
+//#region src/session/memory.d.ts
 /**
- * Reserved tool-result metadata namespace. Tools (and extension
- * `detect` hooks) emit `metadata.artifacts = ArtifactInput[]` and the
- * loop lifts each entry into the session's artifact store.
+ * Creates an in-memory {@link SessionStore}. Nothing is persisted.
+ *
+ * @example
+ * ```ts
+ * import { createMemoryStore, createSession } from 'zidane/session'
+ *
+ * const session = await createSession({ store: createMemoryStore() })
+ * ```
  */
-declare const ARTIFACTS_METADATA_KEY = "artifacts";
-/** Maximum size of an artifact `meta` value, in bytes of its JSON encoding. Larger values are dropped. */
-declare const ARTIFACT_META_MAX_BYTES = 16384;
-/** Maximum number of artifacts kept per session. Stores evict the oldest `file` artifacts first. */
-declare const ARTIFACTS_PER_SESSION_CAP = 200;
-/** A recorded output of a session, such as a pull request, a branch, a commit or a file. */
-interface SessionArtifact {
-  /** Stable id (uuid). Preserved across upserts of the same `(kind, uri)`. */
-  id: string;
-  /** Id of the session the artifact belongs to. */
-  sessionId: string;
-  /**
-   * Run that produced it. A `persist`-spawned subagent shares the parent
-   * session and records under its OWN run id (detection reaches it via the
-   * `child:tool:transform` bubble; see `presets/artifacts.ts`).
-   */
-  runId?: string;
-  /** Tool-result turn that produced it — the transcript anchor. */
-  turnId?: string;
-  /** Open kind string. Built-ins in {@link ARTIFACT_KINDS}. */
-  kind: string;
-  /** Canonical locator: PR URL, `git:<repo>#<branch>`, `file://<abs path>`, … */
-  uri: string;
-  /** Human line. Always present — the rendering fallback for unknown kinds. */
-  label: string;
-  /**
-   * Project the artifact landed in, resolved at emission time from where
-   * the thing actually is (a worktree, a sibling repo), defaulting to the
-   * session's own `projectRoot`. Drives "everything produced from this
-   * repo" queries.
-   */
-  projectRoot?: string;
-  /** Kind-specific payload, ≤ {@link ARTIFACT_META_MAX_BYTES}. */
-  meta?: JsonValue;
-  /** Creation time as epoch milliseconds. */
-  createdAt: number;
-  /** Last update time as epoch milliseconds. */
-  updatedAt: number;
-}
-/** What a producer hands to `session.addArtifact` / the metadata namespace. */
-interface SessionArtifactInput {
-  /** Open kind string. See `ARTIFACT_KINDS` for the built-in ones. */
-  kind: string;
-  /** Canonical locator of the artifact. */
-  uri: string;
-  /** Human-readable line shown for the artifact. */
-  label: string;
-  /** Project the artifact landed in. Default: the session project. */
-  projectRoot?: string;
-  /** Kind-specific payload, at most `ARTIFACT_META_MAX_BYTES`. */
-  meta?: JsonValue;
-}
-/** Filter for listing artifacts. Fields combine with AND. */
-interface ArtifactFilter {
-  /** Only artifacts of this session. */
-  sessionId?: string;
-  /**
-   * Tri-state like `SessionStore.list`: string → that project only,
-   * `null` → artifacts with no project, omitted → axis ignored.
-   */
-  projectRoot?: string | null;
-  /** Only artifacts of this kind. */
-  kind?: string;
-  /** Exact locator match — reverse lookup ("who produced PR #123?"). Pair with `kind`. */
-  uri?: string;
-  /** Only artifacts with `updatedAt >= since`. */
-  since?: number;
-  /** Maximum number of artifacts to return. */
-  limit?: number;
+declare function createMemoryStore(): SessionStore;
+//#endregion
+//#region src/session/remote.d.ts
+/** Options for {@link createRemoteStore}. */
+interface RemoteStoreOptions {
+  /** Base URL of the session API */
+  url: string;
+  /** Optional headers (e.g. for authentication) */
+  headers?: Record<string, string>;
+  /** Per-request timeout in ms. Default 30s — bounds a hung backend. */
+  timeoutMs?: number;
 }
 /**
- * Validate + normalize a raw input (typically from tool-result metadata,
- * i.e. an untrusted boundary). Returns `null` when the entry is unusable
- * — missing kind/uri/label or oversized in a way truncation can't fix.
- * `label` is clipped, `meta` is dropped (not the artifact) when it exceeds
- * the byte bound.
- * @param raw - Untrusted value, typically from tool-result metadata.
+ * Creates a {@link SessionStore} that talks to a REST session API over HTTP. See the module comment for the endpoints it calls.
+ *
+ * @param options - API base URL, headers and timeout.
+ * @example
+ * ```ts
+ * import { createRemoteStore, createSession } from 'zidane/session'
+ *
+ * const store = createRemoteStore({ url: 'https://api.example.com', headers: { authorization: 'Bearer token' } })
+ * const session = await createSession({ store })
+ * ```
  */
-declare function normalizeArtifactInput(raw: unknown): SessionArtifactInput | null;
+declare function createRemoteStore(options: RemoteStoreOptions): SessionStore;
+//#endregion
+//#region src/session/index.d.ts
 /**
- * Apply an upsert to an existing row: identity fields (`id`, `runId`,
- * `turnId`, `createdAt`) stay, `label` refreshes, `meta` and `projectRoot`
- * refresh when the incoming artifact has them, and `updatedAt` becomes the
- * later of the two. Shared by every store so the
- * merge semantics can't drift.
- * @param existing - Stored artifact.
- * @param incoming - Artifact being upserted.
+ * Run `fn` with `session` bound as the active extension session for the
+ * duration of the call (and every async continuation it spawns). Uses
+ * `AsyncLocalStorage.run` rather than `enterWith` so concurrent agents in the
+ * same process (e.g. the GUI's multi-session host) never observe each other's
+ * session through `currentExtensionSession()`.
+ * @param session - Session to bind. When `undefined`, `fn` runs without a binding.
+ * @param fn - Function to run with the binding in place.
  */
-declare function mergeArtifact(existing: SessionArtifact, incoming: SessionArtifact): SessionArtifact;
+declare function withExtensionSession<T>(session: Session | undefined, fn: () => T): T;
 /**
- * Which artifacts to evict so a session stays at or under `cap` after
- * one more insert. `file` artifacts go first (noisiest, cheapest to
- * regenerate), oldest first within a kind; ties keep the caller's order
- * (stable sort), so pass rows in insertion order. Pure — callers delete
- * the returned ids.
- * @param current - Artifacts currently stored for the session, in insertion order.
- * @param cap - Maximum number of artifacts per session.
+ * Returns the session bound by {@link withExtensionSession} for the current async context, or `undefined` when none is bound.
  */
-declare function selectArtifactEvictions(current: readonly SessionArtifact[], cap?: number): string[];
+declare function currentExtensionSession(): Session | undefined;
 /**
- * Tests an artifact against a filter. An undefined filter matches everything. `limit` is not applied here.
+ * Reads one value an extension stored in the session metadata. Returns a copy, or `undefined` when the session, extension or key is missing or a name is unsafe.
  *
- * @param artifact - Artifact to test.
- * @param filter - Filter to apply.
- */
-declare function matchesArtifactFilter(artifact: SessionArtifact, filter: ArtifactFilter | undefined): boolean;
-/**
- * Newest first, stable on id.
- * @param artifacts - Artifacts to sort. The array is sorted in place.
- */
-declare function sortArtifacts(artifacts: SessionArtifact[]): SessionArtifact[];
-//#endregion
-//#region src/session/messages-pairing.d.ts
-/**
- * Placeholder content inserted into a synthetic `tool_result` when the harness
- * has to repair an orphan `tool_use`. Exported so downstream consumers
- * (training-data collectors, HFI submission) can reject any payload containing
- * it — the marker satisfies the wire-level pairing contract structurally but
- * the content itself is fake and would poison fine-tuning data.
+ * @param session - Session to read, if any.
+ * @param extensionName - Name of the extension that owns the value.
+ * @param key - Key under the extension namespace.
  */
-declare const SYNTHETIC_TOOL_RESULT_PLACEHOLDER = "[Tool result missing due to internal error]";
+declare function getExtensionSessionState<T = JsonValue>(session: Session | undefined, extensionName: string, key: string): T | undefined;
 /**
- * Replacement text for an assistant message whose every content block was
- * stripped during pairing repair (e.g. the only blocks were orphan
- * `tool_call`s). Providers reject empty `content` arrays — the marker keeps
- * the turn shape valid while signaling "this assistant turn lost its
- * outputs" to the model so it can recover.
+ * Stores a JSON value under an extension namespace in the session metadata and saves the session when it has a store. Does nothing without a session.
+ *
+ * Throws when a name is unsafe or the value exceeds the size limits (16 KiB per item, 64 KiB for all extension state).
+ *
+ * @param session - Session to write, if any.
+ * @param extensionName - Name of the extension that owns the value.
+ * @param key - Key under the extension namespace.
+ * @param value - JSON value to store. It is copied.
  */
-declare const TOOL_USE_INTERRUPTED_MARKER = "[Tool use interrupted]";
+declare function setExtensionSessionState(session: Session | undefined, extensionName: string, key: string, value: JsonValue): Promise<void>;
 /**
- * Replacement text for a user message whose every content block was a
- * `tool_result` with no matching upstream `tool_call` (e.g. the assistant
- * pair was stripped by an earlier compaction). Same role as
- * {@link TOOL_USE_INTERRUPTED_MARKER} on the user side.
+ * Removes one value from an extension namespace in the session metadata and saves the session when it has a store. Does nothing when the value does not exist.
+ *
+ * @param session - Session to modify, if any.
+ * @param extensionName - Name of the extension that owns the value.
+ * @param key - Key to remove.
  */
-declare const ORPHANED_TOOL_RESULT_MARKER = "[Orphaned tool result removed due to conversation resume]";
+declare function deleteExtensionSessionState(session: Session | undefined, extensionName: string, key: string): Promise<void>;
 /**
- * Classification of a single repair the pairing pass performed. Surfaced via
- * {@link EnsureToolResultPairingOptions.onRepair} so consumers can wire
- * telemetry, debug logs, or strict-mode rejection without re-implementing the
- * walk.
+ * Transitive `resumedFromRunId` chain starting at `runId` (inclusive).
  *
- * Each entry corresponds to one of the corruption modes documented on
- * {@link ensureToolResultPairing}.
+ * A resumed run only persists the turns IT produced — the turns it was
+ * seeded with still carry the original run's id. So reconstructing a
+ * resumed child's full conversation means collecting turns from every run
+ * in its resume lineage, not just the latest link. Cycle-guarded (a
+ * malformed chain terminates instead of looping).
+ * @param runs - Run records of the session.
+ * @param runId - Run to start from.
  */
-type PairingRepairMode = 'orphan-tool-use-prepend' | 'orphan-tool-use-append' | 'orphan-tool-result-strip' | 'duplicate-tool-use-strip' | 'duplicate-tool-result-strip' | 'empty-assistant-marker' | 'duplicate-tool-use-remint';
-/** One repair made by {@link ensureToolResultPairing}. */
-interface PairingRepair {
-  /** Which repair was performed. See {@link PairingRepairMode}. */
-  mode: PairingRepairMode;
-  /** Tool-use / tool-result id this repair concerns. Absent for empty-marker repairs. */
-  callId?: string;
-  /** Zero-based index into the INPUT `messages` array where the corruption was found. */
-  messageIndex: number;
-}
-/** Options for {@link ensureToolResultPairing}. */
-interface EnsureToolResultPairingOptions {
+declare function resumeChainRunIds(runs: readonly SessionRun[], runId: string): Set<string>;
+/** Record of one agent run inside a session. */
+interface SessionRun {
+  /** Run id. */
+  id: string;
+  /** Start time as epoch milliseconds. */
+  startedAt: number;
+  /** End time as epoch milliseconds. Absent while the run is in progress. */
+  endedAt?: number;
+  /** Prompt the run started with. */
+  prompt: string;
+  /** Run state. A persisted `running` run whose process died is shown as `aborted` on load. */
+  status: 'running' | 'completed' | 'aborted' | 'error';
+  /** Number of turns the run produced. */
+  turns?: number;
+  /** Input tokens used by the run. */
+  tokensIn?: number;
+  /** Output tokens used by the run. */
+  tokensOut?: number;
+  /** Error message when the run failed. */
+  error?: string;
+  /** What `error`'s one line leaves out (the provider's own text, a limit's reset). */
+  errorDetail?: RunErrorDetail;
+  /** Per-turn usage breakdown */
+  turnUsage?: TurnUsage[];
+  /** Total usage across all turns */
+  totalUsage?: TurnUsage;
+  /** Estimated cost in USD */
+  cost?: number;
   /**
-   * Fired once per repair the pass performed. Synchronous so the loop can
-   * stay on its hot path. Throwing from the callback aborts the pass —
-   * consumers wanting fail-fast (strict mode) can re-throw with their own
-   * typed error.
-   */
-  onRepair?: (repair: PairingRepair) => void;
+   * The run that spawned this one, when the agent is a subagent sharing its
+   * parent's session. Undefined on top-level `agent.run()`. Consumers can walk
+   * `runs` by `parentRunId` to reconstruct the subagent tree.
+   */
+  parentRunId?: string;
+  /**
+   * The prior run this one continues (see `AgentRunOptions.resumeRunId`).
+   * Set when a stopped/failed subagent run was resumed — consumers can
+   * chain runs by `resumedFromRunId` to render “child-4 (resumes child-2)”
+   * style markers. Absent on normal runs.
+   */
+  resumedFromRunId?: string;
+  /**
+   * Host-assigned display label (e.g. the spawn tool's `child-3`), persisted
+   * so label → run resolution is a stored fact instead of a positional
+   * guess. Positional `child-N` numbering can desynchronize from announced
+   * labels (concurrent spawns `startRun` out of reservation order, a
+   * pre-`startRun` throw advances the counter without a run, and reload
+   * ordering ties break lexicographically) — resolving by stored label is
+   * immune to all three. Absent on top-level runs and legacy sessions.
+   */
+  label?: string;
+  /**
+   * The `spawn` tool call that started this run, in the parent's turn (see
+   * `AgentRunOptions.parentCallId`): pairs a child with its call exactly,
+   * where parallel calls share a task. Absent on top-level runs and older
+   * sessions.
+   */
+  parentCallId?: string;
+  /**
+   * Zero-based subagent depth. 0 = top-level run, 1 = direct child, …
+   * Recorded here so hosts can query/filter by level without walking the tree.
+   */
+  depth?: number;
+  /**
+   * How this run was initiated when not a plain user prompt. `command` marks
+   * a sub-run driven from a `/` command's `ctx.runAgent`; `display` is the
+   * short line the transcript shows instead of the full injected prompt
+   * (which often embeds bulky material like a diff). Presentation-only —
+   * the wire/model payload is unaffected. Absent on normal runs.
+   */
+  origin?: {
+    kind: 'command';
+    display?: string;
+  };
+  /**
+   * The host's agent profile the run ran as (see `AgentRunOptions.runAgent`),
+   * so a transcript can name it per run. Absent when the host passes none.
+   */
+  agent?: SessionRunAgent;
 }
-/**
- * Defensive repair pass that rewrites a message list so it satisfies the
- * wire-level `tool_use` ↔ `tool_result` adjacency contract every modern
- * provider enforces.
- *
- * Anthropic 400s on orphans with `'tool_use' ids were found without
- * 'tool_result' blocks immediately after` (and its inverse, `tool_result
- * must be preceded by a tool_call with the same toolCallId`). OpenAI's
- * Chat Completions API rejects most mismatches with a 400 too.
- *
- * Six repair modes — modeled after Anthropic's Claude Code defenses:
- *
- * | # | Corruption | Repair |
- * |---|------------|--------|
- * | 1 | assistant `tool_use` whose next user msg lacks a matching `tool_result` | **Prepend** a synthetic `tool_result` block carrying {@link SYNTHETIC_TOOL_RESULT_PLACEHOLDER} with `isError: true` |
- * | 2 | assistant `tool_use` followed by nothing (or by a non-user msg) | **Insert** a new synthetic user message with the same placeholder |
- * | 3 | user `tool_result` with no preceding assistant `tool_call` | **Strip** the orphan block; if it empties the msg, replace with {@link ORPHANED_TOOL_RESULT_MARKER} text block |
- * | 4 | duplicate `tool_call.id` across assistant messages (CC-1212) | **Strip** later instances + their matching tool_results |
- * | 5 | duplicate `tool_result.callId` within a single user message | **Dedupe** by `callId`, keep first |
- * | 6 | assistant message emptied by mode-4 stripping | **Replace** content with {@link TOOL_USE_INTERRUPTED_MARKER} text block |
- *
- * **Repair, not drop.** Dropping orphan blocks would (a) silently rewrite
- * history the model had reasoned over and (b) cascade — dropping an assistant
- * tool_call would orphan its tool_result, which would then get dropped too,
- * removing any trace of "what the model tried to do" from the transcript. This
- * pass preserves the model's tool_use shape and patches the dangling result
- * with an `is_error` placeholder so the model sees "I tried X, the result was
- * lost" and can retry intelligently.
- *
- * Adjacency contract: `tool_result` blocks must live in the user message
- * IMMEDIATELY following the assistant message that emitted the matching
- * `tool_use`. The pass enforces strict adjacency — a tool_result two
- * messages downstream of its tool_call is still an orphan.
- *
- * Idempotent: returns the input reference unchanged when no repairs were
- * necessary. Re-running on already-repaired output is a no-op.
- *
- * Pure: does not mutate input messages or their content arrays — every
- * repair allocates a fresh array / object.
- * @param messages - Wire messages to repair. They are not modified.
- * @param options - Repair callback. See {@link EnsureToolResultPairingOptions}.
- */
-declare function ensureToolResultPairing(messages: SessionMessage[], options?: EnsureToolResultPairingOptions): SessionMessage[];
-/** Result of {@link remintDuplicateToolCallIds}. */
-interface RemintResult {
-  /** Tool calls with duplicate ids replaced. Same reference when unchanged. */
-  toolCalls: Array<{
-    id: string;
-    name: string;
-    input: Record<string, unknown>;
-  }>;
-  /** Assistant content with matching `tool_call` block ids rewritten. Same reference when unchanged. */
-  content: SessionContentBlock[];
-  /** One entry per re-minted occurrence, in emission order. */
-  reminted: Array<{
-    oldId: string;
-    newId: string;
-  }>;
+/** A host agent profile as a run record names it. */
+interface SessionRunAgent {
+  /** Profile id. */
+  id: string;
+  /** Display name. */
+  label: string;
 }
-/**
- * Re-mint tool-call ids that collide with ids already present in the
- * transcript (or with an earlier sibling in the same turn), BEFORE the turn
- * is persisted and its tools dispatched.
- *
- * Why this exists: some providers/serving stacks emit non-globally-unique
- * tool_use ids (per-turn counters like `call_0`, retry-replay duplicates,
- * Kimi-K2.6 on Fireworks). The wire-time pairing pass
- * ({@link ensureToolResultPairing}) can only STRIP such duplicates — which
- * erases the model's tool calls and results from the wire view, stalls
- * progress, and re-accumulates repairs quadratically because the persisted
- * session keeps the corrupted ids. Re-minting at persist time keeps the
- * pairing intact instead: the call, its execution, and its tool_result all
- * carry the fresh id, so the pairing pass has nothing to strip on any later
- * turn.
- *
- * Fresh ids are `${oldId}_r{n}` with `n` bumped until unique — deterministic
- * shape, Anthropic-wire-safe charset (given a safe input id), and visibly
- * traceable back to the original.
- *
- * Alignment contract: `toolCalls` and the `tool_call` blocks inside
- * `content` are two views of the same emission and MUST be in the same
- * order (true for every provider — both are built from one source array).
- * Occurrences are matched positionally per old id so intra-turn duplicates
- * map to distinct fresh ids on both views.
- *
- * Pure: returns the input references unchanged when no id collides.
- * @param toolCalls - Tool calls of the new assistant turn.
- * @param content - Content blocks of the same turn, with `tool_call` blocks in the same order as `toolCalls`.
- * @param priorIds - Tool call ids already in the transcript.
- */
-declare function remintDuplicateToolCallIds(toolCalls: ReadonlyArray<{
+/** A session's turns and runs: what a history edit reads and writes (`SessionStore.mutateHistory`). */
+interface SessionHistory {
+  /** The session's turns, in order. */
+  turns: SessionTurn[];
+  /** The session's runs, in order. */
+  runs: SessionRun[];
+}
+/** Persisted form of a session: identity, turns, runs and metadata. */
+interface SessionData {
+  /** Session id. */
   id: string;
-  name: string;
-  input: Record<string, unknown>;
-}>, content: readonly SessionContentBlock[], priorIds: ReadonlySet<string>): RemintResult;
+  /** Label of the agent profile that owns the session. */
+  agentId?: string;
+  /**
+   * Absolute path of the project this session belongs to — typically
+   * the git root resolved from `cwd` at creation time, falling back to
+   * `cwd` itself when not in a git repo. Set ONCE on creation and never
+   * mutated thereafter (the session "belongs" to that project forever).
+   *
+   * Used by the TUI's sessions list to filter rows by current project,
+   * so the user only sees conversations relevant to where they are
+   * working — without needing one `.{prefix}/` directory per project.
+   *
+   * `undefined` on pre-tagging legacy sessions; the chat layer treats
+   * those as "untagged" and hides them unless `Settings.showAllProjects`
+   * is on.
+   */
+  projectRoot?: string;
+  /** Turn history, oldest first. */
+  turns: SessionTurn[];
+  /** Records of the runs in this session. */
+  runs: SessionRun[];
+  /** Session state. A persisted `running` status is stale after a restart and is shown as `idle` on load. */
+  status: 'idle' | 'running' | 'completed' | 'error';
+  /** Free-form metadata, such as the title, model and extension state. */
+  metadata: Record<string, unknown>;
+  /** Creation time as epoch milliseconds. */
+  createdAt: number;
+  /** Last update time as epoch milliseconds. */
+  updatedAt: number;
+}
 /**
- * Classification of a single deletion {@link dropInvalidToolPairings}
- * performed. Surfaced via `onDrop` for telemetry.
+ * Compact per-session summary returned by {@link SessionStore.listMeta}.
+ * Raw facts only — presentation (title derivation, fallback strings)
+ * stays in the chat layer (`listSessionMeta` / `deriveSessionTitle`).
  */
-type PairingDropKind = 'duplicate-tool-call' | 'duplicate-tool-result' | 'orphan-tool-result' | 'empty-turn';
-/** One deletion made by {@link dropInvalidToolPairings}. */
-interface PairingDrop {
-  /** What was dropped. See {@link PairingDropKind}. */
-  kind: PairingDropKind;
-  /** Tool-call / tool-result id the drop concerns. Absent for empty-turn drops. */
-  callId?: string;
-  /** Zero-based index into the INPUT `turns` array. */
-  index: number;
+interface SessionMetaRow {
+  /** Session id. */
+  id: string;
+  /** Header metadata (may carry a stored `title`). */
+  metadata: Record<string, unknown>;
+  /** Absent for untagged (legacy) sessions. */
+  projectRoot?: string;
+  /** Last update time as epoch milliseconds. */
+  updatedAt: number;
+  /**
+   * The store's change counter for this session: bumped by every write to
+   * it (in the write's own transaction), so it only grows, whatever
+   * `updatedAt` a writer stamps. Absent from stores that keep none.
+   */
+  rev?: number;
+  /** Number of turns. */
+  turnCount: number;
+  /** Count of `role: 'user'` turns. */
+  userMessageCount: number;
+  /** Number of run records. */
+  runCount: number;
+  /**
+   * First `role: 'user'` turn — the title-derivation source. Stores may
+   * omit it when `metadata.title` is already set (no derivation needed).
+   */
+  firstUserTurn?: SessionTurn;
+  /**
+   * Header fields consumers like the daemon's `sessions.list` need to
+   * build full rows without a per-session `load()`. Optional (additive
+   * contract extension) — callers fall back to `load()` when absent.
+   */
+  agentId?: string;
+  /** Creation time as epoch milliseconds. */
+  createdAt?: number;
+  /** Session state. */
+  status?: SessionData['status'];
+  /**
+   * Number of artifacts recorded for the session. Optional (additive):
+   * only stores implementing the artifact methods populate it; consumers
+   * treat absence as "unknown", not zero.
+   */
+  artifactCount?: number;
 }
 /**
- * Drop-only normalization of persisted history: delete structurally invalid
- * tool blocks so the transcript never re-triggers wire-time pairing repairs
- * turn after turn.
- *
- * Unlike {@link ensureToolResultPairing} — which SYNTHESIZES placeholder
- * content and must therefore stay wire-only (fabricated results would poison
- * persisted history and training data) — this pass performs pure deletions of
- * blocks that are provably invalid regardless of interpretation:
- *
- * | Corruption | Action |
- * |------------|--------|
- * | duplicate `tool_call` id within one run lane (across or within turns) | drop the later instance |
- * | duplicate `tool_result.callId` within one turn | drop the later instance |
- * | `tool_result` with no matching `tool_call` in the immediately preceding same-lane assistant turn | drop the block |
- * | turn emptied by the drops above (reasoning-only remainders count as empty) | drop the whole turn |
- *
- * Duplicate detection is scoped to the WIRE-VIEW lane: tool_call ids only
- * collide when both instances reach one model request. By default a turn's
- * lane is its raw `runId` — correct for parent/subagent interleaving, where
- * providers minting per-conversation counter ids (`call_0`, `call_1`)
- * legitimately reuse the same id across lanes. Callers that know the run
- * topology (see `createSession`) pass `laneForRun` to widen lanes to true
- * wire views: all depth-0 runs share the main conversation view, and a
- * resumed subagent shares its resume-chain ancestors' view — duplicates
- * across those runIds DO reach a single request (wire-time
- * `ensureToolResultPairing` mode 4 would strip them on every send) and are
- * healed here.
- *
- * Orphan `tool_use` blocks (a call whose result was never persisted —
- * interrupted run) are deliberately KEPT: they are authentic model output,
- * and the wire-time pass patches them with a synthetic result on every send
- * without touching history.
- *
- * Deletions cascade by design: dropping a duplicate `tool_call` orphans its
- * `tool_result`, which is then dropped too; a turn emptied by either is
- * removed entirely.
- *
- * Safe to persist: deterministic, idempotent (re-running on healed output is
- * a no-op returning the same reference), and fabricates nothing.
- *
- * Pure: does not mutate input turns or their content arrays.
- * @param turns - Persisted turns, oldest first. They are not modified.
- * @param options - `onDrop` is called once per deletion. `laneForRun` maps a `runId` to its wire-view lane.
+ * Storage backend for sessions. Implement it to persist sessions somewhere else, or use a bundled store: memory, SQLite, remote or file map.
  */
-declare function dropInvalidToolPairings<T extends {
-  role: string;
-  content: SessionContentBlock[];
-  runId?: string;
-}>(turns: T[], options?: {
-  onDrop?: (drop: PairingDrop) => void;
+interface SessionStore {
+  /** Optional: generate a session ID server-side (e.g. a database-issued UUID). */
+  generateSessionId?: () => string | Promise<string>;
   /**
-   * Map a turn's `runId` to its wire-view lane. Turns whose lanes differ
-   * never share a model request, so their tool_call ids may legitimately
-   * collide. Defaults to the raw `runId` (undefined runIds share one
-   * lane) — the conservative choice when run topology is unknown.
+   * Optional: generate a turn ID server-side for session-managed user turns.
+   *
+   * Provider-loop assistant and tool-result turns use AgentClock.randomUUID()
+   * instead, so durable-execution adapters can keep those IDs replay-stable.
    */
-  laneForRun?: (runId: string | undefined) => string;
-}): T[];
-//#endregion
-//#region src/session/messages.d.ts
-/**
- * Converts an Anthropic wire message into a {@link SessionMessage}.
- *
- * @param msg - Anthropic message with a string or block-array `content`.
- */
-declare function fromAnthropic(msg: {
-  role: string;
-  content: unknown;
-}): SessionMessage;
-/**
- * Converts an OpenAI wire message into a {@link SessionMessage}.
- *
- * @param msg - OpenAI message with a string or part-array `content`.
- */
-declare function fromOpenAI(msg: {
-  role: string;
-  content: unknown;
-}): SessionMessage;
-/** What a wire builder should do with a reasoning block for a given target. */
-type ReasoningWireAction = 'keep' | 'drop' | 'strip-signature';
+  generateTurnId?: () => string | Promise<string>;
+  /** Load a session by ID. Returns null if not found. */
+  load: (sessionId: string) => Promise<SessionData | null>;
+  /**
+   * Save a session (create or update, full document). Bulk overwrite:
+   * turns and runs on disk are replaced by the caller's snapshot, so a
+   * stale snapshot silently discards anything another writer appended.
+   * `Session.save()` only routes here when the turn list was explicitly
+   * replaced (`setTurns` / `setRuns` / load-time heal); everything else
+   * goes through {@link saveMeta}.
+   */
+  save: (session: SessionData) => Promise<void>;
+  /**
+   * Optional: persist header fields only (agentId, projectRoot, status,
+   * metadata, timestamps) plus an UPSERT of the runs present in the
+   * snapshot — never deletes turns or runs. This is what metadata writes
+   * (title, model, todos, extension state) need.
+   *
+   * Scope of the guarantee: TURNS appended by a concurrent process survive.
+   * The header itself is still last-writer-wins — `status` and `agentId`
+   * are written wholesale from the caller's snapshot, and so is `metadata`
+   * unless `options.metaKeys` names the changed keys (`Session.save()`
+   * always does; stores merge them with {@link mergeSessionMetadata}), and every run in the snapshot is upserted as-is (a reader
+   * that loaded through `loadSession` carries the in-memory stale-running
+   * demotion, so it can write `idle` / `aborted` over a live owner's marker
+   * until the owner's next write). Readers that only need one key should
+   * prefer a keyed patch (the host's `patchSessionMeta`) over `save()`.
+   * Stores that omit it fall back to `save`, keeping the historical bulk
+   * semantics.
+   */
+  saveMeta?: (session: SessionData, options?: SaveMetaOptions) => Promise<void>;
+  /** Delete a session. */
+  delete: (sessionId: string) => Promise<void>;
+  /**
+   * List session IDs, optionally filtered. `projectRoot` restricts to
+   * sessions whose `SessionData.projectRoot` matches exactly — untagged
+   * (legacy) sessions are NOT returned under that filter; pass `null`
+   * explicitly to ask for untagged ones, or omit the field to ignore
+   * the axis entirely. `agentId` filters by recorded agent; the two
+   * conditions AND together when both are set.
+   */
+  list: (filter?: {
+    agentId?: string;
+    limit?: number;
+    projectRoot?: string | null;
+  }) => Promise<string[]>;
+  /**
+   * Optional: list session summaries without materializing full sessions.
+   *
+   * The generic fallback (`listSessionMeta` in `zidane/chat`) is `list()`
+   * + `load()` per id — O(every turn in the store) because each `load`
+   * parses the full turn history just to count rows and derive a title.
+   * Stores that can answer from an index (SQL aggregates, a denormalized
+   * header) should implement this; the sqlite store turns a multi-hundred-
+   * ms TUI boot cost into a single query.
+   *
+   * Same filter contract and ordering (most recently updated first) as
+   * {@link list}.
+   */
+  listMeta?: (filter?: {
+    agentId?: string;
+    limit?: number;
+    projectRoot?: string | null;
+  }) => Promise<SessionMetaRow[]>;
+  /**
+   * Optional: one session's header row WITHOUT materializing turns.
+   * Hot-path reads (the cross-process run guard checks `status` +
+   * `updatedAt` on every prompt send) must not pay a multi-MB turn parse
+   * on long sessions. Callers fall back to `load()` when absent.
+   */
+  getMeta?: (sessionId: string) => Promise<SessionMetaRow | null>;
+  /** Append new turns to a session (incremental, avoids full re-save). */
+  appendTurns: (sessionId: string, turns: SessionTurn[]) => Promise<void>;
+  /** Return a slice of turns for a session. */
+  getTurns: (sessionId: string, from?: number, limit?: number) => Promise<SessionTurn[]>;
+  /**
+   * Optional: rewrite a session's history as ONE atomic read-modify-write,
+   * so turns appended between the read and the write can't be erased (a
+   * `load()` + `save()` pair can). `mutate` gets the current turns and
+   * runs and returns the next ones, or `null` to leave them untouched; a
+   * throw inside it aborts without writing. Runs are written only when it
+   * returns a different `runs` array. History edits (delete / edit a turn,
+   * rewind) use it when present and fall back to `load()` + `save()`.
+   */
+  mutateHistory?: (sessionId: string, mutate: (history: SessionHistory) => SessionHistory | null) => Promise<'ok' | 'no-session' | 'unchanged'>;
+  /**
+   * Optional: the turns-only form of {@link SessionStore.mutateHistory}.
+   * When `mutateHistory` is absent, edits that leave the runs alone (delete
+   * or edit a turn) use it; a rewind falls back to `load()` + `save()`.
+   * @deprecated Implement `mutateHistory` instead.
+   */
+  mutateTurns?: (sessionId: string, mutate: (turns: SessionTurn[]) => SessionTurn[] | null) => Promise<'ok' | 'no-session' | 'unchanged'>;
+  /**
+   * Persist a run record (called at run start with `status: 'running'`, and
+   * after completeRun / abortRun / errorRun).
+   *
+   * **Upsert semantics required.** The agent's run lifecycle calls
+   * `session.startRun()` to register a new run in IN-MEMORY state and
+   * then `updateRun()`. The store doesn't see the run before the first
+   * `updateRun()` — `appendTurns` persists turns but not runs. An
+   * update-only implementation would silently drop every newly-created
+   * run record, leaving
+   * the on-disk `runs[]` missing entries that the persisted turns
+   * reference (which `eventsFromTurns` then mis-classifies via
+   * `ancestryOf` → broken depth, broken `child-N` labels, broken
+   * `userPrompts` history).
+   *
+   * Implementations MUST insert when the id doesn't exist and update
+   * when it does. The bundled `sqlite` / `memory` / `file-map` stores
+   * all follow this contract; remote stores using HTTP PUT get upsert
+   * for free via REST semantics.
+   */
+  updateRun: (sessionId: string, run: SessionRun) => Promise<void>;
+  /**
+   * Update the top-level status of a session.
+   *
+   * `preserveUpdatedAt` (default false) writes the status WITHOUT
+   * touching `updatedAt` — for pure-read heals (`loadSession`'s stale
+   * `'running'` demotion) that must not reorder recency-sorted session
+   * lists. Best-effort contract: stores that don't manage `updatedAt`
+   * themselves (memory, file-map, remote) may ignore the option; the
+   * sqlite store honors it.
+   */
+  updateStatus: (sessionId: string, status: SessionData['status'], options?: {
+    preserveUpdatedAt?: boolean;
+  }) => Promise<void>;
+  /**
+   * Optional: record an artifact (see `./artifacts.ts`). Upsert on
+   * `(sessionId, kind, uri)` — an existing row keeps its `id` / `runId` /
+   * `turnId` / `createdAt` and refreshes `label` / `meta` / `updatedAt`
+   * (`mergeArtifact`). Resolves to the canonical stored row. Unknown
+   * session ids are a no-op returning `null` (no ghost headers; same
+   * posture as `updateRun`). Implementations enforce
+   * `ARTIFACTS_PER_SESSION_CAP` via `selectArtifactEvictions`.
+   *
+   * Every artifact method is optional: stores that don't implement them
+   * (file-map, remote, third-party) keep working — `Session.addArtifact`
+   * degrades to a no-op and listings come back empty.
+   */
+  upsertArtifact?: (artifact: SessionArtifact) => Promise<SessionArtifact | null>;
+  /**
+   * Optional: list artifacts, newest `updatedAt` first. `filter.sessionId`
+   * scopes to one session; `filter.projectRoot` follows the tri-state
+   * contract of {@link list}; omit both for every artifact in the store.
+   */
+  listArtifacts?: (filter?: ArtifactFilter) => Promise<SessionArtifact[]>;
+  /** Optional: remove one artifact. Unknown ids are a no-op. */
+  deleteArtifact?: (sessionId: string, artifactId: string) => Promise<void>;
+  /**
+   * Optional: release backend resources (e.g. close the SQLite handle).
+   * Hosts should call this on teardown when present; stores backed by
+   * memory or remote HTTP have nothing to release and may omit it.
+   */
+  close?: () => void;
+}
 /**
- * Provider a history is sent to, as {@link reasoningWireAction} tells them
- * apart. A Gemini-wire target is its signature scope, so an extension's
- * `googleCompatible` route keeps only the signatures it minted.
+ * A live session: the turn history and run records of one conversation, with an optional store that persists them.
  */
-type ReasoningWireTarget = 'anthropic' | 'openai' | GeminiSignatureScope;
-/**
- * Single source of truth for whether a signature-bearing reasoning block
- * (`thinking` / `redacted_thinking`) may be forwarded to a provider. The
- * wire builders ({@link toAnthropic}, the OpenAI and Google message shapers)
- * and the host-facing {@link sanitizeHistoryForProvider} apply this same
- * policy — keeping them one function means the sanitizer can never drift
- * from what the wire actually sends.
- *
- * Rules, each driven by an API constraint hit in production:
- *
- * - target `anthropic`:
- *   - `redacted_thinking` → keep (native Anthropic block; must be echoed).
- *   - `thinking` tagged `openai`, `google` or `google-vertex` → drop
- *     (OpenAI `encrypted_content` and Gemini thought signatures are not
- *     valid Anthropic HMACs; 400s).
- *   - unsigned `thinking` → drop (`ThinkingBlockParam` requires a
- *     signature; unsigned blocks come from non-signing producers).
- *   - signed but UNTAGGED `thinking` (pre-tagging sessions) → keep: it is
- *     most plausibly legacy Anthropic output, and the signature-400
- *     recovery converges if it is not.
- *
- * - target `openai` or a Gemini-wire scope (`google`, `google-vertex`, a
- *   `googleCompatible` route's):
- *   - `redacted_thinking` → drop (Anthropic-only block type).
- *   - `thinking` tagged `anthropic` → drop (an Anthropic HMAC is valid
- *     nowhere else).
- *   - `thinking` signed by any other producer, or signed but UNTAGGED →
- *     strip-signature: there is no signature-error recovery on these paths,
- *     so forwarding a possibly-foreign signature risks an unrecoverable
- *     400. The reasoning text survives; only the opaque signature is
- *     withheld. Gemini's are kept only for the route that issued them.
- * @param block - A `thinking` or `redacted_thinking` block.
- * @param target - Provider the history is sent to.
- */
-declare function reasoningWireAction(block: {
-  type: 'thinking';
-  signature?: string;
-  signatureProducer?: SignatureProducer;
-} | {
-  type: 'redacted_thinking';
-}, target: ReasoningWireTarget): ReasoningWireAction;
-/**
- * Host-facing history sanitizer — applies {@link reasoningWireAction} to a
- * turn set BEFORE it is handed to an agent targeting `target`. The in-loop
- * wire builders already enforce the same policy per call, so this is for
- * hosts that seed history from an external durable store (or hydrate
- * pre-provenance-tagging sessions) and want the poison removed from their
- * source of truth in one call instead of re-deriving block semantics.
- *
- * Returns new turn objects only where something changed (unchanged turns
- * pass through by reference). A turn whose content empties keeps the same
- * neutral marker the wire repair uses, so role boundaries stay intact.
- * @param turns - Turns to sanitize.
- * @param target - Provider the history is sent to.
- */
-declare function sanitizeHistoryForProvider<T extends {
-  content: SessionContentBlock[];
-}>(turns: readonly T[], target: ReasoningWireTarget): {
-  turns: T[];
-  removed: number;
-  stripped: number;
-};
-/**
- * Converts a {@link SessionMessage} into an Anthropic wire message. Foreign reasoning blocks are dropped following {@link reasoningWireAction}.
- *
- * @param msg - Message to convert.
- */
-declare function toAnthropic(msg: SessionMessage): {
-  role: string;
-  content: unknown;
-};
-/**
- * Converts a {@link SessionMessage} into an OpenAI wire message.
- *
- * @param msg - Message to convert.
- */
-declare function toOpenAI(msg: SessionMessage): {
-  role: string;
-  content: unknown;
-};
-/**
- * Drop ASSISTANT turns whose every `tool_call` block is unresolved
- * (no matching `tool_result` block anywhere later in the transcript).
- * Tool_call blocks with at least one matching tool_result are kept — modes
- * 1/3 of {@link ensureToolResultPairing} handle the partial-pair case at
- * wire-send time.
- *
- * Use case: session resume. A turn that emitted three `tool_use` blocks but
- * never persisted the matching `tool_result` turn (process death, crash,
- * `kill -9`) leaves the transcript with an orphan that Anthropic rejects on
- * the FIRST API call after reload. Dropping the whole assistant turn — not
- * just the orphan blocks — preserves text-only turns that legitimately
- * carry reasoning the model wants to see again.
- *
- * Does NOT mint fresh ids: re-id'ing on every resume would cause
- * exponential transcript growth across repeated resumes of an interrupted
- * session.
- *
- * Pure: returns the input reference unchanged when no turn was dropped.
- * @param turns - Turns of the session, oldest first.
- */
-declare function filterUnresolvedToolUses<T extends {
-  role: string;
-  content: SessionContentBlock[];
-}>(turns: T[]): T[];
-/**
- * Classification of a session's tail state for resume purposes.
- *
- * - `'clean'` — the trailing turn is a user message (the model would respond
- *   next), or the transcript is empty. Safe to resume by appending a fresh
- *   user prompt.
- * - `'interrupted'` — the trailing turn is an assistant message that has at
- *   least one `tool_call` block with no matching `tool_result` anywhere
- *   later. The run was almost certainly killed between persisting the
- *   assistant turn and persisting its tool-results turn. Hosts that want
- *   Claude-Code-style auto-resume can detect this and inject a
- *   `"Continue from where you left off."` user message before the next run.
- * - `'completed'` — the trailing turn is an assistant message with no
- *   orphan tool_calls. The model considers itself done. Hosts that want to
- *   resume must supply a new prompt; auto-continuation here would be a
- *   non-sequitur.
- */
-type TurnInterruptionState = 'clean' | 'interrupted' | 'completed';
-/**
- * Inspect a session's trailing turn to classify whether the run was
- * interrupted mid-tool-call. Pure / synchronous — does not modify the input.
- *
- * Pair with {@link filterUnresolvedToolUses} on the resume path: filter
- * first so the result reflects the post-cleanup state (a turn whose orphans
- * were stripped reads as 'completed', not 'interrupted').
- * @param turns - Turns of the session, oldest first.
- */
-declare function detectTurnInterruption<T extends {
-  role: string;
-  content: SessionContentBlock[];
-}>(turns: T[]): TurnInterruptionState;
-/**
- * Guarantee a message list ends with a `role: 'user'` message, appending a
- * synthetic directive when it doesn't.
- *
- * Why: Anthropic's API (and several OpenAI-compat reasoning models — opus
- * 4.7, the o-series translation layers on Bedrock/Vertex) rejects requests
- * whose final message is `role: 'assistant'` with
- * "This model does not support assistant message prefill. The conversation
- * must end with a user message."
- *
- * Triggers in zidane:
- *   - Compaction over a session whose last turn is the agent's response
- *     (the common case — autocompact fires right after `agent.run()`).
- *   - Schema enforcement after an assistant text turn (no `tool_use`, so
- *     `ensureToolResultPairing` doesn't synthesize a user tail).
- *   - `context:transform` hooks that strip the trailing user turn.
- *
- * The pair-repair pass {@link ensureToolResultPairing} already covers the
- * orphan-`tool_use` case via mode 2; this helper closes the plain-text
- * assistant-tail case. They compose: run pair-repair first, then this
- * pass, so an assistant turn with orphan tool_uses gets its synthetic
- * `tool_result` user turn AND this pass is a no-op (the synthetic turn
- * is already user-role).
- *
- * Empty input passes through unchanged — the caller's "nothing to send"
- * guard is responsible for that case; we don't materialize a conversation
- * out of an empty list.
- *
- * Idempotent: returns the input reference unchanged when the list is
- * already user-terminated (or empty).
- *
- * @param messages   Wire-ready message list.
- * @param provider   Provider whose `userMessage()` shape we use so the
- *                   synthetic turn matches the wire format the rest of
- *                   the list already follows.
- * @param directive  Text to put in the synthetic user message. Defaults
- *                   to {@link DEFAULT_USER_TAIL_DIRECTIVE} ("Continue.").
- *                   Compaction overrides this with a summary-specific cue.
- */
-declare function ensureEndsWithUserMessage(messages: SessionMessage[], provider: Provider, directive?: string): SessionMessage[];
-/** Options for {@link toWireMessages}. */
-interface ToWireMessagesOptions {
-  /**
-   * Pairing-repair telemetry. Fires once per repair the underlying
-   * {@link ensureToolResultPairing} pass performs. Mirrors the
-   * `pairing:repair` hook surface so consumers can wire structured logging
-   * without an agent instance.
-   */
-  onRepair?: (repair: PairingRepair) => void;
+interface Session {
+  /** Session ID */
+  readonly id: string;
+  /** Agent ID (optional label) */
+  readonly agentId?: string;
   /**
-   * When set, also runs {@link ensureEndsWithUserMessage} so the result is
-   * safe for assistant-prefill-rejecting models (opus 4.7, o-series
-   * translation layers). Omit to skip — pure pairing repair only.
+   * Re-label the session's agent profile (in memory; persisted by the
+   * next `save()`). Sessions remember their profile — pickers restore it
+   * on activation and other windows converge on it via `sessions.touch`.
    */
-  provider?: Provider;
+  setAgentId: (agentId: string) => void;
   /**
-   * Override for the synthetic user-tail directive. Only consulted when
-   * `provider` is set. Defaults to {@link DEFAULT_USER_TAIL_DIRECTIVE}.
+   * Project this session was created under — see {@link SessionData.projectRoot}.
+   * Set once on creation; surfaces here for read-only inspection.
    */
-  userTailDirective?: string;
+  readonly projectRoot?: string;
   /**
-   * Resolve persisted content references into provider-native payload bytes.
-   * The returned data is wire-only and must not be written back to turns.
+   * Raw persisted turn history — kept pristine for fidelity (the model's
+   * reasoning chain stays intact across reloads).
+   *
+   * **DO NOT pass this directly to a provider request.** Mid-pair
+   * persistence (interrupted runs, partial-result writes, compaction
+   * boundaries) leaves orphan `tool_use` / `tool_result` blocks here that
+   * every provider 400s on (`tool_result must be preceded by a tool_call
+   * with the same toolCallId`). The agent's own loop repairs these
+   * just-in-time at wire-send time and never writes the repair back to
+   * `turns`.
+   *
+   * For provider requests built outside `agent.run()`, use
+   * {@link Session.toMessages} — it applies the same defensive pairing
+   * repair and resolves to a guaranteed-safe `SessionMessage[]`.
    */
-  resolveContentRef?: ResolveContentRef;
-}
-/**
- * Build a wire-ready `SessionMessage[]` from raw persisted `SessionTurn[]`.
- *
- * **The canonical "I want to send these to a provider" projection.** Use
- * this — not raw `session.turns` / `store.getTurns()` — when constructing a
- * provider request outside `agent.run()`. The agent's own wire pipeline
- * (`executeTurn` in `src/loop-turn.ts`) applies the same repair just-in-time;
- * downstream consumers that bypass the loop hit `tool_result must be
- * preceded by a tool_call` 400s precisely because they shipped raw turns.
- *
- * Pipeline:
- *   1. Filter out turns that never reach the model (`system` and `command`
- *      roles).
- *   2. Resolve content refs with `options.resolveContentRef`.
- *   3. {@link ensureToolResultPairing} — repairs all six orphan / dup
- *      corruption modes: synthetic placeholders for orphan tool_use blocks
- *      (preserves the model's tool_use shape), strips for duplicates and
- *      orphan tool_results.
- *   4. {@link ensureEndsWithUserMessage} when `options.provider` is set —
- *      guards against assistant-tail prefill rejection (opus 4.7, o-series).
- *
- * Pure + idempotent. Does not mutate the input turns. Re-running on the
- * output is a no-op.
- *
- * **Do not feed the result back into `session.setTurns` / `appendTurns`.**
- * The repair can insert `SYNTHETIC_TOOL_RESULT_PLACEHOLDER` / `[Orphaned
- * tool result removed …]` markers; round-tripping those into persisted
- * state contaminates the session's reasoning history and defeats the
- * "don't rewrite the past" invariant the wire-only repair was designed
- * around.
- * @param turns - Persisted turns, oldest first.
- * @param options - Repair and tail options. See {@link ToWireMessagesOptions}.
- */
-declare function toWireMessages(turns: readonly {
-  role: 'user' | 'assistant' | 'system' | 'command';
-  content: SessionContentBlock[];
-}[], options?: ToWireMessagesOptions): Promise<SessionMessage[]>;
-/**
- * Converts a wire message of unknown provider into a {@link SessionMessage}. Block types decide between {@link fromAnthropic} and {@link fromOpenAI}. Anthropic is the default.
- *
- * @param msg - Anthropic or OpenAI wire message.
- */
-declare function autoDetectAndConvert(msg: {
-  role: string;
-  content: unknown;
-}): SessionMessage;
-//#endregion
-//#region src/session/metadata-merge.d.ts
-/** Options for `SessionStore.saveMeta`. */
-interface SaveMetaOptions {
+  readonly turns: SessionTurn[];
   /**
-   * The metadata keys this writer changed. When set, the store merges only
-   * these keys into the metadata it already holds (an `undefined` value
-   * removes the key) instead of replacing the whole record, so a stale copy
-   * of the session can't write back keys another writer changed since.
-   * Omitted: the whole `metadata` record is written.
+   * True when this session has no turns yet.
+   *
+   * Use this as a first-prompt signal when setting up a run — e.g. writing initial
+   * configuration only on fresh sessions. Equivalent to `turns.length === 0`.
    */
-  metaKeys?: readonly string[];
-}
-/**
- * The metadata a `saveMeta` should store: `incoming` wholesale without
- * `keys`, otherwise `stored` with only `keys` taken from `incoming`.
- *
- * @param stored - Metadata the store holds now; when absent, `incoming` is stored as is.
- * @param incoming - Metadata the writer sends.
- * @param keys - Keys the writer changed (`SaveMetaOptions.metaKeys`); an `undefined` value in `incoming` removes the key.
- */
-declare function mergeSessionMetadata(stored: SessionData['metadata'] | undefined, incoming: SessionData['metadata'], keys: readonly string[] | undefined): SessionData['metadata'];
-//#endregion
-//#region src/session/file-map.d.ts
-/**
- * Host-provided file-map adapter. Three methods exchanging `Record<string, string>`
- * payloads — the whole persistence surface the wrapper needs.
- */
-interface FileMapAdapter {
-  /** Load the current file map. Returns an empty `files` record when nothing is persisted. */
-  get: () => Promise<{
-    files: Record<string, string>;
-  }>;
-  /** Replace the persisted file map. Full-rewrite semantics. */
-  save: (files: Record<string, string>) => Promise<void>;
-  /** Delete all persisted state. */
-  delete: () => Promise<void>;
+  readonly isEmpty: boolean;
+  /** Top-level session status */
+  readonly status: SessionData['status'];
+  /** All runs in this session */
+  readonly runs: SessionRun[];
+  /** Arbitrary metadata */
+  readonly metadata: Record<string, unknown>;
+  /** Creation time as epoch milliseconds. */
+  readonly createdAt: number;
+  /** Last update time as epoch milliseconds. */
+  readonly updatedAt: number;
+  /**
+   * Start tracking a new run. `extras.parentRunId` + `extras.depth` are
+   * populated by the spawn tool when a child agent shares its parent's
+   * session; regular top-level `agent.run()` calls omit them.
+   */
+  startRun: (runId: string, prompt?: string, extras?: {
+    parentRunId?: string;
+    depth?: number;
+    resumedFromRunId?: string;
+    label?: string;
+    parentCallId?: string;
+    agent?: SessionRunAgent;
+  }) => void;
+  /** Mark a run as completed */
+  completeRun: (runId: string, stats: {
+    turns: number;
+    tokensIn: number;
+    tokensOut: number;
+    turnUsage?: TurnUsage[];
+    cost?: number;
+  }) => void;
+  /**
+   * Mark a run as aborted. Optional `stats` lets the agent backfill the run's token totals when
+   * the abort happened *after* the loop accumulated meaningful usage —
+   * common when the user presses esc mid-streaming. Without it, the run
+   * record reads `0 in / 0 out` on reload regardless of how much was
+   * spent before the abort. Same shape as `completeRun`'s stats so the
+   * persisted `totalUsage` aggregate stays consistent across paths.
+   */
+  abortRun: (runId: string, stats?: {
+    turns: number;
+    tokensIn: number;
+    tokensOut: number;
+    turnUsage?: TurnUsage[];
+    cost?: number;
+  }) => void;
+  /** Mark a run as errored. Optional `stats` — same rationale as `abortRun.stats`. */
+  errorRun: (runId: string, error: string, stats?: {
+    turns: number;
+    tokensIn: number;
+    tokensOut: number;
+    turnUsage?: TurnUsage[];
+    cost?: number;
+  }, detail?: RunErrorDetail) => void;
+  /** Append turns to in-memory history AND persist via store.appendTurns (if store present) */
+  appendTurns: (turns: SessionTurn[]) => Promise<void>;
+  /** Replace all turns in-memory (does not persist — use save() for that) */
+  setTurns: (turns: SessionTurn[]) => void;
+  /**
+   * Replace all runs in-memory (does not persist — use save() for that).
+   * Mirrors {@link setTurns} for the fork / restore case: callers that
+   * bootstrap a session from an externally-derived snapshot (e.g.
+   * `onForkTurn` copying parent runs into a child session) need this so
+   * the cloned runs land in `data.runs` before the first `save()`.
+   * Production agent runs continue to mutate runs via `startRun` /
+   * `completeRun` / `updateRun`; this is the bulk-replace escape hatch.
+   */
+  setRuns: (runs: SessionRun[]) => void;
+  /** Update the session status in memory AND via store.updateStatus (if store present) */
+  updateStatus: (status: SessionData['status']) => Promise<void>;
+  /** Persist an updated run record via store.updateRun (if store present) */
+  updateRun: (run: SessionRun) => Promise<void>;
+  /** Generate a session-managed turn ID using store.generateTurnId if available, else crypto.randomUUID() */
+  generateTurnId: () => string | Promise<string>;
+  /** Set metadata key. `touch: false` keeps `updatedAt` (a rename or a favorite is not activity). */
+  setMeta: (key: string, value: unknown, options?: {
+    touch?: boolean;
+  }) => void;
+  /**
+   * Record an artifact this session produced. Fills `id`, timestamps and
+   * defaults `projectRoot` to the session's own; `origin` ties it to the
+   * producing run/turn for transcript anchoring. Resolves to the stored
+   * row, or `undefined` when there is no store or the store doesn't
+   * implement artifacts (never throws for that case — emission is
+   * best-effort by contract).
+   */
+  addArtifact: (input: SessionArtifactInput, origin?: {
+    runId?: string;
+    turnId?: string;
+  }) => Promise<SessionArtifact | undefined>;
+  /** This session's artifacts, newest first. Empty when unsupported. */
+  listArtifacts: (filter?: Pick<ArtifactFilter, 'kind' | 'since' | 'limit'>) => Promise<SessionArtifact[]>;
+  /**
+   * Persist the session to the store. When the store implements `saveMeta`,
+   * this writes the header, the changed metadata keys and the runs, and leaves
+   * turns alone, unless `setTurns` or `setRuns` replaced them. In every other
+   * case it overwrites the whole document through `store.save`. Throws when
+   * the session has no store.
+   */
+  save: () => Promise<void>;
+  /**
+   * Project the session's persisted turns into wire-ready messages safe to
+   * hand to any provider.
+   *
+   * The canonical answer to "I need to send these turns to Anthropic /
+   * OpenAI from outside `agent.run()`" (sub-agent classifier, side-channel
+   * summarizer, replay worker, …). Runs the same defensive pairing repair
+   * the agent loop applies just-in-time at wire-send time
+   * ({@link ensureToolResultPairing}), so orphan `tool_use` blocks and
+   * dangling `tool_result`s never reach the provider as the 400
+   * "tool_result must be preceded by a tool_call with the same toolCallId".
+   *
+   * Pass `provider` to also enforce the user-tail invariant
+   * ({@link ensureEndsWithUserMessage}) — required for opus 4.7 / o-series
+   * style models that reject assistant-prefill.
+   *
+   * Pure + idempotent. Resolves content refs only in the returned messages
+   * and does NOT mutate `session.turns`. **Do not write the result back via
+   * `setTurns` / `appendTurns`** — synthetic placeholders or resolved
+   * payloads will contaminate persisted history.
+   */
+  toMessages: (options?: ToWireMessagesOptions) => Promise<SessionMessage[]>;
+  /** Serialize to SessionData */
+  toJSON: () => SessionData;
+  /**
+   * The backing store, when one was provided. Exposed so hosts can call
+   * its optional `close()` on teardown (e.g. release the SQLite handle).
+   */
+  readonly store?: SessionStore;
 }
-/** Options for {@link createFileMapStore}. */
-interface FileMapStoreOptions {
-  /** Filename for the JSONL turns log. Default: `turns.jsonl`. */
-  turnsFile?: string;
-  /** Filename for the metadata JSON. Default: `meta.json`. */
-  metaFile?: string;
+/** Options for {@link createSession}. */
+interface CreateSessionOptions {
+  /** Session ID. If omitted and store provides generateSessionId, that is used. */
+  id?: string;
+  /** Agent ID label */
+  agentId?: string;
+  /**
+   * Project tag — see {@link SessionData.projectRoot}. Stamped once on
+   * creation; ignored when `_data` is set (restoring an existing
+   * session preserves whatever was already persisted there). The chat
+   * layer's session factory stamps `projectRootOf(cwd)` so sessions
+   * started from the same repo — any subdir, any linked worktree — share
+   * one tag.
+   */
+  projectRoot?: string;
+  /** Initial metadata */
+  metadata?: Record<string, unknown>;
+  /** Storage backend (optional, enables save/load) */
+  store?: SessionStore;
+  /**
+   * Observability hook for the load-time pairing heal: fired once per block
+   * or turn `dropInvalidToolPairings` deleted while restoring `_data`.
+   * Deletions are permanent once the session is saved, so hosts that alert
+   * on wire-time `pairing:repair` events should wire this to the same sink.
+   * Only fires on the `_data` restore path; fresh sessions never heal.
+   */
+  onPairingDrop?: (drop: PairingDrop) => void;
+  /**
+   * @internal: restore from existing data (bypasses id/agentId/metadata
+   * options). The session ALIASES this object for its lifetime — every
+   * mutation (appendTurns, run records, updatedAt) writes through to it,
+   * and the load-time pairing heal may replace its `turns` array in place
+   * before the session is returned. Callers must not retain independent
+   * ownership expectations.
+   */
+  _data?: SessionData;
 }
 /**
- * Create a single-session `SessionStore` backed by a file-map adapter.
- *
- * @param adapter - Host adapter that loads, saves and deletes the file map.
- * @param options - File names to use. See {@link FileMapStoreOptions}.
- * @example
- * ```ts
- * const session = await createSession({
- *   store: createFileMapStore(hostSessionStore),
- * })
- * ```
- */
-declare function createFileMapStore(adapter: FileMapAdapter, options?: FileMapStoreOptions): SessionStore;
-//#endregion
-//#region src/session/memory.d.ts
-/**
- * Creates an in-memory {@link SessionStore}. Nothing is persisted.
- *
+ * Create a new session.
+ * Async so stores that generate IDs server-side (e.g. a database) can be supported.
+ * @param options - Session identity, metadata and store. See {@link CreateSessionOptions}.
  * @example
  * ```ts
  * import { createMemoryStore, createSession } from 'zidane/session'
  *
- * const session = await createSession({ store: createMemoryStore() })
+ * const session = await createSession({ agentId: 'reviewer', store: createMemoryStore() })
+ * console.log(session.id, session.turns.length)
  * ```
  */
-declare function createMemoryStore(): SessionStore;
-//#endregion
-//#region src/session/remote.d.ts
-/** Options for {@link createRemoteStore}. */
-interface RemoteStoreOptions {
-  /** Base URL of the session API */
-  url: string;
-  /** Optional headers (e.g. for authentication) */
-  headers?: Record<string, string>;
-  /** Per-request timeout in ms. Default 30s — bounds a hung backend. */
-  timeoutMs?: number;
-}
+declare function createSession(options?: CreateSessionOptions): Promise<Session>;
 /**
- * Creates a {@link SessionStore} that talks to a REST session API over HTTP. See the module comment for the endpoints it calls.
- *
- * @param options - API base URL, headers and timeout.
- * @example
- * ```ts
- * import { createRemoteStore, createSession } from 'zidane/session'
+ * Demote a persisted `'running'` status to `'idle'` (in place) and return the
+ * data. A persisted `'running'` is necessarily stale: the run that set it lived
+ * in another process (crash, kill -9, power loss) and cannot still be executing
+ * in a freshly-loaded session. Call this on the result of a raw `store.load()`
+ * so consumers don't render a ghost in-progress state or refuse a new run.
+ * `loadSession` applies it automatically; direct `store.load()` callers (e.g.
+ * the TUI) should run loaded data through this.
  *
- * const store = createRemoteStore({ url: 'https://api.example.com', headers: { authorization: 'Bearer token' } })
- * const session = await createSession({ store })
- * ```
+ * Run RECORDS get the same treatment: the agent persists each record at
+ * run start with `status: 'running'` (crash durability — see the
+ * `SessionStore.updateRun` contract), so a freshly-loaded session may
+ * carry `'running'` runs that died with their process. They demote to
+ * `'aborted'` so replay renders a truthful "aborted" state instead of a
+ * perpetually-in-flight run.
+ * @param data - Loaded session data. It is modified in place.
  */
-declare function createRemoteStore(options: RemoteStoreOptions): SessionStore;
-//#endregion
-//#region src/session/index.d.ts
-/**
- * Run `fn` with `session` bound as the active extension session for the
- * duration of the call (and every async continuation it spawns). Uses
- * `AsyncLocalStorage.run` rather than `enterWith` so concurrent agents in the
- * same process (e.g. the GUI's multi-session host) never observe each other's
- * session through `currentExtensionSession()`.
- * @param session - Session to bind. When `undefined`, `fn` runs without a binding.
- * @param fn - Function to run with the binding in place.
- */
-declare function withExtensionSession<T>(session: Session | undefined, fn: () => T): T;
+declare function demoteStaleRunningStatus(data: SessionData): SessionData;
+/** Options for {@link loadSession}. */
+interface LoadSessionOptions {
+  /** Forwarded to `createSession` — see {@link CreateSessionOptions.onPairingDrop}. */
+  onPairingDrop?: (drop: PairingDrop) => void;
+  /**
+   * Write a load-time pairing heal back to the store (default true). Pass
+   * `false` from READERS — a window mirroring a session another process
+   * runs (daemon mode) — because the persist is a bulk turn overwrite and
+   * the owner's next load heals and persists it anyway.
+   */
+  persistHeal?: boolean;
+}
 /**
- * Returns the session bound by {@link withExtensionSession} for the current async context, or `undefined` when none is bound.
+ * Load an existing session from a store.
+ * @param store - Store to load from.
+ * @param sessionId - Id of the session to load.
+ * @param options - Load options. See {@link LoadSessionOptions}.
+ * @returns The session, or `null` when the store has no session with that id.
  */
-declare function currentExtensionSession(): Session | undefined;
+declare function loadSession(store: SessionStore, sessionId: string, options?: LoadSessionOptions): Promise<Session | null>;
+//#endregion
+//#region src/providers/model-catalog.d.ts
 /**
- * Reads one value an extension stored in the session metadata. Returns a copy, or `undefined` when the session, extension or key is missing or a name is unsafe.
+ * Model catalog override — the one seam for replacing model metadata.
  *
- * @param session - Session to read, if any.
- * @param extensionName - Name of the extension that owns the value.
- * @param key - Key under the extension namespace.
- */
-declare function getExtensionSessionState<T = JsonValue>(session: Session | undefined, extensionName: string, key: string): T | undefined;
-/**
- * Stores a JSON value under an extension namespace in the session metadata and saves the session when it has a store. Does nothing without a session.
+ * zidane resolves model metadata (output ceiling, pricing, context window,
+ * reasoning support) from pi-ai's bundled registry. That registry is a
+ * snapshot: it can't know a gateway alias, a private deployment, a model
+ * released after our dependency pin, or a non-Anthropic model served over the
+ * Anthropic wire. Without a seam, consumers either patch our source (the
+ * `EXTRA_COST_RATES` table in `cost.ts` exists because of exactly that) or
+ * mutate pi-ai's unfrozen catalog behind our back.
  *
- * Throws when a name is unsafe or the value exceeds the size limits (16 KiB per item, 64 KiB for all extension state).
+ * Two ways to supply one, both first-class:
  *
- * @param session - Session to write, if any.
- * @param extensionName - Name of the extension that owns the value.
- * @param key - Key under the extension namespace.
- * @param value - JSON value to store. It is copied.
+ *   - `behavior.modelCatalog` — per agent, and per run like every other
+ *     behavior field. No process-wide state, so two agents can carry
+ *     different catalogs.
+ *   - {@link setModelCatalog} — process-wide default. Also the only source
+ *     the chat/TUI layer can see (the model picker resolves metadata before
+ *     any agent exists).
+ *
+ * Resolution, first hit wins: run behavior → agent behavior → global →
+ * pi-ai's bundled registry → local fallback tables.
+ *
+ * Everything stays keyed by `(provider, modelId)`: nothing is flattened
+ * across providers, and overriding one provider leaves the others fully
+ * bundled. The provider key is the pi-ai registry id, which is usually the
+ * factory name (`anthropic`, `cerebras`, `openrouter`, …) — with one
+ * exception: the Codex provider stores model records under `openai-codex` and
+ * prices them under `openai`, and accepts an entry keyed EITHER way — on the
+ * wire via {@link aliasCatalogProviders} and in the host layer via the
+ * descriptor's key set, so an override can't half-apply.
+ *
+ * Two operational notes:
+ *
+ *   - **Serialization.** The table form is plain JSON; the `{ get, list }`
+ *     form holds functions. A durable / replay runtime that snapshots
+ *     `behavior` can only round-trip the table form — build the source form
+ *     inside the process that runs the agent, or install it with
+ *     {@link setModelCatalog} at boot.
+ *   - **Multi-tenancy.** {@link setModelCatalog} is process-wide, so in a
+ *     shared server it applies to every tenant. Pass `behavior.modelCatalog`
+ *     per agent / per run instead; the global is for a deployment-wide
+ *     correction and for the host's model picker.
  */
-declare function setExtensionSessionState(session: Session | undefined, extensionName: string, key: string, value: JsonValue): Promise<void>;
 /**
- * Removes one value from an extension namespace in the session metadata and saves the session when it has a store. Does nothing when the value does not exist.
- *
- * @param session - Session to modify, if any.
- * @param extensionName - Name of the extension that owns the value.
- * @param key - Key to remove.
+ * Size class of a model within its provider's lineup. Drives the automatic
+ * text model (titles, suggestions): the smallest current model of the
+ * session's provider. Bundled models get it from a family heuristic
+ * (`src/chat/text-model.ts`); a catalog entry's value wins over it.
  */
-declare function deleteExtensionSessionState(session: Session | undefined, extensionName: string, key: string): Promise<void>;
+type ModelTier = 'small' | 'medium' | 'large';
 /**
- * Transitive `resumedFromRunId` chain starting at `runId` (inclusive).
- *
- * A resumed run only persists the turns IT produced — the turns it was
- * seeded with still carry the original run's id. So reconstructing a
- * resumed child's full conversation means collecting turns from every run
- * in its resume lineage, not just the latest link. Cycle-guarded (a
- * malformed chain terminates instead of looping).
- * @param runs - Run records of the session.
- * @param runId - Run to start from.
+ * Metadata for one model. Every field is optional and merges FIELD-LEVEL over
+ * the bundled entry, so `{ maxTokens: 128000 }` corrects the ceiling and
+ * leaves pricing and context window to the registry.
  */
-declare function resumeChainRunIds(runs: readonly SessionRun[], runId: string): Set<string>;
-/** Record of one agent run inside a session. */
-interface SessionRun {
-  /** Run id. */
-  id: string;
-  /** Start time as epoch milliseconds. */
-  startedAt: number;
-  /** End time as epoch milliseconds. Absent while the run is in progress. */
-  endedAt?: number;
-  /** Prompt the run started with. */
-  prompt: string;
-  /** Run state. A persisted `running` run whose process died is shown as `aborted` on load. */
-  status: 'running' | 'completed' | 'aborted' | 'error';
-  /** Number of turns the run produced. */
-  turns?: number;
-  /** Input tokens used by the run. */
-  tokensIn?: number;
-  /** Output tokens used by the run. */
-  tokensOut?: number;
-  /** Error message when the run failed. */
-  error?: string;
-  /** What `error`'s one line leaves out (the provider's own text, a limit's reset). */
-  errorDetail?: RunErrorDetail;
-  /** Per-turn usage breakdown */
-  turnUsage?: TurnUsage[];
-  /** Total usage across all turns */
-  totalUsage?: TurnUsage;
-  /** Estimated cost in USD */
-  cost?: number;
-  /**
-   * The run that spawned this one, when the agent is a subagent sharing its
-   * parent's session. Undefined on top-level `agent.run()`. Consumers can walk
-   * `runs` by `parentRunId` to reconstruct the subagent tree.
-   */
-  parentRunId?: string;
-  /**
-   * The prior run this one continues (see `AgentRunOptions.resumeRunId`).
-   * Set when a stopped/failed subagent run was resumed — consumers can
-   * chain runs by `resumedFromRunId` to render “child-4 (resumes child-2)”
-   * style markers. Absent on normal runs.
-   */
-  resumedFromRunId?: string;
-  /**
-   * Host-assigned display label (e.g. the spawn tool's `child-3`), persisted
-   * so label → run resolution is a stored fact instead of a positional
-   * guess. Positional `child-N` numbering can desynchronize from announced
-   * labels (concurrent spawns `startRun` out of reservation order, a
-   * pre-`startRun` throw advances the counter without a run, and reload
-   * ordering ties break lexicographically) — resolving by stored label is
-   * immune to all three. Absent on top-level runs and legacy sessions.
-   */
-  label?: string;
-  /**
-   * The `spawn` tool call that started this run, in the parent's turn (see
-   * `AgentRunOptions.parentCallId`): pairs a child with its call exactly,
-   * where parallel calls share a task. Absent on top-level runs and older
-   * sessions.
-   */
-  parentCallId?: string;
-  /**
-   * Zero-based subagent depth. 0 = top-level run, 1 = direct child, …
-   * Recorded here so hosts can query/filter by level without walking the tree.
-   */
-  depth?: number;
+interface ModelCatalogEntry {
+  /** Model id. Required only for entries surfaced through {@link ModelCatalogSource.list}. */
+  id?: string;
+  /** Display name for pickers. */
+  name?: string;
+  /** Max output tokens — the provider's `max_tokens` default and hard clamp. */
+  maxTokens?: number;
+  /** Total context window, in tokens (drives the host-layer context gauge). */
+  contextWindow?: number;
+  /** Whether the model supports reasoning/thinking. */
+  reasoning?: boolean;
+  /** Accepted input modalities. */
+  input?: readonly ('text' | 'image')[];
   /**
-   * How this run was initiated when not a plain user prompt. `command` marks
-   * a sub-run driven from a `/` command's `ctx.runAgent`; `display` is the
-   * short line the transcript shows instead of the full injected prompt
-   * (which often embeds bulky material like a diff). Presentation-only —
-   * the wire/model payload is unaffected. Absent on normal runs.
+   * Per-MTok rates used for cost estimation. Merges PER-RATE over the bundled
+   * rates, so `{ cost: { output: 30 } }` corrects the output rate and keeps the
+   * registry's input / cache rates rather than zeroing them.
    */
-  origin?: {
-    kind: 'command';
-    display?: string;
+  cost?: {
+    input?: number;
+    output?: number;
+    cacheRead?: number;
+    cacheWrite?: number;
   };
+  /** Size class; overrides the family heuristic. */
+  tier?: ModelTier;
 }
-/** A session's turns and runs: what a history edit reads and writes (`SessionStore.mutateHistory`). */
-interface SessionHistory {
-  /** The session's turns, in order. */
-  turns: SessionTurn[];
-  /** The session's runs, in order. */
-  runs: SessionRun[];
-}
-/** Persisted form of a session: identity, turns, runs and metadata. */
-interface SessionData {
-  /** Session id. */
-  id: string;
-  /** Label of the agent profile that owns the session. */
-  agentId?: string;
+/**
+ * Programmatic catalog. Both members are optional and both fall through on
+ * `undefined`, which is what keeps overrides scoped to the providers you
+ * actually own.
+ */
+interface ModelCatalogSource {
   /**
-   * Absolute path of the project this session belongs to — typically
-   * the git root resolved from `cwd` at creation time, falling back to
-   * `cwd` itself when not in a git repo. Set ONCE on creation and never
-   * mutated thereafter (the session "belongs" to that project forever).
-   *
-   * Used by the TUI's sessions list to filter rows by current project,
-   * so the user only sees conversations relevant to where they are
-   * working — without needing one `.{prefix}/` directory per project.
+   * Resolve one model. Return `undefined` to fall through to the bundled
+   * entry for that `(provider, modelId)`.
+   */
+  get?: (provider: string, modelId: string) => ModelCatalogEntry | undefined;
+  /**
+   * Enumerate a provider's models (model pickers, `modelsForDescriptor`).
    *
-   * `undefined` on pre-tagging legacy sessions; the chat layer treats
-   * those as "untagged" and hides them unless `Settings.showAllProjects`
-   * is on.
+   *   - `undefined` → use the bundled list for that provider (the default).
+   *   - `[…]`       → you own that provider's list; bundled entries are not
+   *                   consulted, so this both adds and hides.
+   *   - `[]`        → you own it and it has no models (hides the picker).
    */
-  projectRoot?: string;
-  /** Turn history, oldest first. */
-  turns: SessionTurn[];
-  /** Records of the runs in this session. */
-  runs: SessionRun[];
-  /** Session state. A persisted `running` status is stale after a restart and is shown as `idle` on load. */
-  status: 'idle' | 'running' | 'completed' | 'error';
-  /** Free-form metadata, such as the title, model and extension state. */
-  metadata: Record<string, unknown>;
-  /** Creation time as epoch milliseconds. */
-  createdAt: number;
-  /** Last update time as epoch milliseconds. */
-  updatedAt: number;
+  list?: (provider: string) => readonly ModelCatalogEntry[] | undefined;
 }
 /**
- * Compact per-session summary returned by {@link SessionStore.listMeta}.
- * Raw facts only — presentation (title derivation, fallback strings)
- * stays in the chat layer (`listSessionMeta` / `deriveSessionTitle`).
+ * A catalog: either a {@link ModelCatalogSource} or the table shorthand —
+ * a plain record keyed `"<provider>:<modelId>"`.
+ *
+ * The table form is a pure OVERLAY: entries patch or add models, and each
+ * provider keeps every bundled model the table doesn't name. Hiding bundled
+ * models requires the `list` function, so the easy path can't accidentally
+ * blank a provider's picker.
+ *
+ * ```ts
+ * setModelCatalog({ 'openai:gpt-5.6': { maxTokens: 128000 } })
+ * ```
  */
-interface SessionMetaRow {
-  /** Session id. */
-  id: string;
-  /** Header metadata (may carry a stored `title`). */
-  metadata: Record<string, unknown>;
-  /** Absent for untagged (legacy) sessions. */
-  projectRoot?: string;
-  /** Last update time as epoch milliseconds. */
-  updatedAt: number;
-  /**
-   * The store's change counter for this session: bumped by every write to
-   * it (in the write's own transaction), so it only grows, whatever
-   * `updatedAt` a writer stamps. Absent from stores that keep none.
-   */
-  rev?: number;
-  /** Number of turns. */
-  turnCount: number;
-  /** Count of `role: 'user'` turns. */
-  userMessageCount: number;
-  /** Number of run records. */
-  runCount: number;
-  /**
-   * First `role: 'user'` turn — the title-derivation source. Stores may
-   * omit it when `metadata.title` is already set (no derivation needed).
-   */
-  firstUserTurn?: SessionTurn;
-  /**
-   * Header fields consumers like the daemon's `sessions.list` need to
-   * build full rows without a per-session `load()`. Optional (additive
-   * contract extension) — callers fall back to `load()` when absent.
-   */
-  agentId?: string;
-  /** Creation time as epoch milliseconds. */
-  createdAt?: number;
-  /** Session state. */
-  status?: SessionData['status'];
-  /**
-   * Number of artifacts recorded for the session. Optional (additive):
-   * only stores implementing the artifact methods populate it; consumers
-   * treat absence as "unknown", not zero.
-   */
-  artifactCount?: number;
-}
+type ModelCatalog = ModelCatalogSource | Readonly<Record<string, ModelCatalogEntry>>;
 /**
- * Storage backend for sessions. Implement it to persist sessions somewhere else, or use a bundled store: memory, SQLite, remote or file map.
+ * Install (or clear, with `null`) the process-wide catalog. Latest call wins.
+ *
+ * Prefer `behavior.modelCatalog` when you can: it needs no global state and
+ * scopes to one agent or one run. Use this for a deployment-wide correction,
+ * or when the host's model picker must see the override too.
+ *
+ * @param catalog - Catalog to install, or `null` to clear it.
  */
-interface SessionStore {
-  /** Optional: generate a session ID server-side (e.g. a database-issued UUID). */
-  generateSessionId?: () => string | Promise<string>;
-  /**
-   * Optional: generate a turn ID server-side for session-managed user turns.
-   *
-   * Provider-loop assistant and tool-result turns use AgentClock.randomUUID()
-   * instead, so durable-execution adapters can keep those IDs replay-stable.
-   */
-  generateTurnId?: () => string | Promise<string>;
-  /** Load a session by ID. Returns null if not found. */
-  load: (sessionId: string) => Promise<SessionData | null>;
-  /**
-   * Save a session (create or update, full document). Bulk overwrite:
-   * turns and runs on disk are replaced by the caller's snapshot, so a
-   * stale snapshot silently discards anything another writer appended.
-   * `Session.save()` only routes here when the turn list was explicitly
-   * replaced (`setTurns` / `setRuns` / load-time heal); everything else
-   * goes through {@link saveMeta}.
-   */
-  save: (session: SessionData) => Promise<void>;
-  /**
-   * Optional: persist header fields only (agentId, projectRoot, status,
-   * metadata, timestamps) plus an UPSERT of the runs present in the
-   * snapshot — never deletes turns or runs. This is what metadata writes
-   * (title, model, todos, extension state) need.
-   *
-   * Scope of the guarantee: TURNS appended by a concurrent process survive.
-   * The header itself is still last-writer-wins — `status` and `agentId`
-   * are written wholesale from the caller's snapshot, and so is `metadata`
-   * unless `options.metaKeys` names the changed keys (`Session.save()`
-   * always does; stores merge them with {@link mergeSessionMetadata}), and every run in the snapshot is upserted as-is (a reader
-   * that loaded through `loadSession` carries the in-memory stale-running
-   * demotion, so it can write `idle` / `aborted` over a live owner's marker
-   * until the owner's next write). Readers that only need one key should
-   * prefer a keyed patch (the host's `patchSessionMeta`) over `save()`.
-   * Stores that omit it fall back to `save`, keeping the historical bulk
-   * semantics.
-   */
-  saveMeta?: (session: SessionData, options?: SaveMetaOptions) => Promise<void>;
-  /** Delete a session. */
-  delete: (sessionId: string) => Promise<void>;
-  /**
-   * List session IDs, optionally filtered. `projectRoot` restricts to
-   * sessions whose `SessionData.projectRoot` matches exactly — untagged
-   * (legacy) sessions are NOT returned under that filter; pass `null`
-   * explicitly to ask for untagged ones, or omit the field to ignore
-   * the axis entirely. `agentId` filters by recorded agent; the two
-   * conditions AND together when both are set.
-   */
-  list: (filter?: {
-    agentId?: string;
-    limit?: number;
-    projectRoot?: string | null;
-  }) => Promise<string[]>;
+declare function setModelCatalog(catalog: ModelCatalog | null): void;
+/** The process-wide catalog, normalized to source form. */
+declare function getModelCatalog(): ModelCatalogSource | undefined;
+//#endregion
+//#region src/thinking-levels.d.ts
+/**
+ * Thinking / extended-reasoning configuration. Dependency-free, so the
+ * browser-safe surfaces (`zidane/chat/pure`) can validate a stored effort.
+ *
+ * - `'off'` — no thinking.
+ * - `'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max'` — explicit
+ *   effort tier. Maps to provider-specific reasoning controls (Anthropic
+ *   `output_config.effort`; OpenAI-compatible providers clamp to their
+ *   supported tiers).
+ * - `'adaptive'` — let the model decide per-turn whether and how much to think.
+ *   Anthropic-only (`thinking.type='adaptive'`). Other providers fall back to
+ *   no reasoning when this value is supplied.
+ */
+declare const THINKING_LEVELS: readonly ["off", "minimal", "low", "medium", "high", "xhigh", "max", "adaptive"];
+/** One of the {@link THINKING_LEVELS} strings: how much the model reasons before it answers. */
+type ThinkingLevel = (typeof THINKING_LEVELS)[number];
+/**
+ * Type guard for canonical `ThinkingLevel` strings (e.g. `metadata.effort` read off a persisted session).
+ *
+ * @param value - Any value, usually a string read from storage or settings.
+ */
+declare function isThinkingLevel(value: unknown): value is ThinkingLevel;
+//#endregion
+//#region src/mcp/transport.d.ts
+/**
+ * Line-splitting core shared by the two stderr pumps: the Node-stream one
+ * below (host stdio children) and the async-iterable one in
+ * `./context-transport.ts` (children living in an execution context).
+ * Same buffering, same overlong-line cap, same fire-and-forget `mcp:warn`.
+ * @param serverName - Server name reported in each `mcp:warn` payload.
+ * @param hooks - Agent hooks to fire `mcp:warn` on. Lines are dropped when `undefined`.
+ */
+declare function createStderrLineEmitter(serverName: string, hooks: Hookable<AgentHooks> | undefined): {
+  push: (text: string) => void;
+  flush: () => void;
+};
+/**
+ * Reads a stdio child's stderr to the end and fires `mcp:warn` for each non-empty line. Does nothing when the transport has no stderr stream.
+ *
+ * @param transport - Transport that may expose a `stderr` stream.
+ * @param serverName - Server name reported in each `mcp:warn` payload.
+ * @param hooks - Agent hooks to fire `mcp:warn` on.
+ */
+declare function attachStderrWarnPump(transport: {
+  stderr?: {
+    on: (event: string, listener: (...args: unknown[]) => void) => unknown;
+  } | null;
+}, serverName: string, hooks: Hookable<AgentHooks> | undefined): void;
+/**
+ * The execution context + live handle a `scope: 'context'` stdio server is
+ * spawned into. Supplied by the agent once its handle exists; absent for
+ * host-only setups, which is why every field is required here but the
+ * binding itself is optional at the call site.
+ */
+interface McpExecutionBinding {
+  /** Execution context that hosts the server process. */
+  context: ExecutionContext;
   /**
-   * Optional: list session summaries without materializing full sessions.
-   *
-   * The generic fallback (`listSessionMeta` in `zidane/chat`) is `list()`
-   * + `load()` per id — O(every turn in the store) because each `load`
-   * parses the full turn history just to count rows and derive a title.
-   * Stores that can answer from an index (SQL aggregates, a denormalized
-   * header) should implement this; the sqlite store turns a multi-hundred-
-   * ms TUI boot cost into a single query.
+   * Resolve the execution handle, invoked ONLY when a `scope: 'context'`
+   * stdio server actually builds its transport.
    *
-   * Same filter contract and ordering (most recently updated first) as
-   * {@link list}.
-   */
-  listMeta?: (filter?: {
-    agentId?: string;
-    limit?: number;
-    projectRoot?: string | null;
-  }) => Promise<SessionMetaRow[]>;
-  /**
-   * Optional: one session's header row WITHOUT materializing turns.
-   * Hot-path reads (the cross-process run guard checks `status` +
-   * `updatedAt` on every prompt send) must not pay a multi-MB turn parse
-   * on long sessions. Callers fall back to `load()` when absent.
-   */
-  getMeta?: (sessionId: string) => Promise<SessionMetaRow | null>;
-  /** Append new turns to a session (incremental, avoids full re-save). */
-  appendTurns: (sessionId: string, turns: SessionTurn[]) => Promise<void>;
-  /** Return a slice of turns for a session. */
-  getTurns: (sessionId: string, from?: number, limit?: number) => Promise<SessionTurn[]>;
-  /**
-   * Optional: rewrite a session's history as ONE atomic read-modify-write,
-   * so turns appended between the read and the write can't be erased (a
-   * `load()` + `save()` pair can). `mutate` gets the current turns and
-   * runs and returns the next ones, or `null` to leave them untouched; a
-   * throw inside it aborts without writing. Runs are written only when it
-   * returns a different `runs` array. History edits (delete / edit a turn,
-   * rewind) use it when present and fall back to `load()` + `save()`.
-   */
-  mutateHistory?: (sessionId: string, mutate: (history: SessionHistory) => SessionHistory | null) => Promise<'ok' | 'no-session' | 'unchanged'>;
-  /**
-   * Optional: the turns-only form of {@link SessionStore.mutateHistory}.
-   * When `mutateHistory` is absent, edits that leave the runs alone (delete
-   * or edit a turn) use it; a rewind falls back to `load()` + `save()`.
-   * @deprecated Implement `mutateHistory` instead.
+   * Lazy on purpose. An eagerly-resolved handle would make merely *having* a
+   * context-scoped server in the config force a sandbox spawn — including
+   * for sub-agents, which inherit `mcpServers` but reuse the parent's live
+   * connection through `nonOwningMcpConnector` and never touch this binding.
+   * That would cold-boot a fresh sandbox per `spawn()` for nothing. Deferring
+   * also means the agent needs no ordering special case: the handle is
+   * created at the moment of first use, which is necessarily before the
+   * `execStream` call that needs it.
    */
-  mutateTurns?: (sessionId: string, mutate: (turns: SessionTurn[]) => SessionTurn[] | null) => Promise<'ok' | 'no-session' | 'unchanged'>;
-  /**
-   * Persist a run record (called at run start with `status: 'running'`, and
-   * after completeRun / abortRun / errorRun).
-   *
-   * **Upsert semantics required.** The agent's run lifecycle calls
-   * `session.startRun()` to register a new run in IN-MEMORY state and
-   * then `updateRun()`. The store doesn't see the run before the first
-   * `updateRun()` — `appendTurns` persists turns but not runs. An
-   * update-only implementation would silently drop every newly-created
-   * run record, leaving
-   * the on-disk `runs[]` missing entries that the persisted turns
-   * reference (which `eventsFromTurns` then mis-classifies via
-   * `ancestryOf` → broken depth, broken `child-N` labels, broken
-   * `userPrompts` history).
-   *
-   * Implementations MUST insert when the id doesn't exist and update
-   * when it does. The bundled `sqlite` / `memory` / `file-map` stores
-   * all follow this contract; remote stores using HTTP PUT get upsert
-   * for free via REST semantics.
-   */
-  updateRun: (sessionId: string, run: SessionRun) => Promise<void>;
-  /**
-   * Update the top-level status of a session.
-   *
-   * `preserveUpdatedAt` (default false) writes the status WITHOUT
-   * touching `updatedAt` — for pure-read heals (`loadSession`'s stale
-   * `'running'` demotion) that must not reorder recency-sorted session
-   * lists. Best-effort contract: stores that don't manage `updatedAt`
-   * themselves (memory, file-map, remote) may ignore the option; the
-   * sqlite store honors it.
-   */
-  updateStatus: (sessionId: string, status: SessionData['status'], options?: {
-    preserveUpdatedAt?: boolean;
-  }) => Promise<void>;
-  /**
-   * Optional: record an artifact (see `./artifacts.ts`). Upsert on
-   * `(sessionId, kind, uri)` — an existing row keeps its `id` / `runId` /
-   * `turnId` / `createdAt` and refreshes `label` / `meta` / `updatedAt`
-   * (`mergeArtifact`). Resolves to the canonical stored row. Unknown
-   * session ids are a no-op returning `null` (no ghost headers; same
-   * posture as `updateRun`). Implementations enforce
-   * `ARTIFACTS_PER_SESSION_CAP` via `selectArtifactEvictions`.
-   *
-   * Every artifact method is optional: stores that don't implement them
-   * (file-map, remote, third-party) keep working — `Session.addArtifact`
-   * degrades to a no-op and listings come back empty.
-   */
-  upsertArtifact?: (artifact: SessionArtifact) => Promise<SessionArtifact | null>;
-  /**
-   * Optional: list artifacts, newest `updatedAt` first. `filter.sessionId`
-   * scopes to one session; `filter.projectRoot` follows the tri-state
-   * contract of {@link list}; omit both for every artifact in the store.
-   */
-  listArtifacts?: (filter?: ArtifactFilter) => Promise<SessionArtifact[]>;
-  /** Optional: remove one artifact. Unknown ids are a no-op. */
-  deleteArtifact?: (sessionId: string, artifactId: string) => Promise<void>;
-  /**
-   * Optional: release backend resources (e.g. close the SQLite handle).
-   * Hosts should call this on teardown when present; stores backed by
-   * memory or remote HTTP have nothing to release and may omit it.
-   */
-  close?: () => void;
+  getHandle: () => Promise<ExecutionHandle>;
 }
+//#endregion
+//#region src/mcp/origin-pinned-fetch.d.ts
 /**
- * A live session: the turn history and run records of one conversation, with an optional store that persists them.
+ * The transport-reachability rule for a remote MCP endpoint: HTTPS anywhere,
+ * plaintext HTTP only when it stays on the machine, nothing else.
+ *
+ * THE single encoding of that policy. It's enforced at two points on opposite
+ * sides of the plugin boundary — once when validating a plugin's `mcp.json`
+ * (`plugins/mcp.ts`), and again per redirect hop inside
+ * {@link originPinnedFetch} — and those two must never disagree. If they did,
+ * a URL the loader refused could still be reached by redirect, which is the
+ * exact hole the pinning exists to close. Relaxing the rule (private ranges,
+ * `*.localhost`, …) is then a one-line change that both sites inherit.
+ *
+ * Scheme and host only. Authoring rules that apply to a CONFIGURED url but
+ * have no meaning for a redirect target — no userinfo, no fragment — stay with
+ * the loader.
+ * @param url - Endpoint to check.
  */
-interface Session {
-  /** Session ID */
-  readonly id: string;
-  /** Agent ID (optional label) */
-  readonly agentId?: string;
-  /**
-   * Re-label the session's agent profile (in memory; persisted by the
-   * next `save()`). Sessions remember their profile — pickers restore it
-   * on activation and other windows converge on it via `sessions.touch`.
-   */
-  setAgentId: (agentId: string) => void;
-  /**
-   * Project this session was created under — see {@link SessionData.projectRoot}.
-   * Set once on creation; surfaces here for read-only inspection.
-   */
-  readonly projectRoot?: string;
-  /**
-   * Raw persisted turn history — kept pristine for fidelity (the model's
-   * reasoning chain stays intact across reloads).
-   *
-   * **DO NOT pass this directly to a provider request.** Mid-pair
-   * persistence (interrupted runs, partial-result writes, compaction
-   * boundaries) leaves orphan `tool_use` / `tool_result` blocks here that
-   * every provider 400s on (`tool_result must be preceded by a tool_call
-   * with the same toolCallId`). The agent's own loop repairs these
-   * just-in-time at wire-send time and never writes the repair back to
-   * `turns`.
-   *
-   * For provider requests built outside `agent.run()`, use
-   * {@link Session.toMessages} — it applies the same defensive pairing
-   * repair and resolves to a guaranteed-safe `SessionMessage[]`.
-   */
-  readonly turns: SessionTurn[];
-  /**
-   * True when this session has no turns yet.
-   *
-   * Use this as a first-prompt signal when setting up a run — e.g. writing initial
-   * configuration only on fresh sessions. Equivalent to `turns.length === 0`.
-   */
-  readonly isEmpty: boolean;
-  /** Top-level session status */
-  readonly status: SessionData['status'];
-  /** All runs in this session */
-  readonly runs: SessionRun[];
-  /** Arbitrary metadata */
-  readonly metadata: Record<string, unknown>;
-  /** Creation time as epoch milliseconds. */
-  readonly createdAt: number;
-  /** Last update time as epoch milliseconds. */
-  readonly updatedAt: number;
-  /**
-   * Start tracking a new run. `extras.parentRunId` + `extras.depth` are
-   * populated by the spawn tool when a child agent shares its parent's
-   * session; regular top-level `agent.run()` calls omit them.
-   */
-  startRun: (runId: string, prompt?: string, extras?: {
-    parentRunId?: string;
-    depth?: number;
-    resumedFromRunId?: string;
-    label?: string;
-    parentCallId?: string;
-  }) => void;
-  /** Mark a run as completed */
-  completeRun: (runId: string, stats: {
-    turns: number;
-    tokensIn: number;
-    tokensOut: number;
-    turnUsage?: TurnUsage[];
-    cost?: number;
-  }) => void;
-  /**
-   * Mark a run as aborted. Optional `stats` lets the agent backfill the run's token totals when
-   * the abort happened *after* the loop accumulated meaningful usage —
-   * common when the user presses esc mid-streaming. Without it, the run
-   * record reads `0 in / 0 out` on reload regardless of how much was
-   * spent before the abort. Same shape as `completeRun`'s stats so the
-   * persisted `totalUsage` aggregate stays consistent across paths.
-   */
-  abortRun: (runId: string, stats?: {
-    turns: number;
-    tokensIn: number;
-    tokensOut: number;
-    turnUsage?: TurnUsage[];
-    cost?: number;
-  }) => void;
-  /** Mark a run as errored. Optional `stats` — same rationale as `abortRun.stats`. */
-  errorRun: (runId: string, error: string, stats?: {
-    turns: number;
-    tokensIn: number;
-    tokensOut: number;
-    turnUsage?: TurnUsage[];
-    cost?: number;
-  }, detail?: RunErrorDetail) => void;
-  /** Append turns to in-memory history AND persist via store.appendTurns (if store present) */
-  appendTurns: (turns: SessionTurn[]) => Promise<void>;
-  /** Replace all turns in-memory (does not persist — use save() for that) */
-  setTurns: (turns: SessionTurn[]) => void;
-  /**
-   * Replace all runs in-memory (does not persist — use save() for that).
-   * Mirrors {@link setTurns} for the fork / restore case: callers that
-   * bootstrap a session from an externally-derived snapshot (e.g.
-   * `onForkTurn` copying parent runs into a child session) need this so
-   * the cloned runs land in `data.runs` before the first `save()`.
-   * Production agent runs continue to mutate runs via `startRun` /
-   * `completeRun` / `updateRun`; this is the bulk-replace escape hatch.
-   */
-  setRuns: (runs: SessionRun[]) => void;
-  /** Update the session status in memory AND via store.updateStatus (if store present) */
-  updateStatus: (status: SessionData['status']) => Promise<void>;
-  /** Persist an updated run record via store.updateRun (if store present) */
-  updateRun: (run: SessionRun) => Promise<void>;
-  /** Generate a session-managed turn ID using store.generateTurnId if available, else crypto.randomUUID() */
-  generateTurnId: () => string | Promise<string>;
-  /** Set metadata key. `touch: false` keeps `updatedAt` (a rename or a favorite is not activity). */
-  setMeta: (key: string, value: unknown, options?: {
-    touch?: boolean;
-  }) => void;
-  /**
-   * Record an artifact this session produced. Fills `id`, timestamps and
-   * defaults `projectRoot` to the session's own; `origin` ties it to the
-   * producing run/turn for transcript anchoring. Resolves to the stored
-   * row, or `undefined` when there is no store or the store doesn't
-   * implement artifacts (never throws for that case — emission is
-   * best-effort by contract).
-   */
-  addArtifact: (input: SessionArtifactInput, origin?: {
-    runId?: string;
-    turnId?: string;
-  }) => Promise<SessionArtifact | undefined>;
-  /** This session's artifacts, newest first. Empty when unsupported. */
-  listArtifacts: (filter?: Pick<ArtifactFilter, 'kind' | 'since' | 'limit'>) => Promise<SessionArtifact[]>;
-  /**
-   * Persist the session to the store. When the store implements `saveMeta`,
-   * this writes the header, the changed metadata keys and the runs, and leaves
-   * turns alone, unless `setTurns` or `setRuns` replaced them. In every other
-   * case it overwrites the whole document through `store.save`. Throws when
-   * the session has no store.
-   */
-  save: () => Promise<void>;
+declare function isAllowedRemoteUrl(url: URL): boolean;
+/**
+ * The fetch shape this wrapper supports — deliberately narrower than
+ * `typeof fetch`, matching the MCP SDK's `FetchLike`.
+ *
+ * A `Request` input is NOT accepted: the wrapper rebuilds each hop from
+ * `init`, so it would silently drop a Request's method, headers and body and
+ * issue a bare credential-less GET. Narrowing the type makes that shape
+ * unrepresentable rather than a quiet failure on a security-relevant helper.
+ * Both SDK transports only ever pass a URL plus init.
+ */
+type PinnedFetch = (url: string | URL, init?: RequestInit) => Promise<Response>;
+/**
+ * Wrap `baseFetch` so `headerNames` are dropped on any hop that leaves the
+ * origin of `configuredUrl`, and so a redirect cannot downgrade the session
+ * to cleartext.
+ *
+ * `authorization` is ALWAYS protected, whether or not the caller listed it.
+ * The MCP SDK's OAuth provider injects that header per request rather than
+ * through `McpServerConfig.headers` — `bootstrapServer` attaches a provider to
+ * a flagless server whenever stored tokens exist — so a strip list derived
+ * only from the configured header names would leave the bearer token exposed
+ * on exactly the servers that have one.
+ * @param configuredUrl - Configured server URL. Its origin is the pinned origin.
+ * @param headerNames - Configured header names to drop when a redirect leaves the pinned origin.
+ * @param baseFetch - Fetch implementation to wrap. Default: the global `fetch`.
+ */
+declare function originPinnedFetch(configuredUrl: string, headerNames: readonly string[], baseFetch?: PinnedFetch): PinnedFetch;
+//#endregion
+//#region src/mcp/server-config.d.ts
+/**
+ * The config a transport is actually built from.
+ *
+ * `${VAR}` placeholders resolve HERE, not at normalize time — see
+ * {@link expandMcpConfigEnv} for why (config writers round-trip normalized
+ * configs to disk; expanded secrets must never ride along).
+ *
+ * A `preExpanded` config skips the pass entirely. The Agent Plugins loader
+ * has already substituted the only two placeholders that spec permits, in
+ * only the three fields it permits, so a second pass would both widen the
+ * scope (into `command` / `url` / `headers`) and let an ambient
+ * `PLUGIN_ROOT` env var reach text the spec says stays literal. See
+ * {@link McpServerConfig.preExpanded}.
+ * @param config - Normalized server config.
+ */
+declare function resolveTransportConfig(config: McpServerConfig): McpServerConfig;
+/**
+ * Expand environment-variable placeholders in one config string. The
+ * `:-default` form follows shell semantics — the default substitutes when
+ * the variable is unset OR EMPTY (that's what `:-` means in every shell,
+ * and what users pasting the form expect; empty-but-set without a default
+ * still expands to the empty string, as `${VAR}` does in a shell). An
+ * unset variable without a default is left VERBATIM (matching Claude
+ * Code) — a literal `${…}` failing loudly at the server beats an empty
+ * token failing mysteriously — and a debug-gated warning names the
+ * missing variable.
+ * @param value - String that may contain `${VAR}`, `${VAR:-default}` or `${env:VAR}`.
+ * @param env - Variables to resolve against. Default: `process.env`.
+ */
+declare function expandEnvPlaceholders(value: string, env?: Record<string, string | undefined>): string;
+/**
+ * Expanded COPY of a server config for runtime use — `${VAR}` placeholders
+ * resolved across every string field that can carry secrets or
+ * machine-specific paths (command, args, env/header values, url, cwd).
+ *
+ * Deliberately NOT part of `normalizeMcpServers`: normalized configs are
+ * round-tripped back to disk by config writers (e.g. the Claude import
+ * copies parsed entries into zidane-owned `mcps.json`), and expanding
+ * there would MATERIALIZE resolved tokens into files. Expansion happens
+ * only at the transport boundary ({@link createTransport}, the login
+ * flow's mirror) — secrets exist in the connecting process's memory and
+ * nowhere else.
+ * @param config - Server config to expand.
+ * @param env - Variables to resolve against. Default: `process.env`.
+ */
+declare function expandMcpConfigEnv(config: McpServerConfig, env?: Record<string, string | undefined>): McpServerConfig;
+/**
+ * A config from a source that must never read this process's environment
+ * (a machine's project file, `docs/MACHINES.md`): every `${VAR}` placeholder
+ * resolved NOW to its `:-default`, else to the empty string, so the
+ * transport's own expansion has nothing of this process's secrets to put
+ * into a command, an env value, a URL or a header.
+ * @param config - Server config to strip.
+ */
+declare function withoutEnvPlaceholders(config: McpServerConfig): McpServerConfig;
+/**
+ * Unprivileged TCP port: the loopback listener can't bind below 1024 without root.
+ * @param port - Value to check.
+ */
+declare function isValidCallbackPort(port: unknown): port is number;
+/**
+ * The loopback redirect a pinned `oauth.callbackPort` produces: the URL to
+ * register with the provider. Pass the same `callbackPath` given to
+ * `loginMcpServer`, if any.
+ * @param config - Server config. Only `oauth.callbackPort` is read.
+ * @param callbackPath - Path of the callback URL.
+ * @returns The redirect URL, or `undefined` when no callback port is pinned.
+ */
+declare function pinnedMcpRedirectUri(config: Pick<McpServerConfig, 'oauth'>, callbackPath?: string): string | undefined;
+/**
+ * Normalize MCP server configs from any common shape to `McpServerConfig[]`.
+ *
+ * Accepts:
+ * - `McpServerConfig[]` — zidane native (pass-through).
+ * - `McpServerConfig` — a single config object (wrapped to a 1-element array).
+ * - `Record<string, RawShape>` — name-keyed map (common in host-SDK configs), where the key is the server name.
+ * - Mixed shapes with `type` vs `transport`, `httpUrl`/`sseUrl` vs `url`.
+ *
+ * Returns `[]` when `input` is nullish. Throws a descriptive error when the transport
+ * cannot be inferred from a given entry, or when the input shape is unsupported.
+ * @param input - Server configs in any of the accepted shapes, or nullish.
+ */
+declare function normalizeMcpServers(input: unknown): McpServerConfig[];
+//#endregion
+//#region src/mcp/tool-meta.d.ts
+/**
+ * Non-owning view of a live MCP connection: the SAME tools and
+ * instructions, but a no-op `close`. Handed to consumers that must never
+ * tear down transports they don't own — the loop's per-call
+ * `ToolContext.mcpConnection` and child agents spawned off the parent's
+ * connection — because only the owning agent's destroy path may close the
+ * real thing, and a doc comment alone is too weak a guard. Single shared
+ * builder so the call sites can't drift when this shape grows a field.
+ * @param connection - Connection to view. Only its `tools` and `instructions` are read.
+ */
+declare function nonOwningMcpView(connection: Pick<McpConnection, 'tools' | 'instructions'>): McpConnection;
+/**
+ * Recover a discovered tool's `{ server, toolName }` from its namespaced name
+ * (`mcp_<server>_<tool>`). Both server and tool names can contain underscores,
+ * so this matches against the known server list by longest server-name prefix
+ * rather than splitting blindly. Tools that match no configured server (custom
+ * connectors with a different naming scheme) fall back to
+ * `{ server: '', toolName: <namespacedName> }`.
+ * @param namespacedName - Tool name of the form `mcp_<server>_<tool>`.
+ * @param servers - Configured servers to match the prefix against.
+ */
+declare function deriveMcpToolMeta(namespacedName: string, servers: readonly McpServerConfig[]): McpToolMeta;
+/**
+ * Apply an {@link McpToolWrap} to every entry of a discovered-tool map,
+ * resolving each tool's {@link McpToolMeta} from `servers`. Returns a fresh
+ * map; the input is untouched. Used by the agent to apply the
+ * `AgentOptions.mcpToolWrap` hook to discovered tools.
+ * @param tools - Discovered tools keyed by namespaced name.
+ * @param wrap - Wrapper applied to each tool.
+ * @param servers - Configured servers used to resolve each tool's metadata.
+ */
+declare function wrapDiscoveredMcpTools(tools: Record<string, ToolDef>, wrap: McpToolWrap, servers: readonly McpServerConfig[]): Record<string, ToolDef>;
+//#endregion
+//#region src/mcp/tool-result.d.ts
+/**
+ * Lossy flattener — converts MCP `CallToolResult.content` blocks to a single
+ * string. Text blocks are extracted; non-text blocks are JSON-stringified.
+ *
+ * Use this only at UI / log boundaries that require a string. The agent
+ * loop itself routes through {@link normalizeMcpBlocks} so image blocks
+ * survive into provider-native tool_result content (Anthropic blocks,
+ * OpenAI companion-user-message).
+ * @param content - `CallToolResult.content` from an MCP tool call. Anything other than an array gives an empty string.
+ */
+declare function resultToString(content: unknown): string;
+/**
+ * Normalize MCP `CallToolResult.content` to zidane's {@link ToolResultContent[]} shape.
+ *
+ * Handles the MCP content block types:
+ * - `text` → preserved as `{type:'text', text}`
+ * - `image` → preserved as `{type:'image', mediaType, data}` (MCP uses `mimeType`)
+ * - `audio` → `{type:'audio', mediaType, data}`; mediaType reconciled/sniffed when
+ *   the declared `mimeType` is missing or not an `audio/*` type
+ * - `video` → `{type:'video', mediaType, data}` (non-standard, by analogy)
+ * - `resource` with embedded text → flattened to a text block
+ * - `resource` with embedded blob → routed to image/audio/video by sniffing bytes
+ *   first, with declared `mimeType` as a fallback when bytes are unidentifiable
+ *   (it's OPTIONAL on EmbeddedResource per the MCP spec, and often imprecise)
+ * - Any unrecognized block → JSON-stringified fallback text block (lossy but safe)
+ *
+ * Returns `null` when the input is not an array — callers should fall back to an empty
+ * result in that case.
+ * @param content - `CallToolResult.content` from an MCP tool call.
+ */
+declare function normalizeMcpBlocks(content: unknown): ToolResultContent[] | null;
+//#endregion
+//#region src/mcp/index.d.ts
+/** A live connection to a set of MCP servers: the discovered tools and a way to close every transport. */
+interface McpConnection {
+  /** Discovered tools keyed by namespaced name, `mcp_<server>_<tool>`. */
+  tools: Record<string, ToolDef>;
   /**
-   * Project the session's persisted turns into wire-ready messages safe to
-   * hand to any provider.
+   * Per-server `instructions` payload from the MCP `initialize` handshake,
+   * keyed by server name. Each server may return free-form guidance the
+   * model is meant to read alongside the tool catalog — typical content
+   * is "the database is already provisioned, use `apply_migration`
+   * directly" or "always wrap SELECTs in a transaction". The agent
+   * renders these into a system-prompt section when
+   * `behavior.surfaceMcpInstructions` is on (default).
    *
-   * The canonical answer to "I need to send these turns to Anthropic /
-   * OpenAI from outside `agent.run()`" (sub-agent classifier, side-channel
-   * summarizer, replay worker, …). Runs the same defensive pairing repair
-   * the agent loop applies just-in-time at wire-send time
-   * ({@link ensureToolResultPairing}), so orphan `tool_use` blocks and
-   * dangling `tool_result`s never reach the provider as the 400
-   * "tool_result must be preceded by a tool_call with the same toolCallId".
+   * Servers that omit the field, return an empty string, or fail to
+   * connect contribute no entry. Lazy-connected servers contribute an
+   * entry only once their first connect resolves — until then the model
+   * never sees their instructions, matching the schema-loading semantics
+   * of `lazyConnect`.
    *
-   * Pass `provider` to also enforce the user-tail invariant
-   * ({@link ensureEndsWithUserMessage}) — required for opus 4.7 / o-series
-   * style models that reject assistant-prefill.
+   * Map (not Record) so insertion order matches server config order and
+   * the rendered section is byte-stable for the cache breakpoint.
    *
-   * Pure + idempotent. Resolves content refs only in the returned messages
-   * and does NOT mutate `session.turns`. **Do not write the result back via
-   * `setTurns` / `appendTurns`** — synthetic placeholders or resolved
-   * payloads will contaminate persisted history.
-   */
-  toMessages: (options?: ToWireMessagesOptions) => Promise<SessionMessage[]>;
-  /** Serialize to SessionData */
-  toJSON: () => SessionData;
-  /**
-   * The backing store, when one was provided. Exposed so hosts can call
-   * its optional `close()` on teardown (e.g. release the SQLite handle).
+   * Optional so custom `mcpConnector` implementations may omit it; the
+   * framework's own `connectMcpServers` always returns a Map (possibly
+   * empty).
    */
-  readonly store?: SessionStore;
+  instructions?: Map<string, string>;
+  /** Closes every server connection. Servers that fail to close in time are force-stopped. */
+  close: () => Promise<void>;
 }
-/** Options for {@link createSession}. */
-interface CreateSessionOptions {
-  /** Session ID. If omitted and store provides generateSessionId, that is used. */
-  id?: string;
-  /** Agent ID label */
-  agentId?: string;
-  /**
-   * Project tag — see {@link SessionData.projectRoot}. Stamped once on
-   * creation; ignored when `_data` is set (restoring an existing
-   * session preserves whatever was already persisted there). The chat
-   * layer's session factory stamps `projectRootOf(cwd)` so sessions
-   * started from the same repo — any subdir, any linked worktree — share
-   * one tag.
-   */
-  projectRoot?: string;
-  /** Initial metadata */
-  metadata?: Record<string, unknown>;
-  /** Storage backend (optional, enables save/load) */
-  store?: SessionStore;
+/**
+ * Optional knobs threaded into per-server bootstrap. Reserved for runtime
+ * concerns the agent shell injects (credential storage, OAuth providers);
+ * the `McpServerConfig` shape stays pure data.
+ */
+interface ConnectMcpServersOptions {
   /**
-   * Observability hook for the load-time pairing heal: fired once per block
-   * or turn `dropInvalidToolPairings` deleted while restoring `_data`.
-   * Deletions are permanent once the session is saved, so hosts that alert
-   * on wire-time `pairing:repair` events should wire this to the same sink.
-   * Only fires on the `_data` restore path; fresh sessions never heal.
+   * Execution context binding for servers declaring `scope: 'context'`.
+   * Safe to pass unconditionally: the binding is lazy, and its
+   * `getHandle()` is invoked only when a context-scoped stdio server
+   * actually builds its transport — host-only configs never touch it, so
+   * no spawn cost is paid for merely supplying it. Omitting it simply
+   * makes any `scope: 'context'` server fail bootstrap with a pointed
+   * error.
    */
-  onPairingDrop?: (drop: PairingDrop) => void;
+  execution?: McpExecutionBinding;
   /**
-   * @internal: restore from existing data (bypasses id/agentId/metadata
-   * options). The session ALIASES this object for its lifetime — every
-   * mutation (appendTurns, run records, updatedAt) writes through to it,
-   * and the load-time pairing heal may replace its `turns` array in place
-   * before the session is returned. Callers must not retain independent
-   * ownership expectations.
+   * Build a non-interactive `OAuthClientProvider` for a given server. Called
+   * lazily — only invoked when the bootstrap actually needs auth (explicit
+   * `auth: 'oauth'` flag, or a UnauthorizedError that meets the auto-detect
+   * criteria). Return `undefined` to opt this server out of OAuth even if it
+   * was requested (e.g. the host doesn't have a credential store for it).
+   *
+   * "Non-interactive" — the provider must NOT trigger a browser flow during
+   * bootstrap. Use a `redirectUri` of `undefined` so the SDK reads stored
+   * tokens, refreshes on expiry, and throws `UnauthorizedError` if tokens
+   * are missing or refresh fails. The host then surfaces an
+   * `mcp:auth:required` event so the user can opt in to interactive login.
    */
-  _data?: SessionData;
+  buildAuthProvider?: (config: McpServerConfig) => OAuthClientProvider | undefined;
 }
 /**
- * Create a new session.
- * Async so stores that generate IDs server-side (e.g. a database) can be supported.
- * @param options - Session identity, metadata and store. See {@link CreateSessionOptions}.
+ * Internal: shape received by the `_clientFactory` test-injection seam.
+ * Mirrors the subset of `TolerantClientOptions` the bootstrap path forwards
+ * so a mock client can opt into the same lifecycle wiring (warning sink,
+ * future seams) instead of silently bypassing it.
+ */
+interface McpClientFactoryOptions {
+  /** See `TolerantClientOptions.onWarning`. */
+  onWarning?: (message: string) => void;
+}
+type McpClientFactory = (opts?: McpClientFactoryOptions) => Client;
+/**
+ * Connect to MCP servers and discover their tools.
+ *
+ * Each tool is namespaced as `mcp_{serverName}_{toolName}` to avoid
+ * collisions with agent tools or tools from other servers.
+ *
+ * @param configs - Array of MCP server configurations
+ * @param _clientFactory - Internal: override client construction for testing
+ * @param hooks - Optional agent hooks for firing mcp:connect, mcp:error, mcp:close events
+ * @param options - Optional bootstrap knobs (e.g. OAuth provider injection)
  * @example
  * ```ts
- * import { createMemoryStore, createSession } from 'zidane/session'
+ * import { connectMcpServers } from 'zidane/mcp'
  *
- * const session = await createSession({ agentId: 'reviewer', store: createMemoryStore() })
- * console.log(session.id, session.turns.length)
+ * const connection = await connectMcpServers([
+ *   { name: 'fs', transport: 'stdio', command: 'npx', args: ['-y', '@modelcontextprotocol/server-filesystem', '.'] },
+ * ])
+ * console.log(Object.keys(connection.tools))
+ * await connection.close()
  * ```
  */
-declare function createSession(options?: CreateSessionOptions): Promise<Session>;
-/**
- * Demote a persisted `'running'` status to `'idle'` (in place) and return the
- * data. A persisted `'running'` is necessarily stale: the run that set it lived
- * in another process (crash, kill -9, power loss) and cannot still be executing
- * in a freshly-loaded session. Call this on the result of a raw `store.load()`
- * so consumers don't render a ghost in-progress state or refuse a new run.
- * `loadSession` applies it automatically; direct `store.load()` callers (e.g.
- * the TUI) should run loaded data through this.
- *
- * Run RECORDS get the same treatment: the agent persists each record at
- * run start with `status: 'running'` (crash durability — see the
- * `SessionStore.updateRun` contract), so a freshly-loaded session may
- * carry `'running'` runs that died with their process. They demote to
- * `'aborted'` so replay renders a truthful "aborted" state instead of a
- * perpetually-in-flight run.
- * @param data - Loaded session data. It is modified in place.
- */
-declare function demoteStaleRunningStatus(data: SessionData): SessionData;
-/** Options for {@link loadSession}. */
-interface LoadSessionOptions {
-  /** Forwarded to `createSession` — see {@link CreateSessionOptions.onPairingDrop}. */
-  onPairingDrop?: (drop: PairingDrop) => void;
-  /**
-   * Write a load-time pairing heal back to the store (default true). Pass
-   * `false` from READERS — a window mirroring a session another process
-   * runs (daemon mode) — because the persist is a bulk turn overwrite and
-   * the owner's next load heals and persists it anyway.
-   */
-  persistHeal?: boolean;
-}
-/**
- * Load an existing session from a store.
- * @param store - Store to load from.
- * @param sessionId - Id of the session to load.
- * @param options - Load options. See {@link LoadSessionOptions}.
- * @returns The session, or `null` when the store has no session with that id.
- */
-declare function loadSession(store: SessionStore, sessionId: string, options?: LoadSessionOptions): Promise<Session | null>;
+declare function connectMcpServers(configs: McpServerConfig[], _clientFactory?: McpClientFactory, hooks?: Hookable<AgentHooks>, options?: ConnectMcpServersOptions): Promise<McpConnection>;
 //#endregion
 //#region src/skills/types.d.ts
 /**
@@ -5901,6 +5914,11 @@ interface AgentRunOptions {
    * numbering read a stored fact instead of deriving it positionally.
    */
   runLabel?: string;
+  /**
+   * The host's agent profile this run runs as, persisted onto the resulting
+   * `SessionRun.agent` so a transcript can name it per run.
+   */
+  runAgent?: SessionRunAgent;
   /**
    * Zero-based subagent depth. 0 = top-level `agent.run()`, 1 = first-level
    * child spawned by a parent agent, and so on. Used by the spawn tool to
@@ -14539,6 +14557,10 @@ declare function compactPath(path: string, maxWidth?: number, home?: string): st
 //#region src/chat/run-receipt.d.ts
 /** What a finished run cost and how long it took, as shown on its receipt row. */
 interface RunReceipt {
+  /** The agent profile the run ran as. */
+  agent?: string;
+  /** The previous run ran as another agent: the user switched before this run. */
+  agentSwitched?: boolean;
   /** Model that produced the LAST turn — the one the answer came from. */
   modelId?: string;
   /** The provider that served that turn, so its name reads as the model picker's. */
@@ -14565,6 +14587,8 @@ interface RunReceipt {
 }
 /** Leads the turn count: one cycle = one model round trip. */
 declare const RUN_RECEIPT_TURN_GLYPH = "↻";
+/** Leads the agent when the run switched to it from the previous run's. */
+declare const RUN_RECEIPT_SWITCH_GLYPH = "⇄";
 /**
  * `1.2k` / `48k` / `1.3M` — token counts are read at a glance, not counted.
  *
@@ -14585,8 +14609,9 @@ declare const formatCostUsd: typeof fmtCost;
  *
  * @param run - The run record.
  * @param now - Epoch milliseconds used as the end time of a run still in progress.
+ * @param previous - The session's top-level run before this one, to tell an agent switch.
  */
-declare function runReceiptFromRun(run: SessionRun, now?: number): RunReceipt;
+declare function runReceiptFromRun(run: SessionRun, now?: number, previous?: SessionRun): RunReceipt;
 /**
  * `42 tk/s`; one decimal under 10 so a slow model is not shown as `0 tk/s`.
  *
@@ -14594,7 +14619,7 @@ declare function runReceiptFromRun(run: SessionRun, now?: number): RunReceipt;
  */
 declare function formatTokensPerSecond(tps: number): string;
 /** What a cell IS, so renderers can tint by meaning rather than by position. */
-type RunReceiptCellKind = 'model' | 'duration' | 'turns' | 'cost' | 'tokens' | 'speed';
+type RunReceiptCellKind = 'agent' | 'model' | 'duration' | 'turns' | 'cost' | 'tokens' | 'speed';
 /** Sub-parts of a cell that want their own tint — the two token arrows. */
 type RunReceiptSegmentKind = 'tokens-in' | 'tokens-out';
 /** One part of a `tokens` cell, so renderers can color input and output differently. */
@@ -16397,6 +16422,12 @@ interface Settings {
    * Takes effect on the next agent build. Default: on.
    */
   imageGeneration: boolean;
+  /**
+   * Give the agent the `web_search` tool (Anthropic's native search where the
+   * provider offers it). Off removes it from every session, its subagents and
+   * `/side` sessions; a change rebuilds live agents. Default: on.
+   */
+  webSearch: boolean;
   /**
    * Default model of `generate_image`, as `"providerKey/modelId"`
    * (e.g. `"openrouter/google/gemini-3-pro-image"`). Empty string = the first
@@ -30547,5 +30578,5 @@ declare const basicTools: {
 /** Default preset with the shell, file, edit and `spawn` tools and a general-purpose system prompt. The `spawn` tool is created fresh on every access, so each agent gets its own subagent state. */
 declare const _default: Preset;
 //#endregion
-export { MetricsHooksOptions as $, ImageData as $C, originPinnedFetch as $D, ToWireMessagesOptions as $E, loadGoogleWireKit as $S, ToolDescriptionOverride as $T, formatTaskStatus as $_, ReferenceMatch as $a, AgentHookBus as $b, ExtensionReferenceCardFact as $c, stripShellInterpolations as $d, ChipColorMap as $f, normalizePanelLoadContext as $g, defaultSessionModel as $h, TRAILER as $i, ExtensionSessionSummary as $l, AgentComposition as $m, EvalWorkspaceFile as $n, branchKind as $o, ConfirmQuestion as $p, edit as $r, readGithubPulls as $s, buildZidaneSkillEditSkill as $t, ExtensionSubagentDef as $u, EnvironmentState as $v, McpToolHookContext as $w, ASSISTANT_TOOL_CALLS_TAG as $x, activeSnapshotFor as $y, SqlValue as A, OAuthParams as AC, SessionArtifactInput as AD, SessionData as AE, mistral as AS, StreamUsageSnapshot as AT, RunReceiptSegmentKind as A_, DecisionError as Aa, storedCredentialsOf as Ab, ExtensionGuiPanel as Ac, PluginManifest as Ad, RECOMMENDED_SKILL_SOURCES as Af, normalizePaletteRunResult as Ag, OpenInTarget as Ah, createRunSummaryCollector as Ai, SessionBadgeEntry as Al, SchemaInput as Am, CreateEvalAgentOptions as An, discoverExtensions as Ao, CommandArgSuggestion as Ap, SkillsUseToolOptions as Ar, GithubClientOptions as As, resolveLegacySessionDir as At, resolveExtensionConfig as Au, defaultEnvironmentKind as Av, DecisionUsage as Aw, ProviderDecisions as Ax, enabledModelOptions as Ay, MutationValidationHooksOptions as B, resolveOAuthApiKey as BC, resultToString as BD, loadSession as BE, GoogleRouteName as BS, ToolResultDocumentRefContent as BT, runReceiptFromRun as B_, AgentOptions as Ba, ContextBreakdownContributionContext as Bb, ExtensionModalNode as Bc, skillTokenWeights as Bd, groupSkillPicks as Bf, PanelFocus as Bg, ToolCallDisplay as Bh, selectRecentFiles as Bi, ExtensionHudWriter as Bl, LoggingHookSet as Bm, EvalCaseResult as Bn, ExtensionMcpHost as Bo, CommandStepContext as Bp, RECORD_ARTIFACT_TOOL as Br, githubTokenSource as Bs, renderStaleReadNotice as Bt, ExtensionBadgeActions as Bu, EnvironmentAvailability as Bv, ChildSpawnIdentity as Bw, planZaiReasoning as Bx, piIdOf as By, statsByModel as C, AnthropicBedrockConfig as CC, remintDuplicateToolCallIds as CD, SkillDiagnostic as CE, openai as CS, SessionTurn as CT, ModelNamer as C_, composePresets as Ca, readProviderCredentials as Cb, ExtensionContext as Cc, loadAgentPlugin as Cd, sanitizeSkillName as Cf, PaletteRunResult as Cg, EditHunk as Ch, RunSummaryByModel as Ci, ExtensionToolResultPatch as Cl, createInteractionTools as Cm, defineEval as Cn, readExtensionInstallProvenance as Co, collectReferences as Cp, writeFile as Cr, pullFromMeta as Cs, PersistOutcome as Ct, StoredExtensionConfigItem as Cu, EnvironmentDescriptor as Cv, DecisionRefusalAnswer as Cw, HistoryRepair as Cx, ProviderFactoryOptions as Cy, sqliteStoreFile as D, PromptCacheKeyOption as DC, ARTIFACT_META_MAX_BYTES as DD, CreateSessionOptions as DE, neuralwatt as DS, StepThinkingDecay as DT, RunReceiptCell as D_, ToolSearchToolOptions as Da, setPreferredCredential as Db, ExtensionCustomRendererEntry as Dc, PluginAuthor as Dd, SkillBrowseErrorCode as Df, groupPaletteRows as Dg, InteractionMode as Dh, RunSummaryRepeatGuard as Di, GuiContributions as Dl, pendingInteractionsFromTurns as Dm, createReusableExecutionContext as Dn, ENTRY_CANDIDATES as Do, resolveCompletionSubmit as Dp, validateToolArgs as Dr, viewForRead as Ds, maybePersistToolResult as Dt, coerceExtensionConfigInput as Du, EnvironmentSettingsChange as Dv, DecisionScoreQuestion as Dw, ProviderDecisionAvailability as Dx, cerebrasDescriptor as Dy, createSqliteSessionStore as E, PromptCacheKeyContext as EC, ARTIFACT_KINDS as ED, SkillsConfig as EE, NeuralwattParams as ES, StaleReadPolicy as ET, RunReceipt as E_, LazyToolEntry as Ea, setCredentialLabel as Eb, ExtensionCustomRenderer as Ec, LoadedPlugin as Ed, SkillBrowseError as Ef, fuzzyMatch as Eg, EditPayload as Eh, RunSummaryError as Ei, ExtensionTuiSurface as El, makeRequestInteraction as Em, ReusableExecutionContext as En, registerExtensionHostModules as Eo, mergeSuggestions as Ep, ValidationResult as Er, viewForIssueRead as Es, cleanupPersistedSession as Et, clampExtensionConfigNumber as Eu, EnvironmentSettings as Ev, DecisionScoreLevel as Ew, ProviderCapabilities as Ex, anthropicDescriptor as Ey, createSqliteDriver as F, isOAuthAccessToken as FC, sortArtifacts as FD, createSession as FE, GOOGLE_EXTRA_MODELS as FS, ToolHookContext as FT, formatRunReceiptLine as F_, Agent as Fa, ContextSegmentFile as Fb, ExtensionMcpConfigTransform as Fc, parseSchemaId as Fd, SkillSourceInfo as Ff, ExtensionPanelScope as Fg, SessionHeader as Fh, PostCompactRestoreOptions as Fi, ExtensionComposerBadgeOptions as Fl, ConsoleSinkOptions as Fm, EvalAgentRunStats as Fn, DiscoverAndBuildExtensionRegistryOptions as Fo, CommandInvocation as Fp, createSkillsReadTool as Fr, configureGithubClient as Fs, INTERRUPT_MESSAGE_FOR_TOOL_USE as Ft, BadgeActionEffect as Fu, ENVIRONMENT_METADATA_KEY as Fv, AutoCompact as Fw, ToolCall as Fx, modelOptionsFor as Fy, normalizeProviders as G, planAnthropicThinking as GC, expandMcpConfigEnv as GD, createRemoteStore as GE, GoogleVertexParams as GS, ToolResultVideoContent as GT, compactPath as G_, BuildExtensionRegistryOptions as Ga, ContextExactCounts as Gb, ExtensionPaletteProviderEntry as Gc, parseAllowedToolPattern as Gd, installAllowedToolsGate as Gf, PanelLoadContext as Gg, SessionKnobs as Gh, compactConversation as Gi, MAX_COMPOSER_BADGES as Gl, createLoggingHooks as Gm, EvalRunReporterOptions as Gn, EXTENSION_BUS_MAX_PAYLOAD_BYTES as Go, executeCommand as Gp, InteractionToolOptions as Gr, GithubPullRead as Gs, EXTENSION_EDIT_METADATA_KEY as Gt, builtinBadgeEffect as Gu, EnvironmentExecution as Gv, DEFAULT_AGENT_CLOCK as Gw, SchemaSanitizeProfile as Gx, OUTPUT_RESERVE_TOKENS as Gy, MutationValidationResult as H, AnthropicThinkingPlan as HC, nonOwningMcpView as HD, setExtensionSessionState as HE, GoogleStreamFn as HS, ToolResultImageRefContent as HT, SpawnEndSummary as H_, McpConnector as Ha, ContextBreakdownOptions as Hb, ExtensionPaletteCommand as Hc, SkillValidationResult as Hd, skillPickKey as Hf, PanelItem as Hg, DEFAULT_SPACE_ID as Hh, CompactOptions as Hi, ExtensionNotifyOptions as Hl, RingBufferSink as Hm, EvalDefinitionContext as Hn, defineExtension as Ho, commandBlockToEvent as Hp, readFile as Hr, GithubStateStore as Hs, createFileGithubStateStore as Ht, badgeMenu as Hu, EnvironmentConfig as Hv, CompactFunction as Hw, XaiParams as Hx, AUTO_COMPACT_MIN_GROWTH_FRACTION as Hy, createSqliteWriteQueue as I, pinnedAccountMissingError as IC, ConnectMcpServersOptions as ID, currentExtensionSession as IE, GoogleCompatibleRoute as IS, ToolOutcome as IT, formatTokenCount as I_, AgentCacheChange as Ia, ContextSegmentOrigin as Ib, ExtensionMcpServerInfo as Ic, defineSkill as Id, SkillSourceListing as If, PANEL_CONTENT_LIMITS as Ig, SessionMeta as Ih, RecentFile as Ii, ExtensionHud as Il, LogLevel as Im, EvalAgentStats as In, discoverAndBuildExtensionRegistry as Io, CommandOutputBlock as Ip, shellKill as Ir, createGithubClient as Is, SHELL_CASCADE_CANCEL_MESSAGE as It, BadgeActionsMatch as Iu, EnvironmentAction as Iv, AutoCompactConfig as Iw, ToolResult as Ix, modelSupportsReasoning as Iy, Histogram as J, openrouterImageModels as JC, pinnedMcpRedirectUri as JD, FileMapStoreOptions as JE, classifyGoogleError as JS, toolOutputBudgetByteLength as JT, fmtTokens as J_, disposeExtensionRegistry as Ja, ContextItem as Jb, ExtensionPaths as Jc, validateSkillForWrite as Jd, StorageMode as Jf, PanelMarkdownItem as Jg, SpaceModelDefault as Jh, BASE_INSTRUCTIONS as Ji, ExtensionHostRuntimeBridge as Jl, jsonSink as Jm, EvalRunUsage as Jn, ExtensionBusEnvelope as Jo, useInteractionsActions as Jp, glob as Jr, KnownGithubPull as Js, SKILL_EDIT_METADATA_KEY as Jt, normalizeBadgeEffect as Ju, EnvironmentPrepareInput as Jv, FrozenPromptSections as Jw, sanitizeToolSpecs as Jx, ProviderUsageCredits as Jy, resolveModelTargets as K, resolveThinkingBinding as KC, isValidCallbackPort as KD, createMemoryStore as KE, GoogleWireKit as KS, TurnFinishReason as KT, describeSpawnEnd as K_, ExtensionCatalogPartition as Ka, ContextExtensionRow as Kb, ExtensionPaletteRunResult as Kc, validateResourcePath as Kd, ResolveStorageDirsOptions as Kf, PanelLoadContextInput as Kg, Space as Kh, CompactInvalidInputError as Ki, createExtensionHud as Kl, createRingBufferSink as Km, EvalRunSummary as Kn, ExtensionBus as Ko, parseCommandInvocation as Kp, createInteractionTool as Kr, GithubPullRef as Ks, EditSessionTarget as Kt, extensionBadgeActions as Ku, EnvironmentExecutionInput as Kv, DedupHasher as Kw, SchemaSanitizeResult as Kx, effectiveContextWindow as Ky, isSqliteBusyError as L, readAccountOAuthCredential as LC, McpConnection as LD, deleteExtensionSessionState as LE, GoogleExtraModel as LS, ToolResultAudioContent as LT, formatTokensPerSecond as L_, AgentCacheImpact as La, ContextSegmentsInput as Lb, ExtensionMcpSurface as Lc, writeSkillToDisk as Ld, SkillSourceSkill as Lf, PanelAction as Lg, Settings as Lh, buildPostCompactAttachments as Li, ExtensionHudBadge as Ll, LogRecord as Lm, createEvalAgent as Ln, ExtensionPromptBridge as Lo, CommandSpawnResult as Lp, CreateShellToolOptions as Lr, githubApiBase as Ls, TOOL_USE_CANCELLED_MESSAGE as Lt, BadgeMenuItem as Lu, EnvironmentActionInput as Lv, CacheTtl as Lw, ToolSpec as Lx, modelsForDescriptor as Ly, SqliteDriver as M, credentialsFilePath as MC, mergeArtifact as MD, SessionMetaRow as ME, LocalParams as MS, SystemPromptSnapshot as MT, formatCostUsd as M_, DecisionInvalidResponseError as Ma, AgentAccent as Mb, ExtensionKeybinding as Mc, SUPPORTED_AGENT_PLUGINS_VERSIONS as Md, SkillInstallTarget as Mf, rankPaletteItems as Mg, Picked as Mh, estimateTokens as Mi, isBadgeColor as Ml, isStandardSchema as Mm, EvalAgentMcpServers as Mn, isExtensionDefinition as Mo, CommandExecution as Mp, SkillsRunScriptToolOptions as Mr, GithubRequest as Ms, resolvePersistDir as Mt, sanitizeExtensionConfigActionPatch as Mu, isEnvironmentEnabled as Mv, AgentClock as Mw, StreamCallbacks as Mx, getModelInfo as My, SqliteStatement as N, credentialsFromParams as NC, normalizeArtifactInput as ND, SessionRun as NE, local as NS, ThinkingDecay as NT, formatRunDuration as N_, DecisionTimeoutError as Na, accentColor as Nb, ExtensionKeybindingDispatchContext as Nc, agentPluginsSchemaId as Nd, SkillPick as Nf, ExtensionPanel as Ng, Screen as Nh, utf8ByteLength as Ni, ExtensionBannerOptions as Nl, resolveSchemaInput as Nm, EvalAgentRunOptions as Nn, parseExtensionScanPathEnv as No, CommandGenerateDataOptions as Np, createSkillsRunScriptTool as Nr, classifyGithubAnswer as Ns, resolveSessionDir as Nt, toWireConfigSchema as Nu, readEnvironmentSettings as Nv, AgentRunOptions as Nw, StreamOptions as Nx, localDescriptor as Ny, ReadonlySqliteSessionStore as O, derivePromptCacheKey as OC, ArtifactFilter as OD, LoadSessionOptions as OE, planNeuralwattReasoning as OS, StreamHookContext as OT, RunReceiptCellKind as O_, createToolSearchTool as Oa, setProviderCredential as Ob, ExtensionDefinition as Oc, PluginComponentStatus as Od, browseSkillSource as Of, isPaletteContext as Og, ModelApproval as Oh, RunSummaryTokens as Oi, LoadedExtension as Ol, serializeInteractionResponse as Om, artifactPath as On, ExtensionScanEntry as Oo, Command as Op, TailTruncateOptions as Or, GithubAnswer as Os, migrateSessionArtifactDirs as Ot, isValidExtensionConfigItem as Ou, EnvironmentSettingsWrite as Ov, DecisionStartHookContext as Ow, ProviderDecisionRequest as Ox, credKeyOf as Oy, SqliteWriteQueue as P, extractRuntimeCredentials as PC, selectArtifactEvictions as PD, SessionStore as PE, GOOGLE_DEFAULT_MODEL as PS, ToolBatchExecutor as PT, formatRunReceiptCells as P_, DecisionUnsupportedError as Pa, ContextSegment as Pb, ExtensionManifest as Pc, isSupportedAgentPluginsVersion as Pd, SkillPickGroup as Pf, ExtensionPanelEntry as Pg, SessionEnvironmentSummary as Ph, PostCompactAttachments as Pi, ExtensionComposerBadge as Pl, zodToJsonSchema as Pm, EvalAgentRunResult as Pn, scanExtensionDirectories as Po, CommandInteraction as Pp, SkillsReadToolOptions as Pr, clockTime as Ps, resolveTasksDir as Pt, BadgeAction as Pu, resolveProviderConfig as Pv, AgentStats as Pw, TokenCountPayload as Px, modelLabel as Py, MetricsHookSet as Q, ImageAspectRatio as QC, isAllowedRemoteUrl as QD, ReasoningWireAction as QE, googleVertex as QS, ToolDef as QT, formatElapsed as Q_, partitionExtensionCatalog as Qa, buildContextBreakdown as Qb, ExtensionReferenceCard as Qc, interpolateShellCommands as Qd, ChipColor as Qf, normalizePanelContent as Qg, defaultSessionKnobs as Qh, NO_TOOLS_PREAMBLE as Qi, ExtensionSessionControl as Ql, nextLogLevel as Qm, EvalVariantSummary as Qn, artifactKindLabel as Qo, AnswerValue as Qp, createGenerateImageTool as Qr, readGithubPull as Qs, buildZidaneExtensionSkill as Qt, ChildAgent as Qu, EnvironmentRequest as Qv, McpServerConfig as Qw, openrouter as Qx, UsageTone as Qy, MutationValidationBatch as R, readOAuthCredentials as RC, connectMcpServers as RD, demoteStaleRunningStatus as RE, GoogleParams as RS, ToolResultContent as RT, hasRunReceipt as R_, AgentCompactOptions as Ra, buildContextSegments as Rb, ExtensionMcpToolResult as Rc, writeSkillsToDisk as Rd, githubAvatarUrl as Rf, PanelContent as Rg, SpawnEndInfo as Rh, selectFilesFromReadState as Ri, ExtensionHudState as Rl, LogSink as Rm, EvalArtifacts as Rn, ExtensionPromptDelivery as Ro, CommandSpawnTask as Rp, createShellTool as Rr, githubClient as Rs, TOOL_USE_SKIPPED_MESSAGE as Rt, BadgeTarget as Ru, EnvironmentActionResult as Rv, ChildRunStats as Rw, TurnResult as Rx, openaiDescriptor as Ry, formatTokenUsage as S, applyAnthropicCacheBreakpoints as SC, ensureToolResultPairing as SD, SkillConfig as SE, mapCodexStopReason as SS, SessionMessage as ST, truncateTitle as S_, Preset as Sa, readProviderCredentialPair as Sb, ExtensionComposerSurface as Sc, defaultPluginDataRoot as Sd, SkillPathCandidate as Sf, PaletteProvider as Sg, EditDiffDisplay as Sh, RunSummaryBudget as Si, ExtensionToolResultMetadataRegistration as Sl, createAutomaticInteractionResponse as Sm, clearRegisteredEvals as Sn, parseExtensionInstallSource as So, applyInsert as Sp, runHeadless as Sr, pullChecks as Ss, PersistInput as St, ExtensionConfigValueItem as Su, toggleKeyed as Sv, DecisionQuestions as Sw, snapshotCacheDimensions as Sx, ProviderDescriptor as Sy, SqliteStoreFile as T, AnthropicParams as TC, ARTIFACTS_PER_SESSION_CAP as TD, SkillSource as TE, NEURALWATT_DEFAULT_MODEL as TS, SpawnQueuedContext as TT, RUN_RECEIPT_TURN_GLYPH as T_, createAgent as Ta, removeStoredCredential as Tb, ExtensionContributions as Tc, LoadAgentPluginOptions as Td, BrowseSkillSourceOptions as Tf, createPaletteRanker as Tg, EditOutcomeKind as Th, RunSummaryCollectorOptions as Ti, ExtensionToolVerdict as Tl, isModelInteraction as Tm, llmJudge as Tn, updateInstalledExtension as To, mergeReferences as Tp, waitTask as Tr, pullStateLook as Ts, buildPersistedStub as Tt, WireExtensionConfigSchema as Tu, EnvironmentSecrets as Tv, DecisionScoreAnswer as Tw, Provider as Tx, ProviderUsageReport as Ty, SuccessfulMutationOutcome as U, THINKING_BINDING_SETTING_ENV as UC, wrapDiscoveredMcpTools as UD, withExtensionSession as UE, GoogleStreamOptions as US, ToolResultMetadata as UT, ageStep as U_, McpToolMeta as Ua, ContextCategory as Ub, ExtensionPaletteItem as Uc, isToolAllowedByUnion as Ud, skillPickOf as Uf, PanelKeyValueItem as Ug, DEFAULT_SPACE_NAME as Uh, CompactResult as Ui, ExtensionNotifyTone as Ul, consoleSink as Um, EvalRunMetricAggregate as Un, buildExtensionPreset as Uo, commandBlocksToContent as Up, multiEdit as Ur, createMemoryGithubStateStore as Us, isGhRateLimitError as Ut, badgePromptText as Uu, EnvironmentConfigField as Uv, CompactHookContext as Uw, xai as Ux, AutoCompactDecision as Uy, MutationValidationMutation as V, writeOAuthCredentials as VC, deriveMcpToolMeta as VD, resumeChainRunIds as VE, GoogleSharedParams as VS, ToolResultImageContent as VT, AgeStep as V_, AgentToolState as Va, ContextBreakdownContributor as Vb, ExtensionOrderedContribution as Vc, SkillValidationIssue as Vd, skillCategory as Vf, PanelIcon as Vg, TranscriptDensity as Vh, CompactEndEvent as Vi, ExtensionNotification as Vl, LoggingHooksOptions as Vm, EvalDefinition as Vn, createMcpSurface as Vo, CommandStepFn as Vp, recordArtifact as Vr, normalizeGithubHost as Vs, applyCompactSummaryCutoff as Vt, artifactBadgeTarget as Vu, EnvironmentAvailabilityInput as Vv, CompactEndHookContext as Vw, zai as Vx, restoreModelOptions as Vy, createMutationValidationHooks as W, ThinkingBindingBehavior as WC, expandEnvPlaceholders as WD, RemoteStoreOptions as WE, GoogleStreams as WS, ToolResultTextContent as WT, ageString as W_, McpToolWrap as Wa, ContextCategoryId as Wb, ExtensionPaletteProvider as Wc, matchesAllowedTool as Wd, IMPLICITLY_ALLOWED_SKILL_TOOLS as Wf, PanelKeyValueRow as Wg, SPACE_METADATA_KEY as Wh, CompactStartEvent as Wi, ExtensionStatusOptions as Wl, createLogger as Wm, EvalRunReporter as Wn, composeExtensionPreset as Wo, commandSteps as Wp, listFiles as Wr, GithubPull as Ws, rateLimitResetFromJson as Wt, builtinBadgeActions as Wu, EnvironmentConfigValue as Wv, CompactStartHookContext as Ww, SchemaSanitizeOptions as Wx, AutoCompactInput as Wy, Meter as X, GOOGLE_IMAGE_MODELS as XC, withoutEnvPlaceholders as XD, SaveMetaOptions as XE, google as XS, toolResultToText as XT, formatCount as X_, filterRegistryPlugins as Xa, ContextSnapshot as Xb, ExtensionPromptTransform as Xc, resolveSkills as Xd, resolveStorageDirs as Xf, PanelSection as Xg, activeSpaceOf as Xh, CompactPromptBuilder as Xi, ExtensionModelEntry as Xl, filterLogRecords as Xm, EvalScorer as Xn, serializedPayloadBytes as Xo, ASK_USER_TOOL as Xp, GenerateImageToolOptions as Xr, githubPullConfirmedAt as Xs, ZIDANE_EXTENSION_SKILL_NAME as Xt, runBadgeAction as Xu, EnvironmentProvider as Xv, JsonValue as Xw, OpenRouterParams as Xx, ProviderUsageStatus as Xy, InstrumentOptions as Y, OPENAI_IMAGE_MODELS as YC, resolveTransportConfig as YD, createFileMapStore as YE, fromGooglePiAssistantMessage as YS, toolOutputByteLength as YT, formatCostLabel as Y_, filterExtensionRegistry as Ya, ContextMcpGroup as Yb, ExtensionPermission as Yc, validateSkillName as Yd, StorageSlot as Yf, PanelRowItem as Yg, SpacesSettings as Yh, CompactDirection as Yi, ExtensionHostRuntimeImpl as Yl, LOG_LEVEL_CYCLE as Ym, EvalScore as Yn, createExtensionBus as Yo, useInteractionsQueue as Yp, DEFAULT_IMAGE_DIR as Yr, clearGithubPullMemory as Ys, SkillEditMarker as Yt, normalizeBadgeTarget as Yu, EnvironmentPrepareResult as Yv, GeometricThinkingDecay as Yw, OPENROUTER_DEFAULT_MODEL as Yx, ProviderUsageSnapshot as Yy, MetricAttributes as Z, IMAGE_ASPECT_RATIOS as ZC, PinnedFetch as ZD, mergeSessionMetadata as ZE, googleCompatible as ZS, ToolContext as ZT, formatDuration as Z_, mergeContributions as Za, ContextUsageSplit as Zb, ExtensionProviderMiddleware as Zc, InterpolateShellCommandsOptions as Zd, BUILTIN_THEMES as Zf, isExtensionPanelScope as Zg, defaultSessionAgent as Zh, CompactPromptOptions as Zi, ExtensionRuntimeSurface as Zl, formatLogLine as Zm, EvalScorerContext as Zn, BUILTIN_ARTIFACT_KINDS as Zo, AUTOMATIC_INTERACTION_INSTRUCTION as Zp, ImageModelSource as Zr, queueGithubPull as Zs, ZIDANE_SKILL_EDIT_SKILL_NAME as Zt, sessionBadgeTarget as Zu, EnvironmentRegistry as Zv, McpOAuthClientConfig as Zw, normalizeOpenRouterModelId as Zx, ProviderUsageWindow as Zy, sectionDigests as _, buildAnthropicClientOptions as _C, PairingRepairMode as _D, ToolStateView as _E, userMessage as _S, RetryConfig as _T, sessionEventExcerpt as __, defaultRepeatGuardTracked as _a, credentialsPath as _b, ExtensionBehaviorTransform as _c, expandPluginVars as _d, parseSkillContent as _f, PaletteContext as _g, profileTools as _h, providerTranscriptFormatForProvider as _i, ExtensionToolPolicy as _l, QuestionResponse as _m, functionalityMetric as _n, InstallExtensionFromSpecOptions as _o, CompletionContext as _p, efficiencyMetricValues as _r, githubPullView as _s, OAuthCallbackOptions as _t, ExtensionConfigNumberItem as _u, rememberableChain as _v, DecisionInputKind as _w, CacheSystemSection as _x, detectAuth as _y, StartSpan as a, CerebrasParams as aC, fromAnthropic as aD, ReadStateMap as aE, ModelCatalog as aO, TOOL_RESULTS_TAG as aS, ProgressNudgeKind as aT, SESSION_EVENT_STATUS_STYLE as a_, ANCHOR_PREVIEW_MAX_CHARS as aa, showsAccount as ab, ExtensionApiVersion as ac, SubagentDef as ad, SkillInstallOptions as af, resolveSessionSpace as ag, BuiltInPrompt as ah, HeadlessResult as ai, ExtensionRunSettledEvent as al, InteractionsActions as am, withZidaneExtensionSkill as an, findReferences as ao, ThemeSelect as ap, TrajectoryStepKind as ar, renderArtifactRow as as, McpCredentialEntry as at, createExtensionHostRuntimeBridge as au, buildRunModel as av, ProviderImages as aw, ActiveSkill as ax, availableEnvironmentActions as ay, TokenUsageLike as b, resolveAnthropicBetas as bC, TOOL_USE_INTERRUPTED_MARKER as bD, stagedToolState as bE, OpenAIParams as bS, SessionEndStatus as bT, shortSessionId as b_, localReliabilityBehavior as ba, readCredentials as bb, ExtensionBusSurface as bc, validatePluginManifest as bd, skillCatalogEntry as bf, PaletteItem as bg, singleAgentRegistry as bh, RunSummary as bi, ExtensionToolRendererEntry as bl, TextQuestion as bm, formatEvalRunSummary as bn, installExtensionFromSpec as bo, CompletionReference as bp, normalizeMetric as br, isPullFresh as bs, PERSISTED_STUB_PREFIX as bt, ExtensionConfigSurface as bu, sanitizeModelChain as bv, DecisionPredicateQuestion as bw, hashMessages as bx, ModelInfo as by, TracingHooksOptions as c, baseten as cC, sanitizeHistoryForProvider as cD, hydrateReadStateFromSession as cE, ModelTier as cO, assistantMessage as cS, PromptDocumentPart as cT, SessionEventStatus as c_, SummaryToTurnInput as ca, ApiKeyCredential as cb, ExtensionArtifactQuery as cc, createSpawnTool as cd, installSkillFromSpec as cf, spaceMetadata as cg, DEFAULT_PERSIST_EXCLUDE_TOOLS as ch, OpenAIChatContentPart as ci, ExtensionRuntimeEnv as cl, PlanDecision as cm, RegisterEvalTestsOptions as cn, ExtensionFetchResult as co, resolveTheme as cp, EFFICIENCY_METRICS as cr, BUILTIN_REFERENCE_PROVIDERS as cs, McpOAuthProviderOptions as ct, ExtensionConfigActionResult as cu, chainPositionOf as cv, DecisionAnswer as cw, SkillActivationStateOptions as cx, readSessionEnvironment as cy, FrozenSystemPrompt as d, arcee as dC, toWireMessages as dD, resolveReadStateMap as dE, formatTools as dS, PromptTextPart as dT, WORKER_REPORT_FRAGMENT as d_, stripImagesFromTurns as da, PreferCredentialResult as db, ExtensionArtifactRow as dc, SpawnModelEntry as dd, readSkillProvenance as df, spaceSwitchItems as dg, availableAgents as dh, exitCodeForHeadlessResult as di, ExtensionSessionStateSurface as dl, PlanResponse as dm, runEvalCase as dn, ExtensionInstallErrorCode as do, createPathAutocompleteProvider as dp, MetricDirection as dr, GITHUB_PULL_PROVIDER_ID as ds, createMemoryMcpCredentialStore as dt, ExtensionConfigCategory as du, filterChainFallbacks as dv, DecisionChoiceAnswer as dw, CacheBreakLoggerOptions as dx, verifyEnvironment as dy, resolveGoogleModel as eC, TurnInterruptionState as eD, ToolDescriptionTarget as eE, McpExecutionBinding as eO, OAIMessage as eS, McpToolSchema as eT, panelBadgeText as e_, buildCompactPrompt as ea, formatBalance as eb, ArtifactDetectHookOptions as ec, SpawnTaskInput as ed, SKILL_PROVENANCE_FILE as ef, findSpace as eg, AgentProfile as eh, FormattedHeadlessResult as ei, ExtensionReferencePattern as el, CreateInteractionToolsOptions as em, editSessionMetadata as en, ReferenceProviderWire as eo, DEFAULT_THEME as ep, EvalWorkspaceOptions as er, commitKind as es, UpDownCounter as et, ExtensionSessionsSurface as eu, formatTaskSummary as ev, ImageModelInfo as ew, AgentHookHandlers as ex, EnvironmentTeardownResult as ey, SectionChangeNote as f, anthropic as fC, EnsureToolResultPairingOptions as fD, DEFAULT_MAX_VALUE_BYTES as fE, mapOAIFinishReason as fS, PromptVideoPart as fT, isMainSession as f_, summaryToTurn as fa, PreferredCredentialTarget as fb, ExtensionArtifactRowFact as fc, createModelSearchTool as fd, SourcedScanPath as ff, spacesEnabled as fg, builtInPromptOf as fh, formatHeadlessResult as fi, ExtensionSkillPolicy as fl, PlanStep as fm, buildEvalRunSummary as fn, ExtensionInstallIo as fo, resolveInlineSuggestion as fp, MetricEmitter as fr, fetchGithubPullRequest as fs, hasAuthorizationHeader as ft, ExtensionConfigChangeBehavior as fu, modelPickKey as fv, DecisionChoiceQuestion as fw, CacheDimensionDiff as fx, workspacePath as fy, sectionDigest as g, classifyAnthropicError as gC, PairingRepair as gD, ToolStateStore as gE, toolResultsMessage as gS, ResolveContentRefBlock as gT, sessionDirLabel as g_, defaultRepeatGuardNormalize as ga, applyApiKeyEnv as gb, ExtensionBadgeTone as gc, PLUGIN_MCP_FILE as gd, parseFrontmatter as gf, PALETTE_RESULT_MAX as gg, profileComposition as gh, installHeadlessEventAdapter as gi, ExtensionToolCatalogTransform as gl, QuestionRequest as gm, fileExistsOneOf as gn, ExtensionInstallSource as go, ActiveTrigger as gp, defineMetrics as gr, githubPullUrl as gs, OAuthCallbackHandle as gt, ExtensionConfigModelItem as gu, providerKeySetChanged as gv, DecisionInput as gw, CachePromptSections as gx, ProviderKey as gy, latestSystemSnapshot as h, resolveAnthropicMaxOutput as hC, PairingDropKind as hD, ToolStateOp as hE, toOAIMessages as hS, ResolveContentRef as hT, renderSessionEventXml as h_, generateStructuredData as ha, StoredCredential as hb, ExtensionBadgeIcon as hc, PLUGIN_SKILLS_DIR as hd, inferSource as hf, PALETTE_RECENT_GROUP as hg, compositionTools as hh, headlessEventToJsonl as hi, ExtensionStorageSurface as hl, QuestionPayload as hm, fileExists as hn, ExtensionInstallScope as ho, patchInlineGhost as hp, computeEvalTagScores as hr, githubPullReferenceProvider as hs, McpOAuthCallbackPageRenderer as ht, ExtensionConfigItemBase as hu, positionKeyed as hv, DecisionFailureReason as hw, CacheDriftInfo as hx, ProviderAuth as hy, Span as i, cursor as iC, filterUnresolvedToolUses as iD, ReadStateEntry as iE, isThinkingLevel as iO, OpenAICompatParams as iS, OAuthRefreshHookContext as iT, ProjectBrief as i_, buildUpToCompactPrompt as ia, resetLabel as ib, ExtensionAgentPluginOptions as ic, SpawnToolState as id, SkillInstallErrorCode as if, readSessionSpaceId as ig, BUILTIN_AGENTS as ih, HeadlessOutputFormat as ii, ExtensionRegistry as il, InteractionResponse as im, resolveExtensionDocsDir as in, createReferenceResolver as io, ThemeColors as ip, TrajectoryStep as ir, refreshArtifact as is, loginMcpServer as it, createArtifactsSurface as iu, ModelChainEntry as iv, ProviderImageResponse as iw, ActivationVia as ix, assertEnvironmentReady as iy, SqliteDatabaseLike as j, ResolveOAuthApiKeyOptions as jC, matchesArtifactFilter as jD, SessionHistory as jE, planMistralReasoning as jS, SystemFreezeOptions as jT, fitRunReceiptCells as j_, DecisionHttpError as ja, writeCredentials as jb, ExtensionGuiSurface as jc, PluginSchemaKind as jd, RecommendedSkillSource as jf, pushPaletteRecent as jg, Owner as jh, BYTES_PER_TOKEN as ji, TuiContributions as jl, StandardSchemaLike as jm, EvalAgent as jn, inlineLoadedExtension as jo, CommandAttachment as jp, createSkillsUseTool as jr, GithubIdentity as js, resolveMcpWarningsDir as jt, resolveExtensionConfigValue as ju, describeEnvironments as jv, AgentBehavior as jw, ProviderMeta as jx, getContextWindow as jy, createReadonlySqliteSessionStore as k, resolvePromptCacheKey as kC, SessionArtifact as kD, Session as kE, MistralParams as kS, StreamProgressHookContext as kT, RunReceiptSegment as k_, DEFAULT_DECISION_TIMEOUT_MS as ka, storedCredentialById as kb, ExtensionFooterHint as kc, PluginDiagnostic as kd, clearSkillSourceCache as kf, normalizePaletteItems as kg, ModelApprovalChoice as kh, RunSummaryValidation as ki, LoadedPluginRecord as kl, InferSchemaOutput as km, relativeArtifactPath as kn, defaultExtensionScanPaths as ko, CommandAgentResult as kp, tailTruncate as kr, GithubClient as ks, resolveLegacyPersistDir as kt, isValidExtensionConfigValue as ku, applyEnvironmentSettingsChange as kv, DecisionSuccess as kw, ProviderDecisionResponse as kx, defaultModelOf as ky, createTracingHooks as l, planBasetenReasoning as lC, toAnthropic as lD, hydrateReadStateFromSessionAsync as lE, getModelCatalog as lO, buildAssistantContent as lS, PromptImagePart as lT, SessionEventStatusStyle as l_, anchorPreviewFor as la, CredentialsFile as lb, ExtensionArtifactRendererEntry as lc, withIsolatedSpawnTool as ld, listSkillCandidates as lf, spaceModelDefault as lg, PLAN_AGENT as lh, OpenAIChatMessage as li, ExtensionSessionBadge as ll, PlanPayload as lm, createEvalRunReporter as ln, ExtensionInstallCandidate as lo, InlineAutocompleteContext as lp, EvalMetric as lr, GITHUB_ISSUE_PROVIDER_ID as ls, McpStaticClient as lt, ExtensionConfigActionStatus as lu, chainsEqual as lv, DecisionAnswerFor as lw, createSkillActivationState as lx, resolveExecution as ly, catalogChangeNotes as m, defaultAnthropicMaxTokens as mC, PairingDrop as mD, ToolStateController as mE, openaiCompat as mS, RepeatGuardToolMatcher as mT, parseSessionEventXml as m_, GenerateStructuredDataOptions as ma, SetProviderCredentialOptions as mb, ExtensionBadgeColor as mc, matchModelEntries as md, getDefaultScanPaths as mf, PALETTE_RECENTS_MAX as mg, compositionFits as mh, formattedHeadlessTurnEventToJsonl as mi, ExtensionStorageScope as ml, QuestionChoice as mm, fileContentQuality as mn, ExtensionInstallResult as mo, InlineGhost as mp, MetricSpecMap as mr, githubIssueView as ms, saveMcpClientSecret as mt, ExtensionConfigItem as mu, pickPrimaryKeyed as mv, DecisionFailure as mw, CacheDimensionSnapshot as mx, ProviderAccount as my, basicTools as n, toGooglePiMessages as nC, detectTurnInterruption as nD, ToolMap as nE, createStderrLineEmitter as nO, OpenAICompatAuthHeader as nS, ModelTargetSpec as nT, resolvePanelLoadContext as n_, buildFullCompactPrompt as na, formatUsagePercent as nb, ArtifactResolveOptions as nc, SpawnTool as nd, SkillInstallCandidate as nf, newSpaceId as ng, BUILD_AGENT as nh, HeadlessErrorInfo as ni, ExtensionReferenceSurface as nl, InteractionOrigin as nm, extensionScaffold as nn, ReferenceResolverOptions as no, SyntaxTokenStyle as np, MetricStats as nr, parseShortstat as ns, LoginMcpServerOptions as nt, ExtensionWorkspacePair as nu, shortId as nv, ProviderImageAvailability as nw, AgentHooks as nx, LOCAL_ENVIRONMENT as ny, TracingConventions as o, cerebras as oC, fromOpenAI as oD, getReadState as oE, ModelCatalogEntry as oO, applyOAICacheBreakpoints as oS, ProgressNudgeMessage as oT, SESSION_ROLE_KEY as o_, CompactScope as oa, updatedLabel as ob, ExtensionArtifactDetection as oc, SubagentOverride as od, SkillInstallResult as of, sessionSpaceFilter as og, DEFAULT_AGENT_ID as oh, HeadlessStatus as oi, ExtensionRunSettledHandler as ol, PRESENT_PLAN_TOOL as om, withZidaneSkillEditSkill as on, referenceProviderWires as oo, ThemeSurfaces as op, buildTrajectory as or, resolveArtifactKind as os, McpCredentialStore as ot, createWorkspaceSurface as ou, chainAccountConflict as ov, AgentDecide as ow, DeactivationReason as ox, createEnvironmentRegistry as oy, announcedDigest as p, cacheWriteTtlMultiplier as pC, ORPHANED_TOOL_RESULT_MARKER as pD, StagedToolState as pE, openAICompatPromptMessage as pS, RepeatGuardConfig as pT, orchestratedBy as p_, truncateHeadForPtlRetry as pa, ProviderCredential as pb, ExtensionArtifactsSurface as pc, formatModelLine as pd, discoverSkills as pf, PALETTE_LIMITS as pg, compositionByKey as ph, formatHeadlessTurnEvent as pi, ExtensionSource as pl, Question as pm, fileContains as pn, ExtensionInstallProvenance as po, tokenEndingAtCursor as pp, MetricSpec as pr, githubIssueReferenceProvider as ps, mcpOAuthProviderFor as pt, ExtensionConfigEnumItem as pu, pickChainPrimary as pv, DecisionEndHookContext as pw, CacheDimensionName as px, AuthMethod as py, Counter as q, XAI_IMAGE_MODELS as qC, normalizeMcpServers as qD, FileMapAdapter as qE, GoogleWireModel as qS, TurnUsage as qT, fmtCost as q_, buildExtensionRegistry as qa, ContextExtensionSection as qb, ExtensionPaletteWhen as qc, validateResourcePathReal as qd, StorageDirs as qf, PanelLoadScope as qg, SpaceIcon as qh, CompactPromptTooLongError as qi, ExtensionArtifactScope as ql, fanoutSink as qm, EvalRunSummaryCase as qn, ExtensionBusChannel as qo, InteractionsProvider as qp, grep as qr, GithubPullState as qs, ExtensionEditMarker as qt, mergeBadgeMenu as qu, EnvironmentNotReadyError as qv, DedupToolConfig as qw, sanitizeToolSchema as qx, shouldAutoCompact as qy, GEN_AI_ATTRIBUTES as r, CursorParams as rC, ensureEndsWithUserMessage as rD, HydrateReadStateOptions as rE, ThinkingLevel as rO, OpenAICompatHttpError as rS, NestedToolCallRecord as rT, ORCHESTRATED_BY_KEY as r_, buildTailCompactPrompt as ra, mostConstrainedWindow as rb, EMPTY_EXTENSION_REGISTRY as rc, SpawnToolOptions as rd, SkillInstallError as rf, normalizeSpaces as rg, BUILD_CODEMODE_AGENT as rh, HeadlessEvent as ri, ExtensionReferenceView as rl, InteractionRequest as rm, readSkillEditMarker as rn, compileReferencePattern as ro, Theme as rp, Trajectory as rr, pullRequestKind as rs, LoginMcpServerResult as rt, ExtensionWorkspaceSurface as ru, spawnStartParts as rv, ProviderImageRequest as rw, DecideHookContext as rx, SessionEnvironment as ry, TracingHookSet as s, BasetenParams as sC, reasoningWireAction as sD, hashContent as sE, ModelCatalogSource as sO, applyOAIToolCacheBreakpoint as sS, PromptAudioPart as sT, SessionEvent as s_, CompactionSlice as sa, usageTone as sb, ExtensionArtifactKindRegistration as sc, SubagentRegistry as sd, SkillInstallSpec as sf, spaceIdForNewSession as sg, DEFAULT_BUDGET_EXCLUDE_TOOLS as sh, HeadlessUsage as si, ExtensionRunTransform as sl, PendingInteractionEntry as sm, EvalTestRunner as sn, referenceProviders as so, resolveChipColor as sp, formatTrajectoryLine as sr, sessionBadges as ss, McpOAuthProvider as st, ExtensionConfigActionItem as su, chainEntryKey as sv, AgentDecisionsOptions as sw, SkillActivationState as sx, environmentActionSummaries as sy, _default as t, resolveVertexAuth as tC, autoDetectAndConvert as tD, ToolDescriptions as tE, attachStderrWarnPump as tO, OAITool as tS, ModelTarget as tT, panelShowsIn as t_, buildFromCompactPrompt as ta, formatCredits as tb, createArtifactDetectHook as tc, SpawnTaskOutcome as td, SkillCandidateDetail as tf, newSessionModel as tg, AgentRegistry as th, FormattedHeadlessTurnEvent as ti, ExtensionReferenceProvider as tl, HOST_INTERACTION_ID_PREFIX as tm, extensionDirForCwd as tn, ReferenceResolver as to, SyntaxStyles as tp, EvalWorkspaceSnapshot as tr, fileKind as ts, createMetricsHooks as tt, ExtensionWorkspaceOps as tu, previewLine as tv, MAX_IMAGES_PER_REQUEST as tw, AgentHookMap as tx, EnvironmentVerifyResult as ty, FROZEN_PROMPT_SECTION_KINDS as u, ArceeParams as uC, toOpenAI as uD, readStateKey as uE, setModelCatalog as uO, classifyOpenAICompatError as uS, PromptPart as uT, SessionEventTone as u_, sliceForCompaction as ua, OAuthCredential as ub, ExtensionArtifactRendererRegistration as uc, isSpawnTool as ud, parseSkillInstallSpec as uf, spaceOfSwitchItem as ug, ProfileSwitchNoteContext as uh, ProviderTranscriptFormat as ui, ExtensionSessionBadgeCardRow as ul, PlanRequest as um, registerEvalTests as un, ExtensionInstallError as uo, InlineAutocompleteProvider as up, EvalMetricError as ur, GITHUB_PULL_COLORS as us, clearMcpSignIn as ut, ExtensionConfigBooleanItem as uu, chainsEqualKeyed as uv, DecisionAnswers as uw, CacheBreakInfo as ux, runSessionEnvironmentAction as uy, systemSnapshotTurn as v, credentialIdentity as vC, RemintResult as vD, createToolStateController as vE, OpenAICompatStreamError as vS, RunHookMap as vT, sessionEventLabel as v_, normalizeShellCommand as va, ensureCredentialIds as vb, ExtensionBusEmitOptions as vc, ManifestValidation as vd, parseSkillFile as vf, PaletteGroup as vg, resolveAgentId as vh, transcriptToOpenAIMessages as vi, ExtensionToolRenderProps as vl, QuestionType as vm, statusCompleted as vn, InstalledExtensionTargetOptions as vo, CompletionItem as vp, emitEfficiencyMetrics as vr, githubRateLimitText as vs, OAuthCallbackResult as vt, ExtensionConfigScope as vu, reorderKeyed as vv, DecisionOutcome as vw, diffCacheDimensions as vx, BUILTIN_PROVIDERS as vy, SqliteSessionStoreOptions as w, AnthropicContextManagement as wC, ARTIFACTS_METADATA_KEY as wD, SkillResource as wE, toPiMessages as wS, SpawnHookContext as wT, RUN_RECEIPT_GLYPH as w_, definePreset as wa, removeProviderCredential as wb, ExtensionContextTransform as wc, AgentPluginsVersion as wd, skillCandidatesFromPaths as wf, RankedPaletteItem as wg, EditOutcome as wh, RunSummaryCollector as wi, ExtensionToolResultTransform as wl, isInteractionTool as wm, LlmJudgeOptions as wn, removeInstalledExtension as wo, findActiveTrigger as wp, WAIT_TASK_TIMED_OUT_PREFIX as wr, pullMeta as ws, SessionArtifactDirMigration as wt, WireExtensionConfigItem as wu, EnvironmentFieldDescriptor as wv, DecisionRequest as ww, InputTransformation as wx, ProviderUsageProbe as wy, flattenTurns as x, EXTENDED_CACHE_TTL_BETA as xC, dropInvalidToolPairings as xD, ShellInterpolationApproval as xE, classifyOpenAIError as xS, SessionHookContext as xT, sideSessionParent as x_, _default$1 as xa, readProviderCredential as xb, ExtensionCapability as xc, PLUGIN_MANIFEST_FILE as xd, SKILL_CANDIDATE_MAX_DEPTH as xf, PaletteItemKind as xg, ApprovalMode as xh, RunSummaryBlock as xi, ExtensionToolRendererRegistration as xl, buildResumedToolResultsTurn as xm, buildRegisteredEvals as xn, listExtensionCandidates as xo, CompletionSubmitContext as xp, HeadlessOptions as xr, parseGithubRefKey as xs, PERSISTENCE_PREVIEW_BYTES as xt, ExtensionConfigValue as xu, toggleChainEntry as xv, DecisionQuestion as xw, installCacheBreakLogger as xx, ModelOption as xy, ModelUsage as y, resolveAnthropicAuthShape as yC, SYNTHETIC_TOOL_RESULT_PLACEHOLDER as yD, isToolStateOps as yE, consumeSSE as yS, SessionContentBlock as yT, sessionEventMeta as y_, stableStringify as ya, providerFactoryOptions as yb, ExtensionBusMessage as yc, parsePluginManifest as yd, buildCatalog as yf, PaletteHost as yg, sessionComposition as yh, transcriptToProviderMessages as yi, ExtensionToolRenderer as yl, SelectQuestion as ym, formatEvalCaseSummary as yn, fetchExtensionSource as yo, CompletionProvider as yp, finalizeEvalMetrics as yr, githubRefKey as ys, startOAuthCallback as yt, ExtensionConfigStringItem as yu, restoreChainFallbacks as yv, DecisionPredicateAnswer as yw, fnv1a32 as yx, CustomField as yy, MutationValidationFailure as z, registerCustomOAuthProvider as zC, normalizeMcpBlocks as zD, getExtensionSessionState as zE, GoogleRequestAuth as zS, ToolResultDocumentContent as zT, nameFromModelId as z_, AgentCompactResult as za, ContextBreakdown as zb, ExtensionModal as zc, SkillTokenWeights as zd, githubPreviewImageUrl as zf, PanelCustomItem as zg, StreamEvent as zh, selectFilesFromSession as zi, ExtensionHudStatus as zl, Logger as zm, EvalCaseOptions as zn, createExtensionPromptBridge as zo, CommandStep as zp, shell as zr, githubTokenFingerprint as zs, collectNewlyStaleReadPaths as zt, BadgeTargetKind as zu, EnvironmentActionSummary as zv, ChildSpawnHookContext as zw, ZaiParams as zx, openrouterDescriptor as zy };
-//# sourceMappingURL=index-DyQyDLX1.d.ts.map
+export { MetricsHooksOptions as $, ImageAspectRatio as $C, ensureToolResultPairing as $D, ModelCatalogSource as $E, googleVertex as $S, ToolDef as $T, formatElapsed as $_, ReferenceMatch as $a, buildContextBreakdown as $b, ExtensionReferenceCardFact as $c, stripShellInterpolations as $d, ChipColorMap as $f, normalizePanelLoadContext as $g, defaultSessionModel as $h, TRAILER as $i, ExtensionSessionSummary as $l, AgentComposition as $m, EvalWorkspaceFile as $n, branchKind as $o, ConfirmQuestion as $p, edit as $r, readGithubPulls as $s, buildZidaneSkillEditSkill as $t, ExtensionSubagentDef as $u, EnvironmentRequest as $v, McpServerConfig as $w, openrouter as $x, UsageTone as $y, SqlValue as A, resolvePromptCacheKey as AC, ToWireMessagesOptions as AD, connectMcpServers as AE, MistralParams as AS, StreamProgressHookContext as AT, RunReceiptSegment as A_, DecisionError as Aa, storedCredentialById as Ab, ExtensionGuiPanel as Ac, PluginManifest as Ad, RECOMMENDED_SKILL_SOURCES as Af, normalizePaletteRunResult as Ag, OpenInTarget as Ah, createRunSummaryCollector as Ai, SessionBadgeEntry as Al, SchemaInput as Am, CreateEvalAgentOptions as An, discoverExtensions as Ao, CommandArgSuggestion as Ap, SkillsUseToolOptions as Ar, GithubClientOptions as As, resolveLegacySessionDir as At, resolveExtensionConfig as Au, applyEnvironmentSettingsChange as Av, DecisionSuccess as Aw, ProviderDecisionResponse as Ax, defaultModelOf as Ay, MutationValidationHooksOptions as B, registerCustomOAuthProvider as BC, toAnthropic as BD, pinnedMcpRedirectUri as BE, GoogleRequestAuth as BS, ToolResultDocumentContent as BT, nameFromModelId as B_, AgentOptions as Ba, ContextBreakdown as Bb, ExtensionModalNode as Bc, skillTokenWeights as Bd, groupSkillPicks as Bf, PanelFocus as Bg, ToolCallDisplay as Bh, selectRecentFiles as Bi, ExtensionHudWriter as Bl, LoggingHookSet as Bm, EvalCaseResult as Bn, ExtensionMcpHost as Bo, CommandStepContext as Bp, RECORD_ARTIFACT_TOOL as Br, githubTokenSource as Bs, renderStaleReadNotice as Bt, ExtensionBadgeActions as Bu, EnvironmentActionSummary as Bv, ChildSpawnHookContext as Bw, ZaiParams as Bx, openrouterDescriptor as By, statsByModel as C, applyAnthropicCacheBreakpoints as CC, createMemoryStore as CD, SkillConfig as CE, mapCodexStopReason as CS, SessionMessage as CT, ModelNamer as C_, composePresets as Ca, readProviderCredentialPair as Cb, ExtensionContext as Cc, loadAgentPlugin as Cd, sanitizeSkillName as Cf, PaletteRunResult as Cg, EditHunk as Ch, RunSummaryByModel as Ci, ExtensionToolResultPatch as Cl, createInteractionTools as Cm, defineEval as Cn, readExtensionInstallProvenance as Co, collectReferences as Cp, writeFile as Cr, pullFromMeta as Cs, PersistOutcome as Ct, StoredExtensionConfigItem as Cu, toggleKeyed as Cv, DecisionQuestions as Cw, snapshotCacheDimensions as Cx, ProviderDescriptor as Cy, sqliteStoreFile as D, PromptCacheKeyContext as DC, SaveMetaOptions as DD, SkillsConfig as DE, NeuralwattParams as DS, StaleReadPolicy as DT, RunReceipt as D_, ToolSearchToolOptions as Da, setCredentialLabel as Db, ExtensionCustomRendererEntry as Dc, PluginAuthor as Dd, SkillBrowseErrorCode as Df, groupPaletteRows as Dg, InteractionMode as Dh, RunSummaryRepeatGuard as Di, GuiContributions as Dl, pendingInteractionsFromTurns as Dm, createReusableExecutionContext as Dn, ENTRY_CANDIDATES as Do, resolveCompletionSubmit as Dp, validateToolArgs as Dr, viewForRead as Ds, maybePersistToolResult as Dt, coerceExtensionConfigInput as Du, EnvironmentSettings as Dv, DecisionScoreLevel as Dw, ProviderCapabilities as Dx, anthropicDescriptor as Dy, createSqliteSessionStore as E, AnthropicParams as EC, createFileMapStore as ED, SkillSource as EE, NEURALWATT_DEFAULT_MODEL as ES, SpawnQueuedContext as ET, RUN_RECEIPT_TURN_GLYPH as E_, LazyToolEntry as Ea, removeStoredCredential as Eb, ExtensionCustomRenderer as Ec, LoadedPlugin as Ed, SkillBrowseError as Ef, fuzzyMatch as Eg, EditPayload as Eh, RunSummaryError as Ei, ExtensionTuiSurface as El, makeRequestInteraction as Em, ReusableExecutionContext as En, registerExtensionHostModules as Eo, mergeSuggestions as Ep, ValidationResult as Er, viewForIssueRead as Es, cleanupPersistedSession as Et, clampExtensionConfigNumber as Eu, EnvironmentSecrets as Ev, DecisionScoreAnswer as Ew, Provider as Ex, ProviderUsageReport as Ey, createSqliteDriver as F, extractRuntimeCredentials as FC, filterUnresolvedToolUses as FD, wrapDiscoveredMcpTools as FE, GOOGLE_DEFAULT_MODEL as FS, ToolBatchExecutor as FT, formatRunReceiptCells as F_, Agent as Fa, ContextSegment as Fb, ExtensionMcpConfigTransform as Fc, parseSchemaId as Fd, SkillSourceInfo as Ff, ExtensionPanelScope as Fg, SessionHeader as Fh, PostCompactRestoreOptions as Fi, ExtensionComposerBadgeOptions as Fl, ConsoleSinkOptions as Fm, EvalAgentRunStats as Fn, DiscoverAndBuildExtensionRegistryOptions as Fo, CommandInvocation as Fp, createSkillsReadTool as Fr, configureGithubClient as Fs, INTERRUPT_MESSAGE_FOR_TOOL_USE as Ft, BadgeActionEffect as Fu, resolveProviderConfig as Fv, AgentStats as Fw, TokenCountPayload as Fx, modelLabel as Fy, normalizeProviders as G, ThinkingBindingBehavior as GC, PairingDrop as GD, originPinnedFetch as GE, GoogleStreams as GS, ToolResultTextContent as GT, ageString as G_, BuildExtensionRegistryOptions as Ga, ContextCategoryId as Gb, ExtensionPaletteProviderEntry as Gc, parseAllowedToolPattern as Gd, installAllowedToolsGate as Gf, PanelLoadContext as Gg, SessionKnobs as Gh, compactConversation as Gi, MAX_COMPOSER_BADGES as Gl, createLoggingHooks as Gm, EvalRunReporterOptions as Gn, EXTENSION_BUS_MAX_PAYLOAD_BYTES as Go, executeCommand as Gp, InteractionToolOptions as Gr, GithubPullRead as Gs, EXTENSION_EDIT_METADATA_KEY as Gt, builtinBadgeEffect as Gu, EnvironmentConfigValue as Gv, CompactStartHookContext as Gw, SchemaSanitizeOptions as Gx, AutoCompactInput as Gy, MutationValidationResult as H, writeOAuthCredentials as HC, toWireMessages as HD, withoutEnvPlaceholders as HE, GoogleSharedParams as HS, ToolResultImageContent as HT, AgeStep as H_, McpConnector as Ha, ContextBreakdownContributor as Hb, ExtensionPaletteCommand as Hc, SkillValidationResult as Hd, skillPickKey as Hf, PanelItem as Hg, DEFAULT_SPACE_ID as Hh, CompactOptions as Hi, ExtensionNotifyOptions as Hl, RingBufferSink as Hm, EvalDefinitionContext as Hn, defineExtension as Ho, commandBlockToEvent as Hp, readFile as Hr, GithubStateStore as Hs, createFileGithubStateStore as Ht, badgeMenu as Hu, EnvironmentAvailabilityInput as Hv, CompactEndHookContext as Hw, zai as Hx, restoreModelOptions as Hy, createSqliteWriteQueue as I, isOAuthAccessToken as IC, fromAnthropic as ID, expandEnvPlaceholders as IE, GOOGLE_EXTRA_MODELS as IS, ToolHookContext as IT, formatRunReceiptLine as I_, AgentCacheChange as Ia, ContextSegmentFile as Ib, ExtensionMcpServerInfo as Ic, defineSkill as Id, SkillSourceListing as If, PANEL_CONTENT_LIMITS as Ig, SessionMeta as Ih, RecentFile as Ii, ExtensionHud as Il, LogLevel as Im, EvalAgentStats as In, discoverAndBuildExtensionRegistry as Io, CommandOutputBlock as Ip, shellKill as Ir, createGithubClient as Is, SHELL_CASCADE_CANCEL_MESSAGE as It, BadgeActionsMatch as Iu, ENVIRONMENT_METADATA_KEY as Iv, AutoCompact as Iw, ToolCall as Ix, modelOptionsFor as Iy, Histogram as J, XAI_IMAGE_MODELS as JC, PairingRepairMode as JD, createStderrLineEmitter as JE, GoogleWireModel as JS, TurnUsage as JT, fmtCost as J_, disposeExtensionRegistry as Ja, ContextExtensionSection as Jb, ExtensionPaths as Jc, validateSkillForWrite as Jd, StorageMode as Jf, PanelMarkdownItem as Jg, SpaceModelDefault as Jh, BASE_INSTRUCTIONS as Ji, ExtensionHostRuntimeBridge as Jl, jsonSink as Jm, EvalRunUsage as Jn, ExtensionBusEnvelope as Jo, useInteractionsActions as Jp, glob as Jr, KnownGithubPull as Js, SKILL_EDIT_METADATA_KEY as Jt, normalizeBadgeEffect as Ju, EnvironmentNotReadyError as Jv, DedupToolConfig as Jw, sanitizeToolSchema as Jx, shouldAutoCompact as Jy, resolveModelTargets as K, planAnthropicThinking as KC, PairingDropKind as KD, McpExecutionBinding as KE, GoogleVertexParams as KS, ToolResultVideoContent as KT, compactPath as K_, ExtensionCatalogPartition as Ka, ContextExactCounts as Kb, ExtensionPaletteRunResult as Kc, validateResourcePath as Kd, ResolveStorageDirsOptions as Kf, PanelLoadContextInput as Kg, Space as Kh, CompactInvalidInputError as Ki, createExtensionHud as Kl, createRingBufferSink as Km, EvalRunSummary as Kn, ExtensionBus as Ko, parseCommandInvocation as Kp, createInteractionTool as Kr, GithubPullRef as Ks, EditSessionTarget as Kt, extensionBadgeActions as Ku, EnvironmentExecution as Kv, DEFAULT_AGENT_CLOCK as Kw, SchemaSanitizeProfile as Kx, OUTPUT_RESERVE_TOKENS as Ky, isSqliteBusyError as L, pinnedAccountMissingError as LC, fromOpenAI as LD, expandMcpConfigEnv as LE, GoogleCompatibleRoute as LS, ToolOutcome as LT, formatTokenCount as L_, AgentCacheImpact as La, ContextSegmentOrigin as Lb, ExtensionMcpSurface as Lc, writeSkillToDisk as Ld, SkillSourceSkill as Lf, PanelAction as Lg, Settings as Lh, buildPostCompactAttachments as Li, ExtensionHudBadge as Ll, LogRecord as Lm, createEvalAgent as Ln, ExtensionPromptBridge as Lo, CommandSpawnResult as Lp, CreateShellToolOptions as Lr, githubApiBase as Ls, TOOL_USE_CANCELLED_MESSAGE as Lt, BadgeMenuItem as Lu, EnvironmentAction as Lv, AutoCompactConfig as Lw, ToolResult as Lx, modelSupportsReasoning as Ly, SqliteDriver as M, ResolveOAuthApiKeyOptions as MC, autoDetectAndConvert as MD, resultToString as ME, planMistralReasoning as MS, SystemFreezeOptions as MT, fitRunReceiptCells as M_, DecisionInvalidResponseError as Ma, writeCredentials as Mb, ExtensionKeybinding as Mc, SUPPORTED_AGENT_PLUGINS_VERSIONS as Md, SkillInstallTarget as Mf, rankPaletteItems as Mg, Picked as Mh, estimateTokens as Mi, isBadgeColor as Ml, isStandardSchema as Mm, EvalAgentMcpServers as Mn, isExtensionDefinition as Mo, CommandExecution as Mp, SkillsRunScriptToolOptions as Mr, GithubRequest as Ms, resolvePersistDir as Mt, sanitizeExtensionConfigActionPatch as Mu, describeEnvironments as Mv, AgentBehavior as Mw, ProviderMeta as Mx, getContextWindow as My, SqliteStatement as N, credentialsFilePath as NC, detectTurnInterruption as ND, deriveMcpToolMeta as NE, LocalParams as NS, SystemPromptSnapshot as NT, formatCostUsd as N_, DecisionTimeoutError as Na, AgentAccent as Nb, ExtensionKeybindingDispatchContext as Nc, agentPluginsSchemaId as Nd, SkillPick as Nf, ExtensionPanel as Ng, Screen as Nh, utf8ByteLength as Ni, ExtensionBannerOptions as Nl, resolveSchemaInput as Nm, EvalAgentRunOptions as Nn, parseExtensionScanPathEnv as No, CommandGenerateDataOptions as Np, createSkillsRunScriptTool as Nr, classifyGithubAnswer as Ns, resolveSessionDir as Nt, toWireConfigSchema as Nu, isEnvironmentEnabled as Nv, AgentClock as Nw, StreamCallbacks as Nx, getModelInfo as Ny, ReadonlySqliteSessionStore as O, PromptCacheKeyOption as OC, mergeSessionMetadata as OD, ConnectMcpServersOptions as OE, neuralwatt as OS, StepThinkingDecay as OT, RunReceiptCell as O_, createToolSearchTool as Oa, setPreferredCredential as Ob, ExtensionDefinition as Oc, PluginComponentStatus as Od, browseSkillSource as Of, isPaletteContext as Og, ModelApproval as Oh, RunSummaryTokens as Oi, LoadedExtension as Ol, serializeInteractionResponse as Om, artifactPath as On, ExtensionScanEntry as Oo, Command as Op, TailTruncateOptions as Or, GithubAnswer as Os, migrateSessionArtifactDirs as Ot, isValidExtensionConfigItem as Ou, EnvironmentSettingsChange as Ov, DecisionScoreQuestion as Ow, ProviderDecisionAvailability as Ox, cerebrasDescriptor as Oy, SqliteWriteQueue as P, credentialsFromParams as PC, ensureEndsWithUserMessage as PD, nonOwningMcpView as PE, local as PS, ThinkingDecay as PT, formatRunDuration as P_, DecisionUnsupportedError as Pa, accentColor as Pb, ExtensionManifest as Pc, isSupportedAgentPluginsVersion as Pd, SkillPickGroup as Pf, ExtensionPanelEntry as Pg, SessionEnvironmentSummary as Ph, PostCompactAttachments as Pi, ExtensionComposerBadge as Pl, zodToJsonSchema as Pm, EvalAgentRunResult as Pn, scanExtensionDirectories as Po, CommandInteraction as Pp, SkillsReadToolOptions as Pr, clockTime as Ps, resolveTasksDir as Pt, BadgeAction as Pu, readEnvironmentSettings as Pv, AgentRunOptions as Pw, StreamOptions as Px, localDescriptor as Py, MetricsHookSet as Q, IMAGE_ASPECT_RATIOS as QC, dropInvalidToolPairings as QD, ModelCatalogEntry as QE, googleCompatible as QS, ToolContext as QT, formatDuration as Q_, partitionExtensionCatalog as Qa, ContextUsageSplit as Qb, ExtensionReferenceCard as Qc, interpolateShellCommands as Qd, ChipColor as Qf, normalizePanelContent as Qg, defaultSessionKnobs as Qh, NO_TOOLS_PREAMBLE as Qi, ExtensionSessionControl as Ql, nextLogLevel as Qm, EvalVariantSummary as Qn, artifactKindLabel as Qo, AnswerValue as Qp, createGenerateImageTool as Qr, readGithubPull as Qs, buildZidaneExtensionSkill as Qt, ChildAgent as Qu, EnvironmentRegistry as Qv, McpOAuthClientConfig as Qw, normalizeOpenRouterModelId as Qx, ProviderUsageWindow as Qy, MutationValidationBatch as R, readAccountOAuthCredential as RC, reasoningWireAction as RD, isValidCallbackPort as RE, GoogleExtraModel as RS, ToolResultAudioContent as RT, formatTokensPerSecond as R_, AgentCompactOptions as Ra, ContextSegmentsInput as Rb, ExtensionMcpToolResult as Rc, writeSkillsToDisk as Rd, githubAvatarUrl as Rf, PanelContent as Rg, SpawnEndInfo as Rh, selectFilesFromReadState as Ri, ExtensionHudState as Rl, LogSink as Rm, EvalArtifacts as Rn, ExtensionPromptDelivery as Ro, CommandSpawnTask as Rp, createShellTool as Rr, githubClient as Rs, TOOL_USE_SKIPPED_MESSAGE as Rt, BadgeTarget as Ru, EnvironmentActionInput as Rv, CacheTtl as Rw, ToolSpec as Rx, modelsForDescriptor as Ry, formatTokenUsage as S, EXTENDED_CACHE_TTL_BETA as SC, createRemoteStore as SD, ShellInterpolationApproval as SE, classifyOpenAIError as SS, SessionHookContext as ST, truncateTitle as S_, Preset as Sa, readProviderCredential as Sb, ExtensionComposerSurface as Sc, defaultPluginDataRoot as Sd, SkillPathCandidate as Sf, PaletteProvider as Sg, EditDiffDisplay as Sh, RunSummaryBudget as Si, ExtensionToolResultMetadataRegistration as Sl, createAutomaticInteractionResponse as Sm, clearRegisteredEvals as Sn, parseExtensionInstallSource as So, applyInsert as Sp, runHeadless as Sr, pullChecks as Ss, PersistInput as St, ExtensionConfigValueItem as Su, toggleChainEntry as Sv, DecisionQuestion as Sw, installCacheBreakLogger as Sx, ModelOption as Sy, SqliteStoreFile as T, AnthropicContextManagement as TC, FileMapStoreOptions as TD, SkillResource as TE, toPiMessages as TS, SpawnHookContext as TT, RUN_RECEIPT_SWITCH_GLYPH as T_, createAgent as Ta, removeProviderCredential as Tb, ExtensionContributions as Tc, LoadAgentPluginOptions as Td, BrowseSkillSourceOptions as Tf, createPaletteRanker as Tg, EditOutcomeKind as Th, RunSummaryCollectorOptions as Ti, ExtensionToolVerdict as Tl, isModelInteraction as Tm, llmJudge as Tn, updateInstalledExtension as To, mergeReferences as Tp, waitTask as Tr, pullStateLook as Ts, buildPersistedStub as Tt, WireExtensionConfigSchema as Tu, EnvironmentFieldDescriptor as Tv, DecisionRequest as Tw, InputTransformation as Tx, ProviderUsageProbe as Ty, SuccessfulMutationOutcome as U, AnthropicThinkingPlan as UC, EnsureToolResultPairingOptions as UD, PinnedFetch as UE, GoogleStreamFn as US, ToolResultImageRefContent as UT, SpawnEndSummary as U_, McpToolMeta as Ua, ContextBreakdownOptions as Ub, ExtensionPaletteItem as Uc, isToolAllowedByUnion as Ud, skillPickOf as Uf, PanelKeyValueItem as Ug, DEFAULT_SPACE_NAME as Uh, CompactResult as Ui, ExtensionNotifyTone as Ul, consoleSink as Um, EvalRunMetricAggregate as Un, buildExtensionPreset as Uo, commandBlocksToContent as Up, multiEdit as Ur, createMemoryGithubStateStore as Us, isGhRateLimitError as Ut, badgePromptText as Uu, EnvironmentConfig as Uv, CompactFunction as Uw, XaiParams as Ux, AUTO_COMPACT_MIN_GROWTH_FRACTION as Uy, MutationValidationMutation as V, resolveOAuthApiKey as VC, toOpenAI as VD, resolveTransportConfig as VE, GoogleRouteName as VS, ToolResultDocumentRefContent as VT, runReceiptFromRun as V_, AgentToolState as Va, ContextBreakdownContributionContext as Vb, ExtensionOrderedContribution as Vc, SkillValidationIssue as Vd, skillCategory as Vf, PanelIcon as Vg, TranscriptDensity as Vh, CompactEndEvent as Vi, ExtensionNotification as Vl, LoggingHooksOptions as Vm, EvalDefinition as Vn, createMcpSurface as Vo, CommandStepFn as Vp, recordArtifact as Vr, normalizeGithubHost as Vs, applyCompactSummaryCutoff as Vt, artifactBadgeTarget as Vu, EnvironmentAvailability as Vv, ChildSpawnIdentity as Vw, planZaiReasoning as Vx, piIdOf as Vy, createMutationValidationHooks as W, THINKING_BINDING_SETTING_ENV as WC, ORPHANED_TOOL_RESULT_MARKER as WD, isAllowedRemoteUrl as WE, GoogleStreamOptions as WS, ToolResultMetadata as WT, ageStep as W_, McpToolWrap as Wa, ContextCategory as Wb, ExtensionPaletteProvider as Wc, matchesAllowedTool as Wd, IMPLICITLY_ALLOWED_SKILL_TOOLS as Wf, PanelKeyValueRow as Wg, SPACE_METADATA_KEY as Wh, CompactStartEvent as Wi, ExtensionStatusOptions as Wl, createLogger as Wm, EvalRunReporter as Wn, composeExtensionPreset as Wo, commandSteps as Wp, listFiles as Wr, GithubPull as Ws, rateLimitResetFromJson as Wt, builtinBadgeActions as Wu, EnvironmentConfigField as Wv, CompactHookContext as Ww, xai as Wx, AutoCompactDecision as Wy, Meter as X, OPENAI_IMAGE_MODELS as XC, SYNTHETIC_TOOL_RESULT_PLACEHOLDER as XD, isThinkingLevel as XE, fromGooglePiAssistantMessage as XS, toolOutputByteLength as XT, formatCostLabel as X_, filterRegistryPlugins as Xa, ContextMcpGroup as Xb, ExtensionPromptTransform as Xc, resolveSkills as Xd, resolveStorageDirs as Xf, PanelSection as Xg, activeSpaceOf as Xh, CompactPromptBuilder as Xi, ExtensionModelEntry as Xl, filterLogRecords as Xm, EvalScorer as Xn, serializedPayloadBytes as Xo, ASK_USER_TOOL as Xp, GenerateImageToolOptions as Xr, githubPullConfirmedAt as Xs, ZIDANE_EXTENSION_SKILL_NAME as Xt, runBadgeAction as Xu, EnvironmentPrepareResult as Xv, GeometricThinkingDecay as Xw, OPENROUTER_DEFAULT_MODEL as Xx, ProviderUsageSnapshot as Xy, InstrumentOptions as Y, openrouterImageModels as YC, RemintResult as YD, ThinkingLevel as YE, classifyGoogleError as YS, toolOutputBudgetByteLength as YT, fmtTokens as Y_, filterExtensionRegistry as Ya, ContextItem as Yb, ExtensionPermission as Yc, validateSkillName as Yd, StorageSlot as Yf, PanelRowItem as Yg, SpacesSettings as Yh, CompactDirection as Yi, ExtensionHostRuntimeImpl as Yl, LOG_LEVEL_CYCLE as Ym, EvalScore as Yn, createExtensionBus as Yo, useInteractionsQueue as Yp, DEFAULT_IMAGE_DIR as Yr, clearGithubPullMemory as Ys, SkillEditMarker as Yt, normalizeBadgeTarget as Yu, EnvironmentPrepareInput as Yv, FrozenPromptSections as Yw, sanitizeToolSpecs as Yx, ProviderUsageCredits as Yy, MetricAttributes as Z, GOOGLE_IMAGE_MODELS as ZC, TOOL_USE_INTERRUPTED_MARKER as ZD, ModelCatalog as ZE, google as ZS, toolResultToText as ZT, formatCount as Z_, mergeContributions as Za, ContextSnapshot as Zb, ExtensionProviderMiddleware as Zc, InterpolateShellCommandsOptions as Zd, BUILTIN_THEMES as Zf, isExtensionPanelScope as Zg, defaultSessionAgent as Zh, CompactPromptOptions as Zi, ExtensionRuntimeSurface as Zl, formatLogLine as Zm, EvalScorerContext as Zn, BUILTIN_ARTIFACT_KINDS as Zo, AUTOMATIC_INTERACTION_INSTRUCTION as Zp, ImageModelSource as Zr, queueGithubPull as Zs, ZIDANE_SKILL_EDIT_SKILL_NAME as Zt, sessionBadgeTarget as Zu, EnvironmentProvider as Zv, JsonValue as Zw, OpenRouterParams as Zx, ProviderUsageStatus as Zy, sectionDigests as _, classifyAnthropicError as _C, loadSession as _D, ToolStateStore as _E, toolResultsMessage as _S, ResolveContentRefBlock as _T, sessionEventExcerpt as __, defaultRepeatGuardTracked as _a, applyApiKeyEnv as _b, ExtensionBehaviorTransform as _c, expandPluginVars as _d, parseSkillContent as _f, PaletteContext as _g, profileTools as _h, providerTranscriptFormatForProvider as _i, ExtensionToolPolicy as _l, QuestionResponse as _m, functionalityMetric as _n, InstallExtensionFromSpecOptions as _o, CompletionContext as _p, efficiencyMetricValues as _r, githubPullView as _s, OAuthCallbackOptions as _t, ExtensionConfigNumberItem as _u, providerKeySetChanged as _v, DecisionInput as _w, CachePromptSections as _x, ProviderKey as _y, StartSpan as a, cursor as aC, Session as aD, ReadStateEntry as aE, ArtifactFilter as aO, OpenAICompatParams as aS, OAuthRefreshHookContext as aT, SESSION_EVENT_STATUS_STYLE as a_, ANCHOR_PREVIEW_MAX_CHARS as aa, resetLabel as ab, ExtensionApiVersion as ac, SubagentDef as ad, SkillInstallOptions as af, resolveSessionSpace as ag, BuiltInPrompt as ah, HeadlessResult as ai, ExtensionRunSettledEvent as al, InteractionsActions as am, withZidaneExtensionSkill as an, findReferences as ao, ThemeSelect as ap, TrajectoryStepKind as ar, renderArtifactRow as as, McpCredentialEntry as at, createExtensionHostRuntimeBridge as au, ModelChainEntry as av, ProviderImageResponse as aw, ActivationVia as ax, assertEnvironmentReady as ay, TokenUsageLike as b, resolveAnthropicAuthShape as bC, withExtensionSession as bD, isToolStateOps as bE, consumeSSE as bS, SessionContentBlock as bT, shortSessionId as b_, localReliabilityBehavior as ba, providerFactoryOptions as bb, ExtensionBusSurface as bc, validatePluginManifest as bd, skillCatalogEntry as bf, PaletteItem as bg, singleAgentRegistry as bh, RunSummary as bi, ExtensionToolRendererEntry as bl, TextQuestion as bm, formatEvalRunSummary as bn, installExtensionFromSpec as bo, CompletionReference as bp, normalizeMetric as br, isPullFresh as bs, PERSISTED_STUB_PREFIX as bt, ExtensionConfigSurface as bu, restoreChainFallbacks as bv, DecisionPredicateAnswer as bw, fnv1a32 as bx, CustomField as by, TracingHooksOptions as c, BasetenParams as cC, SessionMetaRow as cD, hashContent as cE, matchesArtifactFilter as cO, applyOAIToolCacheBreakpoint as cS, PromptAudioPart as cT, SessionEventStatus as c_, SummaryToTurnInput as ca, usageTone as cb, ExtensionArtifactQuery as cc, createSpawnTool as cd, installSkillFromSpec as cf, spaceMetadata as cg, DEFAULT_PERSIST_EXCLUDE_TOOLS as ch, OpenAIChatContentPart as ci, ExtensionRuntimeEnv as cl, PlanDecision as cm, RegisterEvalTestsOptions as cn, ExtensionFetchResult as co, resolveTheme as cp, EFFICIENCY_METRICS as cr, BUILTIN_REFERENCE_PROVIDERS as cs, McpOAuthProviderOptions as ct, ExtensionConfigActionResult as cu, chainEntryKey as cv, AgentDecisionsOptions as cw, SkillActivationState as cx, environmentActionSummaries as cy, FrozenSystemPrompt as d, ArceeParams as dC, SessionStore as dD, readStateKey as dE, selectArtifactEvictions as dO, classifyOpenAICompatError as dS, PromptPart as dT, WORKER_REPORT_FRAGMENT as d_, stripImagesFromTurns as da, OAuthCredential as db, ExtensionArtifactRow as dc, SpawnModelEntry as dd, readSkillProvenance as df, spaceSwitchItems as dg, availableAgents as dh, exitCodeForHeadlessResult as di, ExtensionSessionStateSurface as dl, PlanResponse as dm, runEvalCase as dn, ExtensionInstallErrorCode as do, createPathAutocompleteProvider as dp, MetricDirection as dr, GITHUB_PULL_PROVIDER_ID as ds, createMemoryMcpCredentialStore as dt, ExtensionConfigCategory as du, chainsEqualKeyed as dv, DecisionAnswers as dw, CacheBreakInfo as dx, runSessionEnvironmentAction as dy, loadGoogleWireKit as eC, ModelTier as eD, ToolDescriptionOverride as eE, remintDuplicateToolCallIds as eO, ASSISTANT_TOOL_CALLS_TAG as eS, McpToolHookContext as eT, panelBadgeText as e_, buildCompactPrompt as ea, activeSnapshotFor as eb, ArtifactDetectHookOptions as ec, SpawnTaskInput as ed, SKILL_PROVENANCE_FILE as ef, findSpace as eg, AgentProfile as eh, FormattedHeadlessResult as ei, ExtensionReferencePattern as el, CreateInteractionToolsOptions as em, editSessionMetadata as en, ReferenceProviderWire as eo, DEFAULT_THEME as ep, EvalWorkspaceOptions as er, commitKind as es, UpDownCounter as et, ExtensionSessionsSurface as eu, formatTaskStatus as ev, ImageData as ew, AgentHookBus as ex, EnvironmentState as ey, SectionChangeNote as f, arcee as fC, createSession as fD, resolveReadStateMap as fE, sortArtifacts as fO, formatTools as fS, PromptTextPart as fT, isMainSession as f_, summaryToTurn as fa, PreferCredentialResult as fb, ExtensionArtifactRowFact as fc, createModelSearchTool as fd, SourcedScanPath as ff, spacesEnabled as fg, builtInPromptOf as fh, formatHeadlessResult as fi, ExtensionSkillPolicy as fl, PlanStep as fm, buildEvalRunSummary as fn, ExtensionInstallIo as fo, resolveInlineSuggestion as fp, MetricEmitter as fr, fetchGithubPullRequest as fs, hasAuthorizationHeader as ft, ExtensionConfigChangeBehavior as fu, filterChainFallbacks as fv, DecisionChoiceAnswer as fw, CacheBreakLoggerOptions as fx, verifyEnvironment as fy, sectionDigest as g, resolveAnthropicMaxOutput as gC, getExtensionSessionState as gD, ToolStateOp as gE, toOAIMessages as gS, ResolveContentRef as gT, sessionDirLabel as g_, defaultRepeatGuardNormalize as ga, StoredCredential as gb, ExtensionBadgeTone as gc, PLUGIN_MCP_FILE as gd, parseFrontmatter as gf, PALETTE_RESULT_MAX as gg, profileComposition as gh, installHeadlessEventAdapter as gi, ExtensionToolCatalogTransform as gl, QuestionRequest as gm, fileExistsOneOf as gn, ExtensionInstallSource as go, ActiveTrigger as gp, defineMetrics as gr, githubPullUrl as gs, OAuthCallbackHandle as gt, ExtensionConfigModelItem as gu, positionKeyed as gv, DecisionFailureReason as gw, CacheDriftInfo as gx, ProviderAuth as gy, latestSystemSnapshot as h, defaultAnthropicMaxTokens as hC, demoteStaleRunningStatus as hD, ToolStateController as hE, openaiCompat as hS, RepeatGuardToolMatcher as hT, renderSessionEventXml as h_, generateStructuredData as ha, SetProviderCredentialOptions as hb, ExtensionBadgeIcon as hc, PLUGIN_SKILLS_DIR as hd, inferSource as hf, PALETTE_RECENT_GROUP as hg, compositionTools as hh, headlessEventToJsonl as hi, ExtensionStorageSurface as hl, QuestionPayload as hm, fileExists as hn, ExtensionInstallScope as ho, patchInlineGhost as hp, computeEvalTagScores as hr, githubPullReferenceProvider as hs, McpOAuthCallbackPageRenderer as ht, ExtensionConfigItemBase as hu, pickPrimaryKeyed as hv, DecisionFailure as hw, CacheDimensionSnapshot as hx, ProviderAccount as hy, Span as i, CursorParams as iC, LoadSessionOptions as iD, HydrateReadStateOptions as iE, ARTIFACT_META_MAX_BYTES as iO, OpenAICompatHttpError as iS, NestedToolCallRecord as iT, ProjectBrief as i_, buildUpToCompactPrompt as ia, mostConstrainedWindow as ib, ExtensionAgentPluginOptions as ic, SpawnToolState as id, SkillInstallErrorCode as if, readSessionSpaceId as ig, BUILTIN_AGENTS as ih, HeadlessOutputFormat as ii, ExtensionRegistry as il, InteractionResponse as im, resolveExtensionDocsDir as in, createReferenceResolver as io, ThemeColors as ip, TrajectoryStep as ir, refreshArtifact as is, loginMcpServer as it, createArtifactsSurface as iu, spawnStartParts as iv, ProviderImageRequest as iw, DecideHookContext as ix, SessionEnvironment as iy, SqliteDatabaseLike as j, OAuthParams as jC, TurnInterruptionState as jD, normalizeMcpBlocks as jE, mistral as jS, StreamUsageSnapshot as jT, RunReceiptSegmentKind as j_, DecisionHttpError as ja, storedCredentialsOf as jb, ExtensionGuiSurface as jc, PluginSchemaKind as jd, RecommendedSkillSource as jf, pushPaletteRecent as jg, Owner as jh, BYTES_PER_TOKEN as ji, TuiContributions as jl, StandardSchemaLike as jm, EvalAgent as jn, inlineLoadedExtension as jo, CommandAttachment as jp, createSkillsUseTool as jr, GithubIdentity as js, resolveMcpWarningsDir as jt, resolveExtensionConfigValue as ju, defaultEnvironmentKind as jv, DecisionUsage as jw, ProviderDecisions as jx, enabledModelOptions as jy, createReadonlySqliteSessionStore as k, derivePromptCacheKey as kC, ReasoningWireAction as kD, McpConnection as kE, planNeuralwattReasoning as kS, StreamHookContext as kT, RunReceiptCellKind as k_, DEFAULT_DECISION_TIMEOUT_MS as ka, setProviderCredential as kb, ExtensionFooterHint as kc, PluginDiagnostic as kd, clearSkillSourceCache as kf, normalizePaletteItems as kg, ModelApprovalChoice as kh, RunSummaryValidation as ki, LoadedPluginRecord as kl, InferSchemaOutput as km, relativeArtifactPath as kn, defaultExtensionScanPaths as ko, CommandAgentResult as kp, tailTruncate as kr, GithubClient as ks, resolveLegacyPersistDir as kt, isValidExtensionConfigValue as ku, EnvironmentSettingsWrite as kv, DecisionStartHookContext as kw, ProviderDecisionRequest as kx, credKeyOf as ky, createTracingHooks as l, baseten as lC, SessionRun as lD, hydrateReadStateFromSession as lE, mergeArtifact as lO, assistantMessage as lS, PromptDocumentPart as lT, SessionEventStatusStyle as l_, anchorPreviewFor as la, ApiKeyCredential as lb, ExtensionArtifactRendererEntry as lc, withIsolatedSpawnTool as ld, listSkillCandidates as lf, spaceModelDefault as lg, PLAN_AGENT as lh, OpenAIChatMessage as li, ExtensionSessionBadge as ll, PlanPayload as lm, createEvalRunReporter as ln, ExtensionInstallCandidate as lo, InlineAutocompleteContext as lp, EvalMetric as lr, GITHUB_ISSUE_PROVIDER_ID as ls, McpStaticClient as lt, ExtensionConfigActionStatus as lu, chainPositionOf as lv, DecisionAnswer as lw, SkillActivationStateOptions as lx, readSessionEnvironment as ly, catalogChangeNotes as m, cacheWriteTtlMultiplier as mC, deleteExtensionSessionState as mD, StagedToolState as mE, openAICompatPromptMessage as mS, RepeatGuardConfig as mT, parseSessionEventXml as m_, GenerateStructuredDataOptions as ma, ProviderCredential as mb, ExtensionBadgeColor as mc, matchModelEntries as md, getDefaultScanPaths as mf, PALETTE_RECENTS_MAX as mg, compositionFits as mh, formattedHeadlessTurnEventToJsonl as mi, ExtensionStorageScope as ml, QuestionChoice as mm, fileContentQuality as mn, ExtensionInstallResult as mo, InlineGhost as mp, MetricSpecMap as mr, githubIssueView as ms, saveMcpClientSecret as mt, ExtensionConfigItem as mu, pickChainPrimary as mv, DecisionEndHookContext as mw, CacheDimensionName as mx, AuthMethod as my, basicTools as n, resolveVertexAuth as nC, setModelCatalog as nD, ToolDescriptions as nE, ARTIFACTS_PER_SESSION_CAP as nO, OAITool as nS, ModelTarget as nT, resolvePanelLoadContext as n_, buildFullCompactPrompt as na, formatCredits as nb, ArtifactResolveOptions as nc, SpawnTool as nd, SkillInstallCandidate as nf, newSpaceId as ng, BUILD_AGENT as nh, HeadlessErrorInfo as ni, ExtensionReferenceSurface as nl, InteractionOrigin as nm, extensionScaffold as nn, ReferenceResolverOptions as no, SyntaxTokenStyle as np, MetricStats as nr, parseShortstat as ns, LoginMcpServerOptions as nt, ExtensionWorkspacePair as nu, previewLine as nv, MAX_IMAGES_PER_REQUEST as nw, AgentHookMap as nx, EnvironmentVerifyResult as ny, TracingConventions as o, CerebrasParams as oC, SessionData as oD, ReadStateMap as oE, SessionArtifact as oO, TOOL_RESULTS_TAG as oS, ProgressNudgeKind as oT, SESSION_ROLE_KEY as o_, CompactScope as oa, showsAccount as ob, ExtensionArtifactDetection as oc, SubagentOverride as od, SkillInstallResult as of, sessionSpaceFilter as og, DEFAULT_AGENT_ID as oh, HeadlessStatus as oi, ExtensionRunSettledHandler as ol, PRESENT_PLAN_TOOL as om, withZidaneSkillEditSkill as on, referenceProviderWires as oo, ThemeSurfaces as op, buildTrajectory as or, resolveArtifactKind as os, McpCredentialStore as ot, createWorkspaceSurface as ou, buildRunModel as ov, ProviderImages as ow, ActiveSkill as ox, availableEnvironmentActions as oy, announcedDigest as p, anthropic as pC, currentExtensionSession as pD, DEFAULT_MAX_VALUE_BYTES as pE, mapOAIFinishReason as pS, PromptVideoPart as pT, orchestratedBy as p_, truncateHeadForPtlRetry as pa, PreferredCredentialTarget as pb, ExtensionArtifactsSurface as pc, formatModelLine as pd, discoverSkills as pf, PALETTE_LIMITS as pg, compositionByKey as ph, formatHeadlessTurnEvent as pi, ExtensionSource as pl, Question as pm, fileContains as pn, ExtensionInstallProvenance as po, tokenEndingAtCursor as pp, MetricSpec as pr, githubIssueReferenceProvider as ps, mcpOAuthProviderFor as pt, ExtensionConfigEnumItem as pu, modelPickKey as pv, DecisionChoiceQuestion as pw, CacheDimensionDiff as px, workspacePath as py, Counter as q, resolveThinkingBinding as qC, PairingRepair as qD, attachStderrWarnPump as qE, GoogleWireKit as qS, TurnFinishReason as qT, describeSpawnEnd as q_, buildExtensionRegistry as qa, ContextExtensionRow as qb, ExtensionPaletteWhen as qc, validateResourcePathReal as qd, StorageDirs as qf, PanelLoadScope as qg, SpaceIcon as qh, CompactPromptTooLongError as qi, ExtensionArtifactScope as ql, fanoutSink as qm, EvalRunSummaryCase as qn, ExtensionBusChannel as qo, InteractionsProvider as qp, grep as qr, GithubPullState as qs, ExtensionEditMarker as qt, mergeBadgeMenu as qu, EnvironmentExecutionInput as qv, DedupHasher as qw, SchemaSanitizeResult as qx, effectiveContextWindow as qy, GEN_AI_ATTRIBUTES as r, toGooglePiMessages as rC, CreateSessionOptions as rD, ToolMap as rE, ARTIFACT_KINDS as rO, OpenAICompatAuthHeader as rS, ModelTargetSpec as rT, ORCHESTRATED_BY_KEY as r_, buildTailCompactPrompt as ra, formatUsagePercent as rb, EMPTY_EXTENSION_REGISTRY as rc, SpawnToolOptions as rd, SkillInstallError as rf, normalizeSpaces as rg, BUILD_CODEMODE_AGENT as rh, HeadlessEvent as ri, ExtensionReferenceView as rl, InteractionRequest as rm, readSkillEditMarker as rn, compileReferencePattern as ro, Theme as rp, Trajectory as rr, pullRequestKind as rs, LoginMcpServerResult as rt, ExtensionWorkspaceSurface as ru, shortId as rv, ProviderImageAvailability as rw, AgentHooks as rx, LOCAL_ENVIRONMENT as ry, TracingHookSet as s, cerebras as sC, SessionHistory as sD, getReadState as sE, SessionArtifactInput as sO, applyOAICacheBreakpoints as sS, ProgressNudgeMessage as sT, SessionEvent as s_, CompactionSlice as sa, updatedLabel as sb, ExtensionArtifactKindRegistration as sc, SubagentRegistry as sd, SkillInstallSpec as sf, spaceIdForNewSession as sg, DEFAULT_BUDGET_EXCLUDE_TOOLS as sh, HeadlessUsage as si, ExtensionRunTransform as sl, PendingInteractionEntry as sm, EvalTestRunner as sn, referenceProviders as so, resolveChipColor as sp, formatTrajectoryLine as sr, sessionBadges as ss, McpOAuthProvider as st, ExtensionConfigActionItem as su, chainAccountConflict as sv, AgentDecide as sw, DeactivationReason as sx, createEnvironmentRegistry as sy, _default as t, resolveGoogleModel as tC, getModelCatalog as tD, ToolDescriptionTarget as tE, ARTIFACTS_METADATA_KEY as tO, OAIMessage as tS, McpToolSchema as tT, panelShowsIn as t_, buildFromCompactPrompt as ta, formatBalance as tb, createArtifactDetectHook as tc, SpawnTaskOutcome as td, SkillCandidateDetail as tf, newSessionModel as tg, AgentRegistry as th, FormattedHeadlessTurnEvent as ti, ExtensionReferenceProvider as tl, HOST_INTERACTION_ID_PREFIX as tm, extensionDirForCwd as tn, ReferenceResolver as to, SyntaxStyles as tp, EvalWorkspaceSnapshot as tr, fileKind as ts, createMetricsHooks as tt, ExtensionWorkspaceOps as tu, formatTaskSummary as tv, ImageModelInfo as tw, AgentHookHandlers as tx, EnvironmentTeardownResult as ty, FROZEN_PROMPT_SECTION_KINDS as u, planBasetenReasoning as uC, SessionRunAgent as uD, hydrateReadStateFromSessionAsync as uE, normalizeArtifactInput as uO, buildAssistantContent as uS, PromptImagePart as uT, SessionEventTone as u_, sliceForCompaction as ua, CredentialsFile as ub, ExtensionArtifactRendererRegistration as uc, isSpawnTool as ud, parseSkillInstallSpec as uf, spaceOfSwitchItem as ug, ProfileSwitchNoteContext as uh, ProviderTranscriptFormat as ui, ExtensionSessionBadgeCardRow as ul, PlanRequest as um, registerEvalTests as un, ExtensionInstallError as uo, InlineAutocompleteProvider as up, EvalMetricError as ur, GITHUB_PULL_COLORS as us, clearMcpSignIn as ut, ExtensionConfigBooleanItem as uu, chainsEqual as uv, DecisionAnswerFor as uw, createSkillActivationState as ux, resolveExecution as uy, systemSnapshotTurn as v, buildAnthropicClientOptions as vC, resumeChainRunIds as vD, ToolStateView as vE, userMessage as vS, RetryConfig as vT, sessionEventLabel as v_, normalizeShellCommand as va, credentialsPath as vb, ExtensionBusEmitOptions as vc, ManifestValidation as vd, parseSkillFile as vf, PaletteGroup as vg, resolveAgentId as vh, transcriptToOpenAIMessages as vi, ExtensionToolRenderProps as vl, QuestionType as vm, statusCompleted as vn, InstalledExtensionTargetOptions as vo, CompletionItem as vp, emitEfficiencyMetrics as vr, githubRateLimitText as vs, OAuthCallbackResult as vt, ExtensionConfigScope as vu, rememberableChain as vv, DecisionInputKind as vw, CacheSystemSection as vx, detectAuth as vy, SqliteSessionStoreOptions as w, AnthropicBedrockConfig as wC, FileMapAdapter as wD, SkillDiagnostic as wE, openai as wS, SessionTurn as wT, RUN_RECEIPT_GLYPH as w_, definePreset as wa, readProviderCredentials as wb, ExtensionContextTransform as wc, AgentPluginsVersion as wd, skillCandidatesFromPaths as wf, RankedPaletteItem as wg, EditOutcome as wh, RunSummaryCollector as wi, ExtensionToolResultTransform as wl, isInteractionTool as wm, LlmJudgeOptions as wn, removeInstalledExtension as wo, findActiveTrigger as wp, WAIT_TASK_TIMED_OUT_PREFIX as wr, pullMeta as ws, SessionArtifactDirMigration as wt, WireExtensionConfigItem as wu, EnvironmentDescriptor as wv, DecisionRefusalAnswer as ww, HistoryRepair as wx, ProviderFactoryOptions as wy, flattenTurns as x, resolveAnthropicBetas as xC, RemoteStoreOptions as xD, stagedToolState as xE, OpenAIParams as xS, SessionEndStatus as xT, sideSessionParent as x_, _default$1 as xa, readCredentials as xb, ExtensionCapability as xc, PLUGIN_MANIFEST_FILE as xd, SKILL_CANDIDATE_MAX_DEPTH as xf, PaletteItemKind as xg, ApprovalMode as xh, RunSummaryBlock as xi, ExtensionToolRendererRegistration as xl, buildResumedToolResultsTurn as xm, buildRegisteredEvals as xn, listExtensionCandidates as xo, CompletionSubmitContext as xp, HeadlessOptions as xr, parseGithubRefKey as xs, PERSISTENCE_PREVIEW_BYTES as xt, ExtensionConfigValue as xu, sanitizeModelChain as xv, DecisionPredicateQuestion as xw, hashMessages as xx, ModelInfo as xy, ModelUsage as y, credentialIdentity as yC, setExtensionSessionState as yD, createToolStateController as yE, OpenAICompatStreamError as yS, RunHookMap as yT, sessionEventMeta as y_, stableStringify as ya, ensureCredentialIds as yb, ExtensionBusMessage as yc, parsePluginManifest as yd, buildCatalog as yf, PaletteHost as yg, sessionComposition as yh, transcriptToProviderMessages as yi, ExtensionToolRenderer as yl, SelectQuestion as ym, formatEvalCaseSummary as yn, fetchExtensionSource as yo, CompletionProvider as yp, finalizeEvalMetrics as yr, githubRefKey as ys, startOAuthCallback as yt, ExtensionConfigStringItem as yu, reorderKeyed as yv, DecisionOutcome as yw, diffCacheDimensions as yx, BUILTIN_PROVIDERS as yy, MutationValidationFailure as z, readOAuthCredentials as zC, sanitizeHistoryForProvider as zD, normalizeMcpServers as zE, GoogleParams as zS, ToolResultContent as zT, hasRunReceipt as z_, AgentCompactResult as za, buildContextSegments as zb, ExtensionModal as zc, SkillTokenWeights as zd, githubPreviewImageUrl as zf, PanelCustomItem as zg, StreamEvent as zh, selectFilesFromSession as zi, ExtensionHudStatus as zl, Logger as zm, EvalCaseOptions as zn, createExtensionPromptBridge as zo, CommandStep as zp, shell as zr, githubTokenFingerprint as zs, collectNewlyStaleReadPaths as zt, BadgeTargetKind as zu, EnvironmentActionResult as zv, ChildRunStats as zw, TurnResult as zx, openaiDescriptor as zy };
+//# sourceMappingURL=index-4mDRyTGJ.d.ts.map