zidane 5.14.4 → 6.0.0

package/dist/index-BtzE3Uaq.d.ts

@@ -1,2738 +0,0 @@
-import { Ar as TurnUsage, Fn as AgentStats, I as ShellInterpolationApproval, K as SessionStore, Kn as McpServerConfig, L as SkillConfig, Mn as AgentBehavior, Nn as AgentClock, Rn as ChildRunStats, Sr as ToolResultContent, St as Provider, T as ToolDef, U as Session, _r as ThinkingLevel, br as ToolOutcome, f as SkillActivationState, i as AgentOptions, kr as TurnFinishReason, mr as SessionTurn, n as AgentHookMap, r as AgentHooks, tr as PromptPart, u as ActiveSkill, w as ToolContext } from "./agent-EFWt6uQ_.js";
-import { c as ExecutionContext, l as ExecutionHandle } from "./types-BqdTeBaC.js";
-import { t as RunSummary } from "./run-summary-DkN8KsHM.js";
-import { Hookable } from "hookable";
-import { OAuthClientProvider, OAuthDiscoveryState } from "@modelcontextprotocol/sdk/client/auth.js";
-import { OAuthClientInformationMixed, OAuthClientMetadata, OAuthTokens } from "@modelcontextprotocol/sdk/shared/auth.js";
-
-//#region src/behaviors/local-reliability.d.ts
-/**
- * Opt-in behavior overlay for brittle/local OpenAI-compatible endpoints.
- * Returns plain `AgentBehavior` so hosts can spread it before or after their
- * own overrides; no built-in profile uses this helper by default.
- */
-declare function localReliabilityBehavior(overrides?: AgentBehavior): AgentBehavior;
-//#endregion
-//#region src/behaviors/repeat-guard.d.ts
-/**
- * Default tracked-tool predicate: the built-in `shell` and `read_file` tools.
- * `shell` is an auto-approved, side-effect-light retry magnet; `read_file` is
- * the re-read loop magnet. Both are the loop shapes the abort escalation exists
- * for. Consumers that want to track additional tools (e.g. an MCP query runner)
- * pass them via
- * {@link RepeatGuardConfig.tools}.
- */
-declare function defaultRepeatGuardTracked(name: string): boolean;
-/**
- * Canonicalize a shell command so semantically-identical invocations collapse
- * to one streak key:
- *
- * - strip a leading `cd <path> &&` (or `cd <path>;`) prefix — the model often
- *   re-prefixes the same command with a `cd` into the project root.
- * - strip a trailing verify-tail of the shape `& sleep N ; <anything>` or
- *   `; sleep N && <anything>` that the model appends to poll a just-started
- *   process (`… & sleep 2 ; curl localhost`).
- * - collapse runs of whitespace to single spaces and trim.
- *
- * Conservative on purpose: it does NOT reorder flags or parse the command —
- * it only removes the two wrappers we actually saw inflate distinct-looking
- * retries of the same core command, plus whitespace noise.
- */
-declare function normalizeShellCommand(command: string): string;
-/**
- * Built-in normalizer used when the consumer doesn't supply one. Shell-shaped
- * tools get {@link normalizeShellCommand}; everything else falls back to a
- * stable JSON encoding. Returns `undefined` when there's no meaningful payload
- * to key on (so the call is excluded from streak tracking rather than keyed on
- * `'{}'`). Consumers needing semantic keying for their own tools (e.g.
- * collapsing a query's whitespace) supply a normalizer via
- * {@link RepeatGuardConfig.normalize}.
- */
-declare function defaultRepeatGuardNormalize(name: string, input: Record<string, unknown>): string | undefined;
-/** Deterministic JSON with sorted keys so key order doesn't split a streak. */
-declare function stableStringify(value: unknown): string;
-//#endregion
-//#region src/compact/messages.d.ts
-/**
- * What to summarize and what to preserve verbatim.
- *
- * - `'full'`         — summarize everything, no preserved tail.
- * - `'tail'`         — summarize everything before the last `keepTurns` turns.
- * - `{ kind: 'from',  turnId }` — summarize from the anchor turn onward.
- * - `{ kind: 'up_to', turnId }` — summarize up to (and including) the anchor.
- */
-type CompactScope = 'full' | 'tail' | {
-  kind: 'from';
-  turnId: string;
-} | {
-  kind: 'up_to';
-  turnId: string;
-};
-interface CompactionSlice {
-  /** The portion of the conversation that will be summarized. */
-  toSummarize: readonly SessionTurn[];
-  /** The portion that stays verbatim in the post-compact history. */
-  preserved: readonly SessionTurn[];
-}
-/**
- * Partition `turns` into `(toSummarize, preserved)` according to `scope`.
- *
- * Throws {@link CompactInvalidInputError} on degenerate inputs so the
- * caller doesn't pay for a doomed provider call:
- *   - empty `turns`
- *   - `scope: 'tail'` with `keepTurns >= turns.length` (nothing to summarize)
- *   - `scope: { from | up_to }` with an anchor id that isn't in `turns`
- *   - the resulting `toSummarize` slice contains no text-bearing content
- *     (only system turns or empty content)
- *
- * Pure. Returns references to the original `SessionTurn` objects — the
- * caller can compare by identity (=== Object.is) to confirm.
- */
-declare function sliceForCompaction(turns: readonly SessionTurn[], scope: CompactScope, keepTurns: number): CompactionSlice;
-/**
- * Replace every attachment block in `turns` with a short text marker.
- *
- * Covers two shapes:
- *   - Top-level `{ type: 'image', ... }` content blocks on user turns.
- *   - Image entries inside `tool_result.output` array form (multimodal
- *     tool results — e.g. an MCP browser screenshot).
- *
- * Unconditional by design: even on vision-capable models, the summary
- * call doesn't benefit from raw image bytes (the model can't refer to
- * them after the summary lands), and stripping uniformly avoids
- * `prompt_too_long` on image-heavy sessions.
- *
- * Returns a fresh array; input turns / blocks are never mutated.
- */
-declare function stripImagesFromTurns(turns: readonly SessionTurn[]): SessionTurn[];
-/**
- * Drop the oldest "round" from `turns` and return a fresh array. Used by
- * the PTL retry path to shrink the prompt one round at a time.
- *
- * A round is a contiguous `[user, assistant?, tool_results?]` group. The
- * function walks forward from index 0, advances through the user turn
- * and any trailing assistant + tool-result turns belonging to the same
- * exchange, and returns the remainder.
- *
- * Adjacency-safe: when the oldest user turn carries `tool_result` blocks
- * answering an assistant turn ahead of it (rare — happens during
- * resume), the function keeps walking until the next clean boundary so
- * the resulting array still respects every provider's `tool_use ↔
- * tool_result` adjacency rule.
- *
- * Returns `turns` unchanged when only one round (or less) remains — the
- * caller is expected to interpret that as "cannot shrink further" and
- * give up the retry loop.
- */
-declare function truncateHeadForPtlRetry(turns: readonly SessionTurn[]): SessionTurn[];
-/**
- * Maximum length of an anchor turn's textual preview, in characters. Long
- * enough to give the model recognizable context (the first paragraph of
- * a typical user message), short enough that it doesn't blow the
- * cache-stability invariant for the prompt prefix.
- */
-declare const ANCHOR_PREVIEW_MAX_CHARS = 200;
-/**
- * Extract the first ~200 chars of text-bearing content from a turn — the
- * preview surfaced in `from` / `up_to` direction prompts so the model
- * knows where the slice begins.
- */
-declare function anchorPreviewFor(turn: SessionTurn): string;
-/**
- * Input shape for {@link summaryToTurn}. Designed to align with the
- * fields of `CompactResult` so a caller can spread the runner's output
- * with a single `replacesTurnIds` rename — no field-by-field unpacking
- * required.
- *
- * Primitive shape (no `CompactResult` import) keeps this module free of
- * dependencies on the runner — `compact.ts` imports from here, not the
- * other way around.
- */
-interface SummaryToTurnInput {
-  /** Summary text — typically `CompactResult.summary`. */
-  summary: string;
-  /** Turn ids being replaced — typically `CompactResult.summarizedTurnIds`. */
-  replacesTurnIds: readonly string[];
-  /** Model id that produced the summary. */
-  model: string;
-  /** Token usage from the summary call. */
-  usage: TurnUsage;
-  /** Defaults to `Date.now()` when omitted. */
-  compactedAt?: number;
-  /**
-   * Turn id. Defaults to `crypto.randomUUID()`. Durable-execution callers
-   * (Restate) pass a journaled id (`clock.randomUUID()`) so the marker turn
-   * is byte-identical on replay; pair it with a journaled {@link compactedAt}.
-   */
-  id?: string;
-}
-/**
- * Build a synthetic `SessionTurn` carrying a single `compact-summary`
- * block, ready to append to a session.
- *
- * The turn's role is `'user'` so it sits at a conversational boundary
- * the way the model expects. The caller is responsible for
- * `session.appendTurns([turn])`. The id defaults to `crypto.randomUUID()`
- * (override via `input.id` for durable-execution replay stability).
- *
- * Typical use after running `compactConversation`:
- *
- * ```ts
- * const result = await compactConversation({ provider, turns })
- * const turn = summaryToTurn({
- *   summary: result.summary,
- *   replacesTurnIds: result.summarizedTurnIds,
- *   model: result.model,
- *   usage: result.usage,
- * })
- * await session.appendTurns([turn])
- * ```
- */
-declare function summaryToTurn(input: SummaryToTurnInput): SessionTurn;
-//#endregion
-//#region src/compact/prompt.d.ts
-/**
- * Pure prompt builders for conversation compaction.
- *
- * The builders produce the **system prompt** for a no-tools summary call.
- * They are total functions of `(direction, anchorPreview?)` and produce
- * byte-stable output for the same inputs — that's load-bearing for the
- * provider's prompt cache: repeated compactions in the same host process
- * share the same prefix and read cache instead of writing it.
- *
- * Inspired by Claude Code's `services/compact/prompt.ts` — same 9-section
- * scaffold, same `<analysis> + <summary>` envelope, same no-tools
- * preamble. Adapted to zidane-specific wording (no "Claude" references)
- * and trimmed of the bits that don't apply (no `marble_origami`-style
- * query sources, no compaction-fingerprint header).
- */
-/** Identifier for the section of the conversation being summarized. */
-type CompactDirection = 'full' | 'tail' | 'from' | 'up_to';
-interface CompactPromptOptions {
-  direction: CompactDirection;
-  /**
-   * Short preview of the anchor turn's text — only used by `'from'` and
-   * `'up_to'`. Pass the last ~200 chars of the anchor turn so the model
-   * has a recognizable handle on where the slice begins / ends. Empty /
-   * undefined for `'full'` and `'tail'`.
-   */
-  anchorPreview?: string;
-}
-/**
- * Function shape for callers that want to swap in a domain-specific
- * summary prompt (security review handoff, support-ticket continuation,
- * etc.) without touching the runner. Default: {@link buildCompactPrompt}.
- */
-type CompactPromptBuilder = (opts: CompactPromptOptions) => string;
-/**
- * No-tools guard. The runner sends `tools: []` to the provider already,
- * but some models still hallucinate tool-call intent on a long
- * conversation. The prose guard is cheap insurance.
- */
-declare const NO_TOOLS_PREAMBLE = "CRITICAL: Respond with TEXT ONLY. Do NOT call any tools.\n\n- Do NOT use Read, Bash, Grep, Glob, Edit, Write, or ANY other tool.\n- You already have all the context you need in the conversation above.\n- Tool calls will be REJECTED and will waste your only turn \u2014 you will fail the task.\n- Your entire response must be plain text: an <analysis> block followed by a <summary> block.";
-/**
- * Body shared by every direction. Lays out the 9-section scaffold,
- * mirrors Claude Code's `BASE_COMPACT_PROMPT` so a model already trained
- * on the layout produces the same shape.
- */
-declare const BASE_INSTRUCTIONS = "Your task is to create a detailed summary of the conversation so far, paying close attention to the user's explicit requests and your previous actions.\n\nThis summary should be thorough in capturing technical details, code patterns, and architectural decisions that would be essential for continuing development work without losing context.\n\nBefore providing your final summary, wrap your analysis in <analysis> tags to organize your thoughts and ensure you've covered all necessary points. In your analysis process:\n\n1. Chronologically analyze each message and section of the conversation. For each section thoroughly identify:\n   - The user's explicit requests and intents\n   - Your approach to addressing the user's requests\n   - Key decisions, technical concepts and code patterns\n   - Specific details like file names, full code snippets, function signatures, file edits\n   - Errors that you ran into and how you fixed them\n   - Pay special attention to specific user feedback that you received, especially if the user told you to do something differently.\n2. Double-check for technical accuracy and completeness.\n\nYour summary, wrapped in <summary> tags, must include the following sections:\n\n1. Primary Request and Intent\n2. Key Technical Concepts\n3. Files and Code Sections (with paths; include code snippets only when load-bearing)\n4. Errors and fixes\n5. Problem Solving\n6. All user messages (list ALL non-tool user messages, verbatim)\n7. Pending Tasks\n8. Current Work\n9. Optional Next Step (include direct quotes from the most recent conversation when relevant)";
-/** Trailer prompting the model to begin. Same on every direction. */
-declare const TRAILER = "Provide your <analysis> and <summary> now.";
-declare function buildFullCompactPrompt(): string;
-declare function buildTailCompactPrompt(): string;
-declare function buildFromCompactPrompt(anchorPreview: string): string;
-declare function buildUpToCompactPrompt(anchorPreview: string): string;
-/**
- * Default public builder. Dispatches by direction to the four named
- * builders. Throws when `from` / `up_to` are passed without an
- * `anchorPreview` — those scopes only make sense with an anchor and a
- * silent fallback would produce a prompt that doesn't tell the model
- * where the slice begins.
- */
-declare const buildCompactPrompt: CompactPromptBuilder;
-//#endregion
-//#region src/compact/errors.d.ts
-/**
- * Typed errors thrown by the compaction helper.
- *
- * Lives in its own file so both the runner and the pure messages module
- * can import without circular dependencies.
- */
-/**
- * Raised when the caller's inputs make compaction meaningless before any
- * API call is attempted. Common cases:
- *   - empty `turns`
- *   - `keepTurns >= turns.length` (no older content to summarize)
- *   - `'from'` / `'up_to'` anchor id not found in `turns`
- *   - the resolved `toSummarize` slice has no text-bearing content
- *
- * Synchronous — thrown from `compactConversation()` before the provider
- * call so the caller can recover without a network round-trip.
- */
-declare class CompactInvalidInputError extends Error {
-  constructor(message: string);
-}
-/**
- * Raised when the provider rejects the compaction request with
- * `prompt_too_long` (or an equivalent) and the head-truncation retry
- * budget has been exhausted. Callers can inspect `ptlRetries` to log
- * how far the retry loop got before giving up.
- */
-declare class CompactPromptTooLongError extends Error {
-  readonly ptlRetries: number;
-  constructor(message: string, ptlRetries: number);
-}
-//#endregion
-//#region src/compact/compact.d.ts
-interface CompactOptions {
-  /** Provider used for the summary call. Called with empty tools list. */
-  provider: Provider;
-  /** Conversation to compact, in chronological order. */
-  turns: readonly SessionTurn[];
-  /**
-   * What to summarize. Default: `'tail'` — summarize everything before
-   * the last `keepTurns` turns. See {@link CompactScope}.
-   */
-  scope?: CompactScope;
-  /**
-   * Trailing turns left untouched when `scope: 'tail'`. Default: 4.
-   * Matches `AgentBehavior.compactKeepTurns` so a host that uses both
-   * mechanisms shares one knob.
-   */
-  keepTurns?: number;
-  /** Model id used for the summary call. Default: `provider.meta.defaultModel`. */
-  model?: string;
-  /**
-   * Maximum tokens the summary itself can occupy. Default: 20_000 — the
-   * p99.99 of summary output size in Claude Code's `COMPACT_MAX_OUTPUT`.
-   * Reasonable for any model with a 200k+ window.
-   */
-  maxOutputTokens?: number;
-  /** Optional reasoning level. Default: `'off'` — summarization rarely benefits from thinking. */
-  thinking?: ThinkingLevel;
-  /** Optional cancellation signal forwarded to `provider.stream()`. */
-  signal?: AbortSignal;
-  /**
-   * Watchdog for the provider summary call in milliseconds. If the provider
-   * stream never settles, compaction aborts its request signal and fails
-   * instead of leaving callers queued forever. Set `0` to disable.
-   * Default: 120000 (2 minutes).
-   */
-  providerStreamTimeoutMs?: number;
-  /**
-   * Retries with head-truncation when the provider reports
-   * `prompt_too_long`. Each retry drops the oldest conversational round
-   * before re-issuing the call. Default: 3. Set 0 to fail-fast.
-   */
-  maxPtlRetries?: number;
-  /**
-   * Optional builder override. The default builder dispatches by
-   * direction to the named builders in `./prompt.ts`; pass a custom
-   * function to swap in a domain-specific summary prompt.
-   */
-  prompt?: CompactPromptBuilder;
-  /**
-   * Lifecycle hook for observability. Fires once per provider call,
-   * including retries. The `kind` field tells you whether the call is
-   * the initial attempt, a head-truncated retry, or a transient-error
-   * retry — useful for surfacing progress in a UI spinner.
-   */
-  onAttempt?: (event: {
-    attempt: number;
-    kind: 'initial' | 'ptl-retry' | 'transient-retry';
-  }) => void;
-  /**
-   * Lifecycle hook fired after preflight succeeds and before the first
-   * provider call starts. Useful for UI state ("Compacting...") and telemetry.
-   * Synchronous by design so observability cannot hang compaction.
-   */
-  onStart?: (event: CompactStartEvent) => void;
-  /**
-   * Lifecycle hook fired exactly once after {@link onStart}, on both success
-   * and failure. Synchronous by design so observability cannot hang compaction.
-   */
-  onEnd?: (event: CompactEndEvent) => void;
-}
-interface CompactStartEvent {
-  model: string;
-  scope: CompactScope;
-  summarizedTurnIds: readonly string[];
-  preservedTurnIds: readonly string[];
-}
-type CompactEndEvent = {
-  status: 'success';
-  durationMs: number;
-  result: CompactResult;
-} | {
-  status: 'error';
-  durationMs: number;
-  error: unknown;
-};
-interface CompactResult {
-  /** The summary text, with any `<analysis>` block stripped. */
-  summary: string;
-  /** Token usage from the (last successful) summary call. */
-  usage: TurnUsage;
-  /** Model id used to produce the summary. */
-  model: string;
-  /** Number of `prompt_too_long` retries that fired before success. 0 on first-try success. */
-  ptlRetries: number;
-  /**
-   * Turn ids actually covered by the summary — i.e., the ids of turns
-   * that made it to the provider. **PTL-retry safe**: when head-truncation
-   * shrank the scope, only the surviving (post-truncation) turn ids
-   * appear here. Drives `summaryToTurn`'s `replacesTurnIds`; the wire-
-   * level cutoff in `applyCompactSummaryCutoff` reads the same field
-   * from the persisted marker.
-   */
-  summarizedTurnIds: readonly string[];
-  /**
-   * Turn ids dropped by PTL head-truncation before reaching the
-   * provider. **Empty on first-try success.** These turns are NOT
-   * covered by the summary — callers should either leave them in the
-   * conversation history (they stay visible to the model verbatim,
-   * since the id-based cutoff only elides ids the marker explicitly
-   * claims) or surface a "compaction lost N turns of context" warning.
-   *
-   * The harness keeps these in the wire-level conversation by default;
-   * the safety contract is "the summary describes exactly what's in
-   * `summarizedTurnIds` — nothing more, nothing less".
-   */
-  droppedDueToPtl: readonly string[];
-  /** Turns left untouched (the preserved tail / verbatim slice). */
-  preservedTurns: readonly SessionTurn[];
-  /** Byte length of turns actually summarized (post-PTL-truncation). */
-  beforeBytes: number;
-  /** UTF-8 byte length of the summary text (rough "after" measure). */
-  afterBytes: number;
-}
-declare function compactConversation(opts: CompactOptions): Promise<CompactResult>;
-//#endregion
-//#region src/compact/restore.d.ts
-/** One file selected for restoration, with its last-read timestamp for ranking. */
-interface RecentFile {
-  /** Path relative to the execution context's `handle.cwd`. */
-  path: string;
-  /** Wall-clock when the file was last read, in ms. Drives recency ranking. */
-  mtimeMs: number;
-}
-interface PostCompactRestoreOptions {
-  /**
-   * Files to consider for restoration, ranked by recency. Typically derived
-   * via {@link selectFilesFromReadState} from `getReadState(session)`.
-   * The helper takes the top {@link PostCompactRestoreOptions.maxFilesToRestore}
-   * by `mtimeMs` descending, fetches their current content, and synthesizes
-   * `read_file` tool_call/tool_result pairs.
-   */
-  recentFiles?: readonly RecentFile[];
-  /**
-   * Active skills to re-inject. Typically `agent.activeSkills`. Each entry
-   * yields a synthetic `skills_use` tool_call/tool_result pair carrying the
-   * skill's instructions (possibly truncated to the per-skill budget).
-   */
-  activeSkills?: readonly ActiveSkill[];
-  /**
-   * Execution context used to fetch file content. **Required for file
-   * restoration.** Skills come pre-loaded (instructions live on the
-   * `SkillConfig`), so they don't need the context.
-   */
-  execution?: ExecutionContext;
-  handle?: ExecutionHandle;
-  /**
-   * Optional abort signal. Checked before each file read so a caller that
-   * bounds restoration (e.g. a host capping its compaction barrier) can stop
-   * the FS round-trips promptly instead of reading every candidate. File
-   * restoration already isolates per-file failures, so an abort mid-loop just
-   * returns whatever was gathered so far.
-   */
-  signal?: AbortSignal;
-  /**
-   * Canonical name of the file-read tool. Defaults to `read_file`. Aliases
-   * (e.g. `Read`) are NOT specified here — the agent loop's
-   * `rewriteMessagesToWire` handles wire conversion automatically.
-   *
-   * Override only when a host registered file-read under a different
-   * canonical name (not just an alias).
-   */
-  readFileToolName?: string;
-  /**
-   * Canonical name of the skill-activation tool. Defaults to `skills_use`.
-   * Same aliasing semantics as `readFileToolName`.
-   */
-  skillsUseToolName?: string;
-  /** Total token budget for file restoration. Default: 50_000. */
-  fileTokenBudget?: number;
-  /** Per-file token cap. Default: 5_000. */
-  fileTokenPerFileCap?: number;
-  /** Maximum file count. Default: 5. */
-  maxFilesToRestore?: number;
-  /** Total token budget for skill restoration. Default: 25_000. */
-  skillTokenBudget?: number;
-  /** Per-skill token cap. Default: 5_000. */
-  skillTokenPerSkillCap?: number;
-  /**
-   * Paths to skip — typically the file paths already covered by the
-   * compaction result's `preservedTurns`. Avoids double-injection when the
-   * recent reads sit in the preserved tail.
-   */
-  excludePaths?: readonly string[];
-  /**
-   * Optional `runId` to tag the synthetic turns with — useful for hosts
-   * that want the restoration turns to roll up under the same run as the
-   * compaction marker. Defaults to undefined (orphan turns).
-   */
-  runId?: string;
-  /**
-   * Time + UUID source for the synthesized turns' `id` / `createdAt`.
-   * Defaults to {@link DEFAULT_AGENT_CLOCK} (`Date.now()` /
-   * `crypto.randomUUID()`). Durable-execution callers (Restate) pass the
-   * loop's journaled clock so the restoration turns are byte-identical on
-   * replay. The synthetic `tool_call`/`tool_result` `callId`s are already
-   * deterministic (`compact-restore-file-${i}`), so only the turn envelope
-   * needs the clock.
-   */
-  clock?: AgentClock;
-}
-/**
- * Envelope returned by {@link buildPostCompactAttachments}. The caller
- * spreads `turns` into `session.appendTurns([summaryTurn, ...turns])`.
- * Count fields drive UI banners ("restored 5 files + 2 skills").
- */
-interface PostCompactAttachments {
-  /**
-   * Two synthetic turns when at least one item was restored, otherwise
-   * an empty array. The pair is `[assistant_with_tool_calls,
-   * user_with_tool_results]` — adjacent and well-formed for every
-   * provider's `tool_use ↔ tool_result` invariant.
-   */
-  turns: readonly SessionTurn[];
-  /** Count of files actually restored (post-budget). */
-  restoredFiles: number;
-  /** Count of skills actually restored (post-budget). */
-  restoredSkills: number;
-  /** Rough total token cost of the restoration payload (sum of all content). */
-  estimatedTokens: number;
-}
-/**
- * Convert a raw read-state map into a deduped, path-ranked list ready for
- * restoration. Multiple entries for the same path (different
- * `(offset, limit, maxBytes)` slices) collapse to one — keeping the most
- * recent `mtimeMs`.
- *
- * Filters out entries whose key doesn't share the given `cwd` prefix:
- * those came from a different execution context and can't be read back
- * through this agent's handle.
- *
- * Pure. Most callers want {@link selectFilesFromSession}, which wraps
- * `getReadState(session)` + this function in one call so the host
- * doesn't have to reach into the tools layer.
- */
-declare function selectFilesFromReadState(readState: ReadonlyMap<string, {
-  mtimeMs: number;
-}>, cwd: string): RecentFile[];
-/**
- * Session-aware convenience: extract recently-read files directly from
- * a {@link Session} via its per-session read-state map.
- *
- * Hosts (TUI / SDK consumers) typically have a `Session` and a `cwd`
- * (the active agent's `handle.cwd`) on hand — this wrapper saves them
- * from reaching into `src/tools/read-state.ts` directly. Returns an
- * empty list when no read state has been recorded yet (fresh session,
- * or `behavior.dedupReads === false`).
- *
- * Equivalent to:
- *
- * ```ts
- * const state = getReadState(session)
- * return state ? selectFilesFromReadState(state, cwd) : []
- * ```
- */
-declare function selectFilesFromSession(session: Session, cwd: string): RecentFile[];
-/**
- * Pick the top `maxFiles` from `files` (descending by `mtimeMs`),
- * dropping any whose path appears in `excludePaths`.
- *
- * Stable for equal mtimes — files with the same timestamp retain their
- * input order. Pure.
- */
-declare function selectRecentFiles(files: readonly RecentFile[], opts: {
-  maxFiles: number;
-  excludePaths?: readonly string[];
-}): RecentFile[];
-/**
- * Build the synthetic turns to append after a `compact-summary` marker.
- *
- * Returns a `PostCompactAttachments` envelope; the caller is responsible
- * for `session.appendTurns([summaryTurn, ...result.turns])`. The two
- * synthetic turns are always emitted together (or both omitted when
- * nothing was restored) so the `tool_use ↔ tool_result` adjacency
- * invariant holds regardless of caller code path.
- *
- * Failure isolation: a single file's read failure never blocks the rest
- * of restoration — that file is skipped silently and processing
- * continues. The returned `restoredFiles` count reflects what actually
- * landed in the synthesized turns.
- */
-declare function buildPostCompactAttachments(opts: PostCompactRestoreOptions): Promise<PostCompactAttachments>;
-//#endregion
-//#region src/compact/utils.d.ts
-/**
- * Shared utilities for the compact module — extracted so the runner
- * (`compact.ts`) and the restoration helper (`restore.ts`) don't carry
- * redundant copies of the same low-level math.
- *
- * Kept zero-dependency by design: no Node/Bun imports, no zidane types
- * either. Both `utf8ByteLength` and `estimateTokens` are total
- * functions of a single `string` argument, so they're trivially
- * portable to a worker/browser context if the compact module ever
- * needs to render outside Node.
- */
-/**
- * UTF-8 byte length, matching `Buffer.byteLength(text, 'utf-8')` but
- * without pulling `node:buffer` for a one-liner. Stable for surrogate
- * pairs — a high+low surrogate pair counts as a single 4-byte sequence
- * (not 2 × 3-byte). Cheap to call in hot loops.
- *
- * Pure. Identical bytes for identical input across every JS runtime.
- */
-declare function utf8ByteLength(text: string): number;
-/** Same constant Claude Code's `CONTEXT_MANAGEMENT.md` documents. */
-declare const BYTES_PER_TOKEN = 4;
-/**
- * Approximate token count for `text`. Mirrors Claude Code's
- * `BYTES_PER_TOKEN = 4` heuristic — acceptable for budget arithmetic
- * (sizing summarization scopes, enforcing per-file caps in restoration).
- *
- * Accurate to ~10% on English + code. Use a real tokenizer when exact
- * counts matter (cost reporting, hard caps); this is for budget gates
- * where being off by 10% is fine.
- *
- * Pure. Exported so callers (TUI, SDK consumers) can do their own
- * pre-budgeting against the same heuristic the harness uses internally.
- */
-declare function estimateTokens(text: string): number;
-//#endregion
-//#region src/tools/edit.d.ts
-/**
- * Surgical edit — replace `old_string` with `new_string` in a single file.
- *
- * Mirrors Claude Code's `Edit` semantics so models post-trained on Anthropic's
- * tool surface need no relearning. Fails clearly when `old_string` isn't unique
- * (unless `replace_all: true`) and when not found, with a nearest-match preview
- * so the model can recover without a separate `read_file` round-trip.
- */
-declare const edit: ToolDef;
-//#endregion
-//#region src/tools/glob.d.ts
-declare const glob: ToolDef;
-//#endregion
-//#region src/tools/grep.d.ts
-declare const grep: ToolDef;
-//#endregion
-//#region src/tools/interaction.d.ts
-interface InteractionToolOptions {
-  /** JSON Schema for the request payload the model sends */
-  schema: Record<string, unknown>;
-  /** Tool name (default: 'interaction') */
-  name?: string;
-  /** Tool description shown to the model */
-  description?: string;
-  /** Called when the model invokes this tool. Receives the validated payload and tool context, returns data for the model. */
-  onRequest: (payload: Record<string, unknown>, ctx: ToolContext) => Promise<Record<string, unknown> | string>;
-}
-/**
- * Create an interaction tool that lets the agent request structured input.
- *
- * The model calls this tool with a payload matching the schema.
- * `onRequest` is called with the payload and should return the response
- * (string or object) that gets sent back to the model as the tool result.
- */
-declare function createInteractionTool(options: InteractionToolOptions): ToolDef;
-//#endregion
-//#region src/tools/list-files.d.ts
-declare const listFiles: ToolDef;
-//#endregion
-//#region src/tools/multi-edit.d.ts
-declare const multiEdit: ToolDef;
-//#endregion
-//#region src/tools/read-file.d.ts
-declare const readFile: ToolDef;
-//#endregion
-//#region src/tools/shell.d.ts
-interface CreateShellToolOptions {
-  /**
-   * Whether to expose the `run_in_background` flag in the input schema +
-   * the background-mode paragraphs in the description. When `false`, the
-   * model never sees the flag and won't try to use it. The execute path
-   * still has a defensive fallback: an explicit `run_in_background: true`
-   * call (e.g. from a hand-crafted message) returns a clean error rather
-   * than silently running foreground.
-   *
-   * Default: `true`.
-   */
-  allowBackground?: boolean;
-  /**
-   * Canonical names of tools registered alongside `shell` on the same
-   * agent. When non-empty, the description gains a "prefer the dedicated
-   * tool" block for each known sibling (`read_file`, `glob`, `grep`,
-   * `list_files`, `edit`, `write_file`) — useful against the
-   * `ls`/`cat`-to-re-verify loop some models fall into when both a
-   * dedicated tool AND `shell` are visible. Unknown / unrecognized names
-   * are ignored.
-   *
-   * Set by `createAgent` per-run from the tool registry; hosts that
-   * construct a `shell` directly can pass it explicitly. Omit to suppress
-   * the block entirely (no nudge for shell-only agents, no nudge for
-   * hosts that prefer to author their own anti-loop prose).
-   */
-  registeredCanonicals?: ReadonlySet<string>;
-  /**
-   * The agent's `toolAliases` map, used to render the wire-level name of
-   * each sibling in the swap block. Without this, the block always prints
-   * canonical names — fine for the default preset, wrong for hosts that
-   * alias-rename (the model would be told to call a name it doesn't see
-   * in the tool spec).
-   */
-  toolAliases?: Record<string, string>;
-}
-/**
- * Factory for the `shell` tool. The default exported `shell` is
- * equivalent to `createShellTool({ allowBackground: true })`. The
- * factory is the entry point hosts use when they want to override the
- * default — e.g. to ship a preset that always disables background mode
- * regardless of `behavior.tasksDir`.
- *
- * Hosts that use the framework's `createAgent` typically don't need to
- * call this directly: when `behavior.tasksDir` is unset or
- * `behavior.disableBackgroundTasks: true` is set, the agent
- * automatically rewrites the registered `shell` (if it's the
- * framework's built-in) using this factory.
- */
-declare function createShellTool(opts?: CreateShellToolOptions): ToolDef;
-/**
- * Default `shell` tool with background mode enabled.
- *
- * Most hosts use this directly via `basicTools`. When the agent's
- * `behavior.tasksDir` is unset OR `behavior.disableBackgroundTasks:
- * true` is set, `createAgent` auto-rewrites this identity to a
- * `createShellTool({ allowBackground: false })` variant so the model
- * never sees a flag it can't use. Hosts who want to bypass that
- * auto-rewrite can register a `createShellTool({ allowBackground })`
- * directly — the rewrite only fires on identity-equal references to
- * this constant.
- */
-declare const shell: ToolDef;
-//#endregion
-//#region src/tools/shell-kill.d.ts
-declare const shellKill: ToolDef;
-//#endregion
-//#region src/tools/skills-read.d.ts
-interface SkillsReadToolOptions {
-  catalog: readonly SkillConfig[];
-  state: SkillActivationState;
-}
-declare function createSkillsReadTool(options: SkillsReadToolOptions): ToolDef;
-//#endregion
-//#region src/tools/skills-run-script.d.ts
-interface SkillsRunScriptToolOptions {
-  catalog: readonly SkillConfig[];
-  state: SkillActivationState;
-  /** Script timeout in milliseconds. Default 60000. */
-  scriptTimeoutMs?: number;
-}
-declare function createSkillsRunScriptTool(options: SkillsRunScriptToolOptions): ToolDef;
-//#endregion
-//#region src/tools/skills-use.d.ts
-interface SkillsUseToolOptions {
-  /** Resolved skills catalog for this run. */
-  catalog: readonly SkillConfig[];
-  /** Per-agent activation state the tool mutates. */
-  state: SkillActivationState;
-  /** Agent hooks — used to fire `skills:activate` on first activation. */
-  hooks: Hookable<AgentHooks>;
-  /**
-   * Execute `!\`cmd\`` shell interpolation on activation. Mirrors
-   * `SkillsConfig.allowShellInterpolation`. Default `true`. Interpolation
-   * runs arbitrary shell from (possibly third-party) skill content, outside
-   * the allowed-tools gate — set `false` for locked-down hosts. When off,
-   * patterns are replaced with a `[shell interpolation disabled]`
-   * placeholder.
-   */
-  allowShellInterpolation?: boolean;
-  /**
-   * Optional approval gate for `!\`cmd\`` shell interpolation. Invoked once
-   * per (skill, command) the first time a skill with embedded shell is
-   * activated, BEFORE the command runs. Return `false` to skip that command
-   * (it is replaced with a `[shell interpolation not approved]` placeholder).
-   * When omitted, interpolation runs without prompting (back-compat). Hosts
-   * (TUI/GUI) can wire this to an interactive confirmation.
-   */
-  approveShellInterpolation?: (request: ShellInterpolationApproval) => boolean | Promise<boolean>;
-}
-/**
- * Factory for `skills_use`. Auto-injected into the agent's tool set by the
- * agent runtime when a non-empty skills catalog is available (unless
- * `SkillsConfig.tool === false`).
- *
- * The tool schema's `name` property is `enum`-constrained to the resolved
- * catalog so the LLM cannot hallucinate a skill that doesn't exist.
- */
-declare function createSkillsUseTool(options: SkillsUseToolOptions): ToolDef;
-//#endregion
-//#region src/tools/spawn.d.ts
-interface ChildAgent {
-  id: string;
-  task: string;
-  startedAt: number;
-  /** Subagent depth — 1 for a direct child of a top-level agent. */
-  depth: number;
-}
-interface SpawnToolState {
-  /** Currently running children. */
-  readonly children: ReadonlyMap<string, ChildAgent>;
-  /**
-   * Cumulative stats across every completed direct child of this spawn-tool
-   * instance (returns a copy). Each child's contribution is the cumulative
-   * `AgentStats` returned by its `agent.run()` — so
-   * `totalIn`/`totalOut`/`totalCacheRead`/`totalCacheCreation` cover the
-   * entire subtree (children + grandchildren + …), while `turns` and
-   * `elapsed` stay parent-loop-only per child and are summed across direct
-   * children. `elapsed` over-counts when children ran in parallel.
-   *
-   * Lives across multiple parent runs that share this instance.
-   */
-  readonly totalChildStats: Readonly<AgentStats>;
-}
-interface SpawnToolOptions {
-  /** Maximum concurrent sub-agents (default: 3). */
-  maxConcurrent?: number;
-  /**
-   * Maximum subagent depth. 0 disables spawning entirely; 1 allows top-level
-   * spawns but forbids grandchildren; 3 (default) allows three levels of
-   * recursion — enough for most orchestration patterns, a sharp ceiling
-   * against runaway loops.
-   */
-  maxDepth?: number;
-  /**
-   * Child model override. When unset, the child inherits the parent run's
-   * resolved model (`ToolContext.model`), falling back to
-   * `provider.meta.defaultModel` only when the parent didn't expose one.
-   */
-  model?: string;
-  /** Child system prompt override. Per-spawn `input.system` takes precedence. */
-  system?: string;
-  /** Child thinking level. */
-  thinking?: 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
-  /** Preset override for children. Shallow-merged over the parent's preset (parent fields still win for anything left unset). */
-  preset?: Preset;
-  /**
-   * Per-child timeout, in milliseconds. When the child exceeds it the spawn
-   * tool returns a timeout marker, fires `spawn:error`, and destroys the
-   * child agent. Default: none.
-   */
-  timeoutMs?: number;
-  /**
-   * When `true` and the parent has a session, the child reuses the parent's
-   * session — child turns are appended with the child's own `runId`, and the
-   * resulting `SessionRun` carries `parentRunId` so the tree is
-   * reconstructible. Default: `false` (child is in-memory only).
-   *
-   * **Read-state isolation.** Sharing the session also shares the
-   * `read_file` / `requireReadBeforeEdit` tracking map (it's keyed
-   * by `Session`). With `persist: false` the child gets no session,
-   * so reads inside the subagent populate nothing the parent can see —
-   * a follow-up `edit` / `multi_edit` in the parent will trip the
-   * gate with `"has not been read"` even though the model just
-   * read the file in the child. Use {@link shareReadState} when
-   * you want the parent's gate to honor the child's reads WITHOUT
-   * also persisting child turns to the parent's session.
-   */
-  persist?: boolean;
-  /**
-   * Forward the parent's read-state map to the child agent so the
-   * `requireReadBeforeEdit` gate and `dedupReads` cache see reads
-   * across the parent/child boundary. Orthogonal to {@link persist} —
-   * use this when you want shared read tracking without sharing the
-   * session's turn history. Default: `false`.
-   *
-   * Has no effect when the parent has no read-state to share (no
-   * session and no explicit `readState` on the parent agent's
-   * options). Implementation: passes the parent's resolved
-   * `ReadStateMap` to the child via `AgentOptions.readState`, which
-   * tools resolve via `ctx.readState ?? getReadState(ctx.session)`.
-   */
-  shareReadState?: boolean;
-  /**
-   * Forward a curated subset of child hook events (`stream:*`, `tool:*`,
-   * `turn:after`) onto the parent's hook bus as `child:*` events. Default:
-   * `true`. Grandchildren bubble through their child transparently.
-   */
-  forwardHooks?: boolean;
-  /** Called when a child agent starts. */
-  onSpawn?: (child: ChildAgent) => void;
-  /** Called when a child agent completes (success, abort, timeout, or error). */
-  onComplete?: (child: ChildAgent, stats: AgentStats, status: NonNullable<ChildRunStats['status']>) => void;
-  /**
-   * Named subagent presets the model can select via the `subagent_type`
-   * input field. Mirrors the Claude Code SDK's surface — models trained
-   * on it routinely emit `subagent_type: 'Explore' | 'Plan' |
-   * 'Verification' | 'general-purpose'`, and without a registry the
-   * field is silently dropped, so hosts wanting type-specialized
-   * subagents have to invent their own dispatch layer.
-   *
-   * Each entry overlays the base spawn config for that particular
-   * dispatch. Per-call `input.system` still wins over `subagents[type].system`
-   * so the model can always specialize further.
-   *
-   * When the registry is non-empty:
-   *   - `subagent_type` appears in the spawn input schema as a `string`
-   *     enum of the registered keys (plus the always-available
-   *     `'general-purpose'` fallback).
-   *   - Models that pass an unregistered type are routed to
-   *     `'general-purpose'` (no error — degrade gracefully so trained
-   *     models keep working even on hosts that haven't wired every
-   *     type Claude Code uses).
-   *
-   * When the registry is empty / unset, the field is omitted entirely
-   * (preserves the historical schema for hosts that never use this).
-   *
-   * Default: `undefined` (no subagent types; `subagent_type` schema
-   * field hidden).
-   */
-  subagents?: SubagentRegistry;
-}
-/**
- * Per-type subagent override applied when the model calls
- * `spawn({ subagent_type: '…' })`. All fields are optional; absent
- * fields fall back to the parent's resolved configuration (see
- * {@link SpawnToolOptions} comments for the merge order).
- */
-interface SubagentDef {
-  /**
-   * System prompt override for this subagent type. Per-call
-   * `input.system` still wins — model-supplied specialization beats
-   * preset defaults.
-   */
-  system?: string;
-  /**
-   * Restrict the child agent's tool registry to this list of canonical
-   * tool names. Operates as a filter over the parent's tools (the
-   * parent's selection is the upper bound — a subagent can never gain
-   * tools the parent doesn't have). When unset, the child inherits the
-   * parent's full tool list.
-   *
-   * Tool names are canonical (registry-key) not wire/alias names — the
-   * filter runs before aliases are applied. Names that don't match a
-   * parent tool are silently dropped (matches the lenient behaviour of
-   * `enabledTools` on MCP configs).
-   */
-  tools?: readonly string[];
-  /**
-   * Mark this subagent as read-only — equivalent to listing only
-   * obviously-non-mutating tools (`read_file`, `grep`, `glob`,
-   * `list_files`) in {@link SubagentDef.tools}. Convenience for the
-   * common "Plan" / "Explore" subagent shape Claude Code ships.
-   *
-   * When both `readonly: true` and `tools` are set, `tools` wins
-   * (explicit beats implicit).
-   */
-  readonly?: boolean;
-  /**
-   * Short description rendered into the spawn tool's schema (the
-   * `subagent_type` field's description) so the model can pick a type
-   * that matches the task without round-tripping through docs.
-   */
-  description?: string;
-}
-/**
- * Map of subagent-type key → preset. Keys are case-sensitive and
- * appear verbatim in the spawn input schema's enum so the model emits
- * them with the same casing. Common conventions: `'Explore'`,
- * `'Plan'`, `'Verification'`, `'general-purpose'` (Claude Code SDK's
- * built-in set).
- */
-type SubagentRegistry = Record<string, SubagentDef>;
-/**
- * Create a configured spawn tool.
- *
- * State (`children`, `totalChildStats`, counters, active count) is scoped to
- * the returned instance. Multiple parent agents using the same instance will
- * share counters + stats + concurrency slots — call `createSpawnTool()` per
- * agent (or use the stateless default `spawn`) to keep them isolated.
- */
-declare function createSpawnTool(options?: SpawnToolOptions): ToolDef & SpawnToolState;
-//#endregion
-//#region src/tools/tool-search.d.ts
-interface LazyToolEntry {
-  /**
-   * Wire name (after `toolAliases` rewrite). What the model sees in the
-   * catalog, what `tool_search` matches against, and what the provider's
-   * tool list will carry once the entry is unlocked.
-   */
-  name: string;
-  /**
-   * Canonical (registry-key) name used for unlock-set membership and for the
-   * loop's `ctx.tools[name]` dispatch lookup. Equal to `name` when no alias
-   * is configured for this tool.
-   */
-  canonicalName: string;
-  description: string;
-  inputSchema: Record<string, unknown>;
-  /** Source MCP server, when applicable. Used for `server`-bulk unlock. */
-  server?: string;
-}
-interface ToolSearchToolOptions {
-  /**
-   * Snapshot of every lazy tool the model can discover. Built once per run by
-   * the agent — the tool closes over this array and never mutates it.
-   */
-  catalog: readonly LazyToolEntry[];
-  /**
-   * Mutable per-run set of unlocked **canonical** tool names. The tool adds
-   * matches in place; the loop reads the set when rebuilding the wire-level
-   * tool list. Keyed by canonical (not wire) so dispatch lookups stay
-   * alias-stable.
-   *
-   * Prefer `addUnlock` for cache-stable wire-tool ordering: writes through a
-   * Set lose unlock order, so the wire-level rebuild that filters by `unlocked`
-   * has to fall back to registry iteration order — which moves entries every
-   * time a lazy tool earlier in the registry is unlocked, breaking provider
-   * prompt-cache breakpoints. The agent passes both when it owns the unlock
-   * tracker, with `addUnlock` mirroring writes into an ordered log.
-   */
-  unlocked: Set<string>;
-  /**
-   * Optional callback fired for every canonical name the tool unlocks. When
-   * set, the agent uses this to maintain an append-only `dynamicUnlockOrder`
-   * so the wire-level tool list emits new unlocks at the tail and keeps the
-   * provider prefix cache warm. Idempotent on repeat unlocks of the same
-   * name — callers may dedupe internally.
-   *
-   * Invoked **in addition to** the `unlocked.add` (which still happens for
-   * back-compat with callers that only watch the Set).
-   */
-  addUnlock?: (canonical: string) => void;
-  /** Default cap on returned matches when the model omits `limit`. */
-  defaultLimit?: number;
-}
-/**
- * Factory for `tool_search`. Auto-injected by the agent when
- * `behavior.toolDisclosure === 'lazy'` and at least one MCP tool is in the
- * registry. Opt out via `behavior.toolSearch.tool === false`.
- */
-declare function createToolSearchTool(options: ToolSearchToolOptions): ToolDef;
-//#endregion
-//#region src/tools/truncate.d.ts
-/**
- * Tail-priority, byte-budgeted truncation shared across tools.
- *
- * "Tail-priority" because the most useful signal in command / job output
- * (errors, exit summaries, the last thing that happened) lives at the END.
- * When `text` exceeds the byte budget the HEAD is dropped and replaced with a
- * marker, keeping as much of the tail as fits.
- *
- * The budget is a UTF-8 *byte* count, not a character count — wire/output
- * accounting is bytes, and a naive `String.prototype.slice` (UTF-16 code
- * units) under-counts multibyte text badly. The cut always lands on a whole
- * code point: the walk steps by code point (surrogate pairs included), so an
- * emoji or CJK glyph is never split into a lone surrogate. As a final safety
- * net against callers that hand us text already sliced mid-codepoint at a raw
- * byte boundary (the classic `Buffer.subarray(...).toString()` pattern, which
- * decodes a partial lead/continuation byte to U+FFFD), a leading run of
- * replacement characters is stripped from the kept tail.
- */
-interface TailTruncateOptions {
-  /**
-   * Build the marker inserted before the kept tail, given the number of
-   * UTF-8 bytes dropped from the head. Defaults to
-   * `…(<n> bytes truncated from head)…\n`. Return an empty string to keep
-   * the tail with no marker at all.
-   */
-  marker?: (droppedBytes: number) => string;
-}
-/**
- * Keep the last `maxBytes` UTF-8 bytes of `text`, dropping the head and
- * prefixing a marker. A non-positive `maxBytes` disables truncation and
- * returns `text` unchanged.
- *
- * `maxBytes` budgets the kept tail only; the marker is added on top and may
- * push the returned string slightly past `maxBytes`. That tradeoff is
- * intentional — folding the marker into the budget would shrink the content
- * actually shown.
- */
-declare function tailTruncate(text: string, maxBytes: number, options?: TailTruncateOptions): string;
-//#endregion
-//#region src/tools/validation.d.ts
-/**
- * Tool argument validation against JSON Schema-style inputSchema.
- *
- * Two passes:
- *   1. Required-field presence. Missing or null/undefined required fields fail.
- *   2. Per-property type checks with **best-effort coercion**. Small/OSS models
- *      routinely send `"true"` for a `boolean` field or `"42"` for a `number`,
- *      and rejecting outright forces a confusing retry. Instead, we auto-heal
- *      coerce when the conversion is unambiguous, fail only when the value
- *      cannot be reasonably normalized to any of the declared types.
- *
- * Recursion: when a property declares `type: 'array'` with an `items` schema,
- * each item is validated against `items`. Object items are walked one level
- * deep (their declared `properties` get the same coercion + enum checks the
- * top level does). Items that can't be coerced are dropped rather than
- * rejecting the whole call — the model rarely benefits from an
- * all-or-nothing failure on a 20-item list because one entry was malformed.
- * Dropped items are reported back via `droppedItems` so the tool's `execute`
- * can surface a hint to the model if it wants to.
- */
-interface ValidationResult {
-  valid: boolean;
-  /** Human-readable reason. Present on failure only. */
-  error?: string;
-  /**
-   * Possibly-coerced input. Present iff `valid: true`. Tools should call
-   * `execute(coercedInput, ctx)` so auto-healed values reach the tool body.
-   * When no coercion was applied, this is reference-equal to the input.
-   */
-  coercedInput?: Record<string, unknown>;
-  /**
-   * Names of fields whose values were coerced. Empty when nothing changed.
-   * Useful for telemetry (`validation:reject` on failure already carries the
-   * reason; this is the success-path equivalent).
-   */
-  coercions?: readonly string[];
-  /**
-   * Indexes of array items dropped during recursive validation, keyed by
-   * the property name. Empty / absent when nothing was dropped. Tools that
-   * care about the discrepancy (e.g. `todowrite` wanting to surface
-   * "ignored 2 malformed items") can inspect this.
-   */
-  droppedItems?: Readonly<Record<string, readonly number[]>>;
-}
-declare function validateToolArgs(input: Record<string, unknown>, schema: Record<string, unknown>): ValidationResult;
-//#endregion
-//#region src/tools/wait-task.d.ts
-/**
- * Stable prefix on the timed-out result. The agent's notification
- * suppression keys on it: results carrying this prefix mean the task is
- * still running, so the pending `<task-notification>` must survive.
- */
-declare const WAIT_TASK_TIMED_OUT_PREFIX = "wait_task: timed out";
-declare const waitTask: ToolDef;
-//#endregion
-//#region src/tools/write-file.d.ts
-/**
- * Write a file, with an idempotency signal when the content is unchanged.
- *
- * Three return shapes — chosen so the model can recognize a no-op without a
- * separate read:
- *   - `Created path (N bytes)` — file did not exist
- *   - `Updated path (N bytes)` — content differed from on-disk
- *   - `No change needed: path already at target state (N bytes)` — equal
- *
- * Race window: in non-process execution contexts (docker, sandbox) shared by
- * multiple agents, another writer can mutate the file between our read and
- * our write. Local process context is single-writer per agent so the race is
- * a non-issue there. Documented rather than locked because the cost of
- * cross-context locking outweighs the cost of a stale "No change" message.
- */
-declare const writeFile: ToolDef;
-//#endregion
-//#region src/headless.d.ts
-type HeadlessStatus = 'completed' | 'aborted' | 'error' | 'timeout';
-interface HeadlessUsage {
-  input: number;
-  output: number;
-  cacheRead: number;
-  cacheCreation: number;
-  /** Cumulative USD cost when the provider/registry could price the run. */
-  cost?: number;
-}
-interface HeadlessErrorInfo {
-  message: string;
-  /** Typed-error class name (`AgentAbortedError`, `AgentContextExceededError`, …). */
-  type: string;
-}
-/**
- * Strictly JSON-serializable postmortem of one headless run. Everything an RL
- * reward function needs: the final answer (`finalText`), the verifiable
- * structured output (`output`, present iff a `schema` was set), usage/turns,
- * and the lossless `transcript` (the SFT training data).
- */
-interface HeadlessResult {
-  status: HeadlessStatus;
-  /** Concatenated text of the last assistant turn that produced any text. */
-  finalText: string;
-  /** Schema-enforced structured output (only when `opts.schema` is set). */
-  output?: Record<string, unknown>;
-  usage: HeadlessUsage;
-  turns: number;
-  durationMs: number;
-  /** Total `tool_call` blocks across the whole transcript. */
-  numToolCalls: number;
-  /** Finish reason of the final turn that reported one. */
-  finishReason?: TurnFinishReason;
-  error?: HeadlessErrorInfo;
-  sessionId: string;
-  /** Incident postmortem (errors, gate blocks, budget events) via run-summary. */
-  summary?: RunSummary;
-  /** Lossless transcript — raw `session.turns`. Thinking stripped when `includeThinking: false`. */
-  transcript: SessionTurn[];
-}
-type HeadlessOutputFormat = 'zidane' | 'provider';
-type ProviderTranscriptFormat = 'anthropic' | 'openai';
-type FormattedHeadlessResult = HeadlessResult | unknown[];
-type FormattedHeadlessTurnEvent = Extract<HeadlessEvent, {
-  type: 'turn';
-}> | unknown[];
-declare function exitCodeForHeadlessResult(result: HeadlessResult): number;
-/**
- * Live event union — the in-process equivalent of a `stream-json` line. Every
- * member is JSON-serializable; render to JSONL with {@link headlessEventToJsonl}.
- */
-type HeadlessEvent = {
-  type: 'start';
-  runId: string;
-  provider?: string;
-} | {
-  type: 'text';
-  delta: string;
-} | {
-  type: 'thinking';
-  delta: string;
-} | {
-  type: 'tool_call';
-  callId: string;
-  name: string;
-  input: Record<string, unknown>;
-} | {
-  type: 'tool_result';
-  callId: string;
-  name: string;
-  output: string;
-  isError: boolean;
-} | {
-  type: 'turn';
-  index: number;
-  turn: SessionTurn;
-} | {
-  type: 'spawn';
-  event: 'before' | 'complete' | 'error';
-  id: string;
-  info?: Record<string, unknown>;
-} | {
-  type: 'error';
-  message: string;
-  errorType?: string;
-} | {
-  type: 'result';
-  result: HeadlessResult;
-};
-/** Serialize one event as a newline-terminated JSON line (stream-json). */
-declare function headlessEventToJsonl(event: HeadlessEvent): string;
-declare function formattedHeadlessTurnEventToJsonl(event: FormattedHeadlessTurnEvent): string;
-declare function providerTranscriptFormatForProvider(providerName: string): ProviderTranscriptFormat;
-declare function transcriptToProviderMessages(turns: SessionTurn[], providerName: string): unknown[];
-declare function formatHeadlessResult(result: HeadlessResult, options: {
-  format: HeadlessOutputFormat;
-  providerName: string;
-}): FormattedHeadlessResult;
-declare function formatHeadlessTurnEvent(event: Extract<HeadlessEvent, {
-  type: 'turn';
-}>, options: {
-  format: HeadlessOutputFormat;
-  providerName: string;
-}): FormattedHeadlessTurnEvent;
-interface HeadlessOptions {
-  /** User prompt — plain string or multimodal `PromptPart[]`. */
-  prompt: string | PromptPart[];
-  /** Built provider (e.g. `local()`, `openaiCompat(...)`, `anthropic(...)`). */
-  provider: Provider;
-  model?: string;
-  /** Override the preset system prompt for this run. */
-  system?: string;
-  thinking?: ThinkingLevel;
-  maxTurns?: number;
-  maxTokens?: number;
-  /** Wall-clock cap; on expiry the run is aborted and `status` becomes `'timeout'`. */
-  timeoutMs?: number;
-  /** External abort signal — chained with the internal timeout controller. */
-  signal?: AbortSignal;
-  /** JSON Schema for structured-output enforcement → populates `result.output`. */
-  schema?: Record<string, unknown>;
-  /** Agent behavior defaults for this headless run. Top-level shortcuts below override matching fields. */
-  behavior?: AgentOptions['behavior'];
-  /** Tool overrides. Omit to use the basic preset's tools. */
-  tools?: Record<string, ToolDef>;
-  mcpServers?: McpServerConfig[];
-  skills?: AgentOptions['skills'];
-  /** Execution context. Defaults to a process context rooted at `cwd`. */
-  execution?: ExecutionContext;
-  /** Working directory for the default process context (ignored if `execution` is set). */
-  cwd?: string;
-  /** Reuse / resume an existing session. */
-  session?: Session;
-  /** Session store for a fresh session (defaults to an in-memory store). */
-  store?: SessionStore;
-  /** Keep `thinking` blocks in `result.transcript` (default true). */
-  includeThinking?: boolean;
-  /** Live event callback — the in-process stream-json equivalent. */
-  onEvent?: (event: HeadlessEvent) => void;
-}
-/**
- * Run a prompt to completion, headless, and return a single serializable
- * {@link HeadlessResult}. Safe to call concurrently for parallel rollouts —
- * each call builds its own agent + session and tears them down in `finally`.
- */
-declare function runHeadless(opts: HeadlessOptions): Promise<HeadlessResult>;
-interface OpenAIChatMessage {
-  role: 'system' | 'user' | 'assistant' | 'tool';
-  content: string | null | OpenAIChatContentPart[];
-  tool_calls?: Array<{
-    id: string;
-    type: 'function';
-    function: {
-      name: string;
-      arguments: string;
-    };
-  }>;
-  tool_call_id?: string;
-}
-type OpenAIChatContentPart = {
-  type: 'text';
-  text: string;
-} | {
-  type: 'image_url';
-  image_url: {
-    url: string;
-  };
-} | {
-  type: 'input_audio';
-  input_audio: {
-    data: string;
-    format: string;
-  };
-} | {
-  type: 'video_url';
-  video_url: {
-    url: string;
-  };
-};
-/**
- * Convert raw `session.turns` into standard OpenAI chat-completion messages:
- * assistant turns carry `tool_calls`, and each `tool_result` becomes its own
- * `role: 'tool'` message. This is the drop-in shape for an SFT renderer —
- * unlike `toOpenAI` (session/messages.ts), which emits an internal `_tag`
- * envelope meant for re-sending to a provider, not for training data.
- *
- * Fails closed on corrupt raw turns instead of fabricating tool results; silent
- * placeholders would create structurally-valid but semantically-poisoned SFT
- * examples.
- */
-declare function transcriptToOpenAIMessages(turns: SessionTurn[], options?: {
-  strictToolPairing?: boolean;
-}): OpenAIChatMessage[];
-declare function installHeadlessEventAdapter(hooks: Hookable<AgentHooks>, onEvent: (event: HeadlessEvent) => void): () => void;
-//#endregion
-//#region src/eval.d.ts
-interface EvalWorkspaceOptions {
-  /**
-   * Working directory inside the execution context. When omitted, process-based
-   * evals get a fresh host temp dir; Docker evals use the context default.
-   *
-   * Note: under the shared-Docker harness (`withDocker`), per-case working dirs
-   * are assigned by the container (`/workspace/case-N`) and a custom `cwd` is
-   * ignored — `withDocker` strips it so cases stay isolated.
-   */
-  cwd?: string;
-  /**
-   * Directory visible inside the execution context, copied into the workspace
-   * before the agent runs. For Docker, mount local fixtures read-only and point
-   * this at the container path, e.g. `/fixtures/react-empty`.
-   */
-  seedDir?: string;
-  /** Relative destination inside the workspace. Defaults to `.`. */
-  seedTarget?: string;
-  /** Relative files/directories to capture after the run. Defaults to `.`. */
-  capture?: string[];
-  /** Max text chars retained per captured file. Defaults to 256 KiB. */
-  maxFileChars?: number;
-  /** Keep a temp process workspace on disk after the eval completes. */
-  retain?: boolean;
-}
-interface EvalWorkspaceFile {
-  path: string;
-  size: number;
-  content?: string;
-  truncated?: boolean;
-  binary?: boolean;
-}
-interface EvalWorkspaceSnapshot {
-  cwd: string;
-  files: EvalWorkspaceFile[];
-}
-interface EvalScore {
-  name: string;
-  passed: boolean;
-  score?: number;
-  details?: string | Record<string, unknown>;
-}
-type MetricDirection = 'higher-is-better' | 'lower-is-better';
-/** Declared metric: a raw signal plus how to normalize it to a `0..1` score. */
-interface MetricSpec {
-  min: number;
-  max: number;
-  direction: MetricDirection;
-  /** Grouping tags, e.g. `@efficiency`, `@functionality`, `@quality`. */
-  tags?: string[];
-  description?: string;
-}
-type MetricSpecMap = Record<string, MetricSpec>;
-/** A normalized metric value attached to one eval case. */
-interface EvalMetric {
-  id: string;
-  raw: number;
-  normalized: number;
-  direction: MetricDirection;
-  min: number;
-  max: number;
-  tags: string[];
-  description?: string;
-  /**
-   * True when the metric was declared but never emitted (e.g. its scorer threw
-   * before calling `ctx.metric`). Recorded as `normalized: 0` so the run still
-   * produces results instead of crashing.
-   */
-  missing?: boolean;
-}
-/** Emit a raw metric value during a run. */
-type MetricEmitter = (id: string, raw: number) => void;
-interface EvalScorerContext {
-  id: string;
-  suite?: string;
-  tags: string[];
-  result: HeadlessResult;
-  events: readonly HeadlessEvent[];
-  workspace?: EvalWorkspaceSnapshot;
-  artifactDir?: string;
-  /** Emit a declared metric's raw value. Unknown ids throw at run end. */
-  metric: MetricEmitter;
-}
-type EvalScorer = (ctx: EvalScorerContext) => EvalScore | Promise<EvalScore>;
-/**
- * Declare an eval's metric set. Returns the same map, typed; pass it to
- * `EvalCaseOptions.metrics`. Declared metrics that are not emitted are recorded
- * as missing with a normalized score of 0; emitting an undeclared metric is an
- * authoring error and throws.
- */
-declare function defineMetrics<T extends MetricSpecMap>(spec: T): T;
-/** Always-available efficiency metrics derived from `HeadlessResult`. */
-declare const EFFICIENCY_METRICS: {
-  'execution-time': {
-    min: number;
-    max: number;
-    direction: "lower-is-better";
-    tags: string[];
-    description: string;
-  };
-  'provider-tokens': {
-    min: number;
-    max: number;
-    direction: "lower-is-better";
-    tags: string[];
-    description: string;
-  };
-  'cache-read-rate': {
-    min: number;
-    max: number;
-    direction: "higher-is-better";
-    tags: string[];
-    description: string;
-  };
-};
-declare function normalizeMetric(raw: number, spec: MetricSpec): number;
-interface LlmJudgeOptions {
-  name?: string;
-  provider: Provider;
-  model?: string;
-  system?: string;
-  rubric: string;
-  maxTokens?: number;
-  /** Wall-clock cap for the judge provider call. Defaults to 60s. */
-  timeoutMs?: number;
-  /** Select what the judge sees. Defaults to final text plus captured workspace files. */
-  input?: (ctx: EvalScorerContext) => string;
-  /** Declared metric id to emit the judge's `0..1` score into. */
-  metric?: string;
-}
-/**
- * Thrown by `runEvalCase` when a scorer emits a metric id that was not declared
- * in `defineMetrics`. This is an authoring error (a typo'd or stale metric id),
- * not a low score — it fails the eval test rather than being recorded as a
- * failed scorer. Exported so downstream harnesses can type-narrow on it.
- */
-declare class EvalMetricError extends Error {
-  constructor(message: string);
-}
-interface ReusableExecutionContext {
-  /**
-   * Execution context facade that reuses one underlying handle. Its
-   * `destroy()` is intentionally a no-op; call `dispose()` when the surrounding
-   * fixture/run owns teardown.
-   */
-  execution: ExecutionContext;
-  /** Destroy the underlying handle if it was spawned. Idempotent. */
-  dispose: () => Promise<void>;
-  /** Current underlying handle, if the agent has spawned one. */
-  handle: () => ExecutionHandle | undefined;
-}
-/**
- * Wrap an execution context so repeated agent runs share one handle until the
- * caller disposes it. This is useful for eval fixtures that want per-test
- * Docker/process lifetime while still using `runHeadless()` per turn.
- */
-declare function createReusableExecutionContext(base: ExecutionContext): ReusableExecutionContext;
-interface EvalAgentRunStats extends EvalRunUsage {
-  durationMs: number;
-  turns: number;
-  toolCalls: number;
-}
-interface EvalAgentStats extends EvalRunUsage {
-  /** Number of completed `run()` calls. */
-  runs: number;
-  /** Sum of per-run agent turns. */
-  turns: number;
-  /** Sum of per-run tool calls. */
-  toolCalls: number;
-  /** Sum of per-run wall-clock durations. */
-  durationMs: number;
-}
-interface EvalAgentRunResult {
-  /** Full headless result. Its transcript is scoped to this run. */
-  result: HeadlessResult;
-  /** Per-run usage and trajectory counters. */
-  stats: EvalAgentRunStats;
-  /** Transcript turns added by this run (same view as `result.transcript`). */
-  newTranscript: SessionTurn[];
-}
-type EvalAgentMcpServers = readonly McpServerConfig[] | (() => readonly McpServerConfig[] | Promise<readonly McpServerConfig[]>);
-interface CreateEvalAgentOptions extends Omit<HeadlessOptions, 'prompt' | 'provider' | 'execution' | 'cwd' | 'session' | 'store' | 'mcpServers' | 'onEvent' | 'signal'> {
-  provider: Provider;
-  /**
-   * Working directory for the default process context. Ignored when
-   * `execution` is supplied.
-   */
-  cwd?: string;
-  /**
-   * Execution context for agent tools. Wrapped with
-   * `createReusableExecutionContext` so runs share one handle until `dispose`.
-   */
-  execution?: ExecutionContext;
-  /** Session to reuse across runs. When omitted, one in-memory session is created. */
-  session?: Session;
-  /** Store used for the auto-created session. Defaults to an in-memory store. */
-  store?: SessionStore;
-  /** Static or lazily resolved MCP servers. Resolved fresh before each run. */
-  mcpServers?: EvalAgentMcpServers;
-  /** Live event callback for every run. */
-  onEvent?: (event: HeadlessEvent) => void;
-}
-interface EvalAgentRunOptions extends Omit<HeadlessOptions, 'provider' | 'execution' | 'cwd' | 'session' | 'store'> {
-  prompt: HeadlessOptions['prompt'];
-}
-interface EvalAgent {
-  run: (options: EvalAgentRunOptions) => Promise<EvalAgentRunResult>;
-  readonly stats: EvalAgentStats;
-  session: () => Promise<Session>;
-  dispose: () => Promise<void>;
-  [Symbol.asyncDispose]: () => Promise<void>;
-}
-/**
- * Multi-turn eval agent over the low-level headless runner. It keeps session
- * and execution lifetime outside any Playwright-specific fixture layer,
- * so downstream platforms can wrap it with their own `agent.run(...)` shape.
- */
-declare function createEvalAgent(options: CreateEvalAgentOptions): EvalAgent;
-type TrajectoryStepKind = 'think' | 'text' | 'tool';
-/**
- * One grouped step in an eval trajectory. Consecutive blocks of the same kind
- * (and, for tools, the same tool name) collapse into a single step with a
- * `count`. A different kind interrupting the run breaks the group.
- *
- * Serializable by design so trajectories round-trip to disk and can be diffed
- * or replayed by other tooling.
- */
-interface TrajectoryStep {
-  kind: TrajectoryStepKind;
-  /** Tool name for `kind: 'tool'` steps (canonical, e.g. `read_file`). */
-  name?: string;
-  /** Number of consecutive occurrences grouped into this step. */
-  count: number;
-  /** Approx wall-clock ms attributed to this step's turns, when derivable. */
-  durationMs?: number;
-}
-interface Trajectory {
-  steps: TrajectoryStep[];
-  /** Total blocks across all steps (sum of `count`). */
-  totalBlocks: number;
-}
-/**
- * Build an ordered, grouped trajectory from a transcript. Walks assistant
- * turns in order, emitting `think` / `text` / `tool:<name>` steps, grouping
- * only consecutive identical kinds. Per-step duration is approximated from the
- * owning turn's `createdAt` delta to the next turn.
- */
-declare function buildTrajectory(transcript: SessionTurn[]): Trajectory;
-/** Render a trajectory as a one-line timeline string (no color). */
-declare function formatTrajectoryLine(trajectory: Trajectory): string;
-interface EvalArtifacts {
-  dir: string;
-  result?: string;
-  events?: string;
-  transcript?: string;
-  workspace?: string;
-}
-interface EvalCaseResult {
-  id: string;
-  suite?: string;
-  /** Run variant this result belongs to (e.g. `baseten:zai-org/GLM-5.1`). */
-  variant?: string;
-  tags: string[];
-  result: HeadlessResult;
-  /** Mean normalized metric score in [0, 1] when metrics are declared; otherwise mean scorer score. */
-  score: number;
-  /** True when every scorer passed. */
-  passed: boolean;
-  scores: EvalScore[];
-  /** Normalized metrics for this case (empty when no metrics declared). */
-  metrics: EvalMetric[];
-  /** Mean normalized score per tag, e.g. `{ '@efficiency': 0.8 }`. */
-  tagScores: Record<string, number>;
-  /** Ordered, grouped step timeline derived from the transcript. */
-  trajectory: Trajectory;
-  events: HeadlessEvent[];
-  artifacts?: EvalArtifacts;
-  workspace?: EvalWorkspaceSnapshot;
-  workspaceError?: string;
-  /** Absolute path to the eval definition file, for editor links. */
-  sourceFile?: string;
-}
-interface EvalCaseOptions extends Omit<HeadlessOptions, 'onEvent'> {
-  id: string;
-  suite?: string;
-  /**
-   * Run variant label when the same eval runs against several provider/model
-   * targets in one run (e.g. `baseten:zai-org/GLM-5.1`). Flows into
-   * {@link EvalCaseResult.variant}, namespaces artifacts, and drives the
-   * reporter's per-variant tables + comparison matrix.
-   */
-  variant?: string;
-  tags?: string[];
-  artifactDir?: string;
-  workspace?: EvalWorkspaceOptions;
-  scorers?: EvalScorer[];
-  /**
-   * Declared metric set. Auto-merged with {@link EFFICIENCY_METRICS} so every
-   * eval gets comparable efficiency metrics for free. All declared metrics must
-   * be emitted (via auto-emit or `ctx.metric`) or the run throws.
-   */
-  metrics?: MetricSpecMap;
-  onEvent?: (event: HeadlessEvent) => void;
-  /** Absolute path to the eval definition file. Set via `import.meta.url`. */
-  sourceFile?: string;
-}
-interface EvalRunUsage {
-  input: number;
-  output: number;
-  cacheRead: number;
-  cacheCreation: number;
-  cost: number;
-}
-interface EvalRunSummaryCase {
-  id: string;
-  suite?: string;
-  variant?: string;
-  passed: boolean;
-  score: number;
-  status: HeadlessResult['status'];
-  durationMs: number;
-  scores: EvalScore[];
-  metrics: EvalMetric[];
-  tagScores: Record<string, number>;
-  trajectory: Trajectory;
-}
-interface MetricStats {
-  mean: number;
-  min: number;
-  max: number;
-  p50: number;
-  p90: number;
-  zeroCount: number;
-  values: number[];
-}
-interface EvalRunMetricAggregate {
-  id: string;
-  direction: MetricDirection;
-  tags: string[];
-  raw: MetricStats;
-  normalized: MetricStats;
-}
-/** Aggregate rollup for one run variant (provider/model target). */
-interface EvalVariantSummary {
-  variant: string;
-  count: number;
-  passed: number;
-  score: number;
-  durationMs: number;
-  usage: EvalRunUsage;
-}
-interface EvalRunSummary {
-  count: number;
-  passed: number;
-  score: number;
-  durationMs: number;
-  usage: EvalRunUsage;
-  cases: EvalRunSummaryCase[];
-  /** Per-metric stats across every case that emitted the metric. */
-  metrics: EvalRunMetricAggregate[];
-  /** Mean normalized score per tag across all cases. */
-  tagScores: Record<string, number>;
-  /** Per-variant rollups, present when any case carries a variant label. */
-  variants?: EvalVariantSummary[];
-}
-interface EvalRunReporterOptions {
-  /** Directory where per-case results and `run-summary.json` are written. */
-  outputDir?: string;
-  /** Enable ANSI colors. Defaults to TTY-aware auto color. */
-  color?: boolean;
-}
-interface EvalRunReporter {
-  readonly results: readonly EvalCaseResult[];
-  record: (result: EvalCaseResult) => Promise<void>;
-  flush: () => Promise<EvalRunSummary>;
-  format: () => string;
-}
-/** Context handed to an eval definition factory at registration time. */
-interface EvalDefinitionContext {
-  /** Agent-under-test provider. */
-  provider: Provider;
-  /** Provider used by `llmJudge` scorers. Defaults to `provider`. */
-  judge: Provider;
-  /** Optional agent model override; evals should pass it to `EvalCaseOptions.model`. */
-  model?: string;
-  /** Optional judge model override; evals should pass it to `llmJudge({ model })`. */
-  judgeModel?: string;
-}
-type EvalDefinition = (ctx: EvalDefinitionContext) => EvalCaseOptions;
-/**
- * Register an eval definition. Eval files call this at module load; the harness
- * (`buildRegisteredEvals`) materializes them with a provider at run time. The
- * factory keeps definitions lazy so a single registry serves any provider/judge
- * pairing without re-importing eval files.
- *
- * Returns the same factory so a file can also `export default` it for direct,
- * registry-free use (e.g. hermetic unit tests).
- */
-declare function defineEval(define: EvalDefinition): EvalDefinition;
-/** Snapshot of every registered eval, materialized for one provider/judge pair. */
-declare function buildRegisteredEvals(ctx: EvalDefinitionContext): EvalCaseOptions[];
-/** Drop every registered eval — test isolation helper. */
-declare function clearRegisteredEvals(): void;
-declare function runEvalCase(options: EvalCaseOptions): Promise<EvalCaseResult>;
-declare function statusCompleted(name?: string): EvalScorer;
-declare function fileExists(path: string, name?: string): EvalScorer;
-declare function fileExistsOneOf(paths: string[], name?: string): EvalScorer;
-declare function fileContains(path: string, expected: string | RegExp, name?: string): EvalScorer;
-declare function fileContentQuality(path: string, expected: string, name?: string): EvalScorer;
-declare function llmJudge(options: LlmJudgeOptions): EvalScorer;
-/**
- * Aggregate a group of boolean scorers into a single `0..1` functionality
- * metric (fraction passed) and emit it. Useful for "N of M files present".
- */
-declare function functionalityMetric(metricId: string, scorers: EvalScorer[], name?: string): EvalScorer;
-declare function formatEvalCaseSummary(result: EvalCaseResult): string;
-declare function formatEvalRunSummary(results: readonly EvalCaseResult[]): string;
-/** Minimal subset of a test runner's API the eval harness needs. */
-interface EvalTestRunner {
-  it: (name: string, fn: () => Promise<void> | void) => void;
-  afterAll: (fn: () => Promise<void> | void) => void;
-}
-interface RegisterEvalTestsOptions {
-  cases: EvalCaseOptions[];
-  runner: EvalTestRunner;
-  reporter?: EvalRunReporter;
-  artifactDir?: string;
-  /**
-   * When true (default), each case asserts only that the agent run reached a
-   * terminal `completed` status — scores are recorded but never fail the test.
-   * Evals are scoring tools, not deterministic assertions.
-   */
-  failOnIncomplete?: boolean;
-  /** Print the aggregated run summary after all cases. Default true. */
-  printSummary?: boolean;
-  /** Repeat each case N times (each repetition is its own test). Default 1. */
-  repeat?: number;
-  /** Teardown run once after all cases (e.g. dispose a shared container). */
-  dispose?: () => Promise<void> | void;
-  /**
-   * Max eval cases to run concurrently. Each case keeps its own workspace dir,
-   * so a shared container runs them in parallel safely. Default 1 (sequential).
-   */
-  concurrency?: number;
-}
-/**
- * Register one test per eval case against a test runner, funnel every result
- * into a shared reporter, and print the aggregated summary once after all cases.
- *
- * A failing test means the agent run itself broke (provider/tool/timeout). Low
- * scores are reported, not asserted — see {@link RegisterEvalTestsOptions.failOnIncomplete}.
- */
-declare function registerEvalTests(options: RegisterEvalTestsOptions): EvalRunReporter;
-declare function createEvalRunReporter(options?: EvalRunReporterOptions): EvalRunReporter;
-declare function buildEvalRunSummary(input: readonly EvalCaseResult[]): EvalRunSummary;
-declare function efficiencyMetricValues(result: HeadlessResult): Record<keyof typeof EFFICIENCY_METRICS, number>;
-declare function emitEfficiencyMetrics(emit: MetricEmitter, result: HeadlessResult): void;
-declare function finalizeEvalMetrics(specs: MetricSpecMap, raw: Map<string, number>): EvalMetric[];
-declare function computeEvalTagScores(metrics: EvalMetric[]): Record<string, number>;
-declare function artifactPath(root: string, result: EvalCaseResult): string;
-declare function relativeArtifactPath(root: string, path: string): string;
-//#endregion
-//#region src/loop.d.ts
-/**
- * Canonical tool_result text emitted when a tool call is interrupted by the
- * user mid-flight (Esc / Ctrl-C / external `AbortSignal`). Mirrors Claude
- * Code's `INTERRUPT_MESSAGE_FOR_TOOL_USE` so downstream consumers can pattern
- * match a single string across both harnesses. Always paired with
- * `isError: true` on the wire — the model treats it as a failed call rather
- * than a successful tool response.
- */
-declare const INTERRUPT_MESSAGE_FOR_TOOL_USE = "[Request interrupted by user for tool use]";
-/**
- * Canonical tool_result text emitted when a tool call is skipped because a
- * steering message arrived between dispatches inside
- * {@link executeToolBatch}. Distinguished from
- * {@link INTERRUPT_MESSAGE_FOR_TOOL_USE} so consumers can split "user
- * cancelled" from "framework superseded".
- */
-declare const TOOL_USE_SKIPPED_MESSAGE = "[Tool use skipped \u2014 superseded by user message]";
-/**
- * Canonical tool_result text emitted when a single tool call is cancelled
- * mid-flight via `agent.cancelTool(callId)` (typically the TUI's
- * "cancel this tool" affordance). Distinguished from
- * {@link INTERRUPT_MESSAGE_FOR_TOOL_USE} (run-wide user abort) and
- * {@link TOOL_USE_SKIPPED_MESSAGE} (steered) so the model — and downstream
- * consumers — can tell the three apart by string match.
- *
- * Always paired with `isError: true` on the wire so the model treats the
- * call as failed rather than as a successful response. The remaining tool
- * calls in the batch continue running, in contrast with a full-run abort.
- */
-declare const TOOL_USE_CANCELLED_MESSAGE = "[Tool call cancelled by user]";
-/**
- * Canonical `tool_result.content` text emitted to siblings that were
- * cancelled by a `shell` error in the same batch. Distinct from
- * {@link INTERRUPT_MESSAGE_FOR_TOOL_USE} (user-issued abort) and
- * {@link TOOL_USE_SKIPPED_MESSAGE} (steered) so consumers can split
- * the three causes by string-match.
- */
-declare const SHELL_CASCADE_CANCEL_MESSAGE = "Cancelled: a sibling `shell` call in the same batch errored; re-run independently if still needed.";
-//#endregion
-//#region src/loop-persistence.d.ts
-/**
- * Bytes of head content included in the inline preview block. 2 KiB matches
- * Claude Code's `PREVIEW_SIZE_BYTES` — enough for the model to identify the
- * content class (error output / structured data / log shape) and decide
- * whether to call `read_file` on the persisted path for the full payload.
- *
- * Tail-priority preview (matching `shell`'s truncation strategy) was
- * considered but rejected: most "what is this?" decisions get made from
- * the head, and the path is in the stub for the rare case where the tail
- * matters.
- */
-declare const PERSISTENCE_PREVIEW_BYTES: number;
-/**
- * Byte-stable prefix every {@link buildPersistedStub} output starts with.
- * Exported so wire-level passes (tail compaction, future stale-output
- * elision) can recognize a persisted stub and preserve its path attribute
- * rather than replacing the stub with their own — losing the pointer to
- * the on-disk blob.
- *
- * Bound to the literal opening of the XML tag; changing the stub format
- * requires updating this constant in lockstep (and shipping a migration
- * for in-flight sessions).
- */
-declare const PERSISTED_STUB_PREFIX = "<persisted-output tool=\"";
-/**
- * Resolve the per-session persistence directory under `<userDir>/tool-results/<sessionId>/`.
- *
- * The chat layer calls this at session activation and forwards the result
- * via `behavior.persistDir`. Exposed as a public helper so SDK consumers
- * pick the same layout — single source of truth for "where do blobs live".
- */
-declare function resolvePersistDir(opts: {
-  userDir: string;
-  sessionId: string;
-}): string;
-/**
- * Resolve the per-session background-tasks directory under
- * `<userDir>/<sessionId>/tasks/`.
- *
- * The chat layer calls this at session activation and forwards the result
- * via `behavior.tasksDir`. Same shape as {@link resolvePersistDir}: hosts
- * get a single source of truth for "where do task log files live".
- * Created on first write; cleanup is the session-delete path's job.
- */
-declare function resolveTasksDir(opts: {
-  userDir: string;
-  sessionId: string;
-}): string;
-/**
- * Inputs to {@link maybePersistToolResult}. Kept as a struct so the loop's
- * call site stays readable and additional optional knobs (compression,
- * mime detection, …) land without re-threading every call site.
- */
-interface PersistInput {
-  /** Canonical tool name — checked against `excludeTools`. */
-  toolName: string;
-  /** `tool_use` id from the assistant turn. Used as the filename. */
-  callId: string;
-  /** Result returned by the tool (post-`tool:transform`). */
-  output: string | ToolResultContent[];
-  /** Byte threshold; outputs at or below stay inline. */
-  threshold: number;
-  /** Canonical tool names that bypass persistence. */
-  excludeTools?: readonly string[];
-  /** Persistence root directory. Created on first write. */
-  persistDir: string;
-  /**
-   * Optional cap on the total bytes of persisted blobs under `persistDir`.
-   * When set (and > 0), after a successful write the helper sweeps the
-   * directory and removes the oldest `*.txt` blobs (by mtime) until the
-   * sum of remaining sizes is at or below the cap.
-   *
-   * Bound to the **current session** because `persistDir` is per-session
-   * (see {@link resolvePersistDir}); eviction never crosses session
-   * boundaries. The new blob is always preserved — its mtime is the
-   * latest, so the LRU sort guarantees older blobs go first.
-   *
-   * Skipped when the value isn't a positive finite number. Also skipped when
-   * {@link writeBlob} is supplied: without remote stat/delete primitives, a
-   * local host sweep would inspect the wrong filesystem. Remote contexts rely
-   * on their own ephemeral teardown / storage quotas instead. Eviction failures
-   * (permissions, races) are surfaced through `ZIDANE_DEBUG` but never block
-   * the calling tool result; an over-cap dir is a housekeeping concern, not a
-   * correctness one.
-   */
-  maxBytes?: number;
-  /**
-   * Optional writer that routes the blob through a specific filesystem. The
-   * agent loop passes `(path, content) => ctx.execution.writeFile(handle, …)`
-   * so the persisted blob lands on the SAME filesystem the model reads it back
-   * from (`read_file` → `ctx.execution.readFile`) — correct for docker /
-   * sandbox / remote / edge contexts, not only the host process.
-   *
-   * Omitted → falls back to a local atomic write (`<path>.tmp` + rename) on the
-   * host `fs`, the historical behavior. A routed write is not atomic, which is
-   * immaterial here: the blob is written once and fully awaited BEFORE the stub
-   * that references it is emitted, so a crash mid-write loses both halves
-   * consistently — there is no torn-read window for a subsequent turn.
-   */
-  writeBlob?: (path: string, content: string) => Promise<void>;
-}
-type PersistOutcome = {
-  kind: 'skip';
-  reason: 'disabled' | 'excluded' | 'under-threshold' | 'unsupported-shape' | 'unsafe-call-id' | 'invalid-persist-dir';
-} | {
-  kind: 'persisted';
-  output: string;
-  originalBytes: number;
-  persistedPath: string;
-  evicted?: {
-    files: number;
-    bytes: number;
-  };
-} | {
-  kind: 'error';
-  reason: 'write-failed';
-  error: Error;
-  output: string;
-  originalBytes: number;
-};
-/**
- * Decide-and-persist for a single tool result. Pure decision + filesystem
- * side-effect; returns the new wire-level `output` string when substitution
- * happened, otherwise tells the caller to leave the result alone.
- *
- * Atomicity: the local fallback writes through `<path>.tmp` + `rename` so a
- * concurrent read (or a crash mid-write) never sees a half-written blob. A
- * routed write (`input.writeBlob`, e.g. a sandbox `writeFile`) is not atomic;
- * see the field doc for why that's safe here.
- *
- * Text-only `ToolResultContent[]` results are flattened and persisted as
- * text. Mixed structured content still bypasses persistence because the inline
- * image/document bytes are the point of the call and a mixed result is not
- * representable as a single `.txt` file without dropping media.
- */
-declare function maybePersistToolResult(input: PersistInput): Promise<PersistOutcome>;
-interface BuildStubInput {
-  toolName: string;
-  originalBytes: number;
-  persistedPath: string;
-  output: string;
-  /** Preview cap in bytes. Default {@link PERSISTENCE_PREVIEW_BYTES}. */
-  previewBytes?: number;
-}
-/**
- * Render the byte-stable `<persisted-output>` stub the model sees in place
- * of the original `tool_result`.
- *
- * Format choices:
- *  - XML wrapper because models reliably parse it as structural.
- *  - Byte count + path in attributes so the model can decide whether to
- *    `read_file` the persisted blob without scanning the preview.
- *  - Preview always shows the head — `shell`'s tail-priority truncation is
- *    irrelevant here because the model has the full path if it needs the
- *    tail.
- *  - No timestamps, no random UUIDs inside the stub: every byte must be
- *    reproducible from the inputs, otherwise re-emission on subsequent
- *    turns would bust the prompt cache.
- *
- * Exported for tests (asserting the byte-stable contract) and for SDK
- * consumers wiring their own persistence middleware against the same
- * surface.
- */
-declare function buildPersistedStub(input: BuildStubInput): string;
-/**
- * Remove every persisted blob belonging to a session. Called by the chat
- * layer from its session-delete path so closing a session frees the disk
- * footprint alongside the SQLite row.
- *
- * Idempotent — missing directory (session never persisted anything) is a
- * no-op, not an error. Wraps the `rm -rf` so a permissions blip on one
- * blob doesn't propagate to the caller; the chat layer can't usefully
- * recover from "couldn't unlink a result file" mid-delete.
- */
-declare function cleanupPersistedSession(persistRoot: string): Promise<void>;
-//#endregion
-//#region src/mcp/oauth-provider.d.ts
-/**
- * Per-server persisted state. Subfields are optional so a partial save
- * (e.g. `saveCodeVerifier` arriving before `saveTokens`) doesn't blow away
- * earlier subfields — the provider always patches, never replaces.
- */
-interface McpCredentialEntry {
-  tokens?: OAuthTokens;
-  clientInformation?: OAuthClientInformationMixed;
-  discoveryState?: OAuthDiscoveryState;
-}
-interface McpCredentialStore {
-  load: (name: string) => McpCredentialEntry | undefined;
-  save: (name: string, entry: McpCredentialEntry) => void;
-  delete: (name: string) => void;
-}
-/**
- * In-memory store — primarily for tests, but valid as a no-persistence option
- * (tokens evaporate on process exit, the user re-auths every cold start).
- */
-declare function createMemoryMcpCredentialStore(seed?: Record<string, McpCredentialEntry>): McpCredentialStore;
-interface McpOAuthProviderOptions {
-  /** Server name — used as the storage key. */
-  name: string;
-  /** Persistence backend. */
-  store: McpCredentialStore;
-  /**
-   * Loopback callback URI. Pass `undefined` for bootstrap (non-interactive
-   * mode — stored tokens + refresh only, never opens a browser).
-   */
-  redirectUri?: string;
-  /**
-   * Invoked when the SDK wants the user agent to navigate to the authorization
-   * URL. Typically the host opens the browser AND emits a hook so the TUI can
-   * render the URL in a status row. No-op in non-interactive mode (the SDK
-   * still calls this before throwing `UnauthorizedError` from connect).
-   */
-  onAuthorizationUrl?: (url: URL) => void | Promise<void>;
-  /**
-   * `client_name` used in dynamic client registration. Defaults to `'zidane'`.
-   * Some servers display this string to the user on the consent screen.
-   */
-  clientName?: string;
-  /**
-   * Override the requested OAuth scope. Default: unset (the SDK negotiates
-   * via the server's metadata).
-   */
-  scope?: string;
-}
-declare class McpOAuthProvider implements OAuthClientProvider {
-  private readonly name;
-  private readonly store;
-  private readonly _redirectUri?;
-  private readonly onAuthorizationUrl?;
-  private readonly clientName;
-  private readonly _scope?;
-  private codeVerifierValue;
-  constructor(opts: McpOAuthProviderOptions);
-  get redirectUrl(): string | URL | undefined;
-  get clientMetadata(): OAuthClientMetadata;
-  tokens(): OAuthTokens | undefined;
-  saveTokens(tokens: OAuthTokens): void;
-  clientInformation(): OAuthClientInformationMixed | undefined;
-  saveClientInformation(info: OAuthClientInformationMixed): void;
-  discoveryState(): OAuthDiscoveryState | undefined;
-  saveDiscoveryState(state: OAuthDiscoveryState): void;
-  saveCodeVerifier(verifier: string): void;
-  codeVerifier(): string;
-  redirectToAuthorization(url: URL): Promise<void>;
-  /**
-   * Wipe stored credentials when the server reports the cached state is no
-   * longer valid. The SDK calls this with a scope hint:
-   *   - `'tokens'`  → access/refresh revoked, keep client registration
-   *   - `'client'`  → client registration invalidated, reset everything
-   *   - `'verifier'`→ PKCE state stale (e.g. mismatched state param)
-   *   - `'discovery'` → discovery metadata stale (servers re-keyed)
-   *   - `'all'`     → full reset
-   */
-  invalidateCredentials(scope: 'all' | 'client' | 'tokens' | 'verifier' | 'discovery'): Promise<void>;
-  private patch;
-}
-/**
- * True when an HTTP transport's auth headers already include an explicit
- * Authorization. Used by the bootstrap escape-hatch: a user who provided
- * their own bearer token shouldn't be auto-promoted to OAuth on a 401.
- *
- * Case-insensitive — Node normalizes outgoing headers to lowercase but
- * users hand-write `Authorization` in configs.
- */
-declare function hasAuthorizationHeader(headers: Record<string, string> | undefined): boolean;
-//#endregion
-//#region src/mcp/login.d.ts
-interface LoginMcpServerOptions {
-  /** Persistence — same store the bootstrap path reads from. */
-  store: McpCredentialStore;
-  /**
-   * Invoked with the authorization URL once it's ready. Hosts typically
-   * (a) emit `mcp:auth:url` for the TUI, and (b) call `tryOpenBrowser`.
-   * The URL is identical to the one passed to the `mcp:auth:url` hook
-   * fired automatically — this callback is a synchronous hook for callers
-   * that don't want to wire the agent hook machinery.
-   */
-  onAuthorizationUrl?: (url: URL) => void | Promise<void>;
-  /** Cancels the flow (esc / close modal / SIGINT). */
-  signal?: AbortSignal;
-  /** Agent hooks. The flow emits `mcp:auth:url`/`success`/`error` when wired. */
-  hooks?: Hookable<AgentHooks>;
-  /** Override `client_name` shown on consent screens. Default: 'zidane'. */
-  clientName?: string;
-  /** Override the requested OAuth scope. */
-  scope?: string;
-  /**
-   * Override the loopback callback path. Default: `/callback`. Useful only
-   * for servers that pinned a different path during registration.
-   */
-  callbackPath?: string;
-  /**
-   * Maximum time to wait for the user to complete the browser flow, in ms.
-   * The user can also cancel via `signal`. Default: 5 minutes.
-   */
-  timeoutMs?: number;
-}
-interface LoginMcpServerResult {
-  /** Stored OAuth tokens after a successful exchange. */
-  tokens: NonNullable<ReturnType<McpOAuthProvider['tokens']>>;
-  /**
-   * Upstream tool descriptors discovered after re-connecting with the new
-   * tokens. Already filtered by the server's `enabledTools` / `disabledTools`
-   * is NOT applied here — that's a bootstrap concern. Hosts that want filtering
-   * should pass the result through `connectMcpServers` rebuild on the next
-   * session activation rather than reusing this list verbatim.
-   */
-  tools: Array<{
-    name: string;
-    description?: string | null;
-    inputSchema?: unknown;
-  }>;
-}
-/**
- * Run the full interactive OAuth flow for `config`. Only supports `sse` and
- * `streamable-http` transports — `stdio` MCP servers don't speak OAuth.
- *
- * Throws on:
- *   - Wrong transport.
- *   - Abort signal.
- *   - Browser-side error (user denied, server rejected, etc.).
- *   - Code exchange failure.
- *   - Post-exchange connect failure.
- *
- * Always closes the loopback callback server before returning, success or
- * failure.
- */
-declare function loginMcpServer(config: McpServerConfig, options: LoginMcpServerOptions): Promise<LoginMcpServerResult>;
-//#endregion
-//#region src/mcp/oauth-callback.d.ts
-/**
- * Local loopback HTTP callback for OAuth 2.0 authorization code flows.
- *
- * Stands up a one-shot server on `127.0.0.1:<random>` that captures the
- * `?code=...` redirect from a browser-driven OAuth flow and resolves a
- * promise with the code. Used as the `redirectUrl` half of the MCP SDK's
- * `OAuthClientProvider` (the persistence half lives separately).
- *
- * Design:
- *   - Loopback-only (`127.0.0.1`) — the OAuth spec treats `http://127.0.0.1:<port>`
- *     as a public-client redirect URI per RFC 8252 §7.3. Browsers do NOT block it,
- *     and Anthropic / OpenAI / Linear / GitHub all accept it.
- *   - Random port (`port = 0`) — the OS picks an unused one. We read the actual
- *     port back from `server.address()` after `listen()`.
- *   - Single-shot — the first GET to `path` with a `code` (or `error`) wins;
- *     subsequent requests get 404. The server keeps listening (in case the user
- *     hits "back" and re-authorizes), so callers must `close()` once they have
- *     the code or have given up.
- *   - Abort-aware — wiring an external `AbortSignal` rejects the promise and
- *     closes the server immediately. Required for the TUI's "esc cancels login"
- *     UX.
- *   - No HTML framework — a single inline `<html>` string keeps this isolated
- *     from any UI dependency.
- */
-/**
- * Result of a successful callback. `state` is forwarded verbatim from the
- * query string — callers verify it against their pre-flight value to defend
- * against CSRF (the MCP SDK does this internally when it controls `state`).
- */
-interface OAuthCallbackResult {
-  code: string;
-  state?: string;
-}
-interface OAuthCallbackHandle {
-  /**
-   * Full URI to register with the authorization server, e.g.
-   * `http://127.0.0.1:51823/callback`. Stable for the lifetime of the
-   * handle.
-   */
-  redirectUri: string;
-  /**
-   * Resolves with `{ code, state }` on a successful callback. Rejects with:
-   *   - The OAuth-spec `error` field (`access_denied`, `server_error`, ...)
-   *     when the authorization server redirects with `?error=...`.
-   *   - `'OAuth callback aborted'` when the external `AbortSignal` fires.
-   *   - `'OAuth callback server closed'` when `close()` is called before any
-   *     callback arrives.
-   *
-   * Single-shot — only the first matching request resolves the promise.
-   */
-  promise: Promise<OAuthCallbackResult>;
-  /**
-   * Idempotent shutdown. Safe to call from a `finally` block whether the
-   * flow succeeded, failed, or was aborted. Resolves once the server stops
-   * accepting connections.
-   */
-  close: () => Promise<void>;
-}
-interface OAuthCallbackOptions {
-  /** Cancels the flow — rejects `promise` and closes the server. */
-  signal?: AbortSignal;
-  /**
-   * Path component the authorization server should redirect to. Defaults
-   * to `/callback`. Useful when matching a pre-registered URI that uses a
-   * different path.
-   */
-  path?: string;
-  /**
-   * Override the loopback host. Defaults to `127.0.0.1`. Don't bind to
-   * `0.0.0.0` here — the OAuth code is a one-time secret and the server
-   * would otherwise accept it from any host on the LAN.
-   */
-  host?: string;
-  /**
-   * Override the port. Defaults to `0` (OS-assigned). Pin to a fixed port
-   * only when the authorization server requires a pre-registered redirect
-   * URI; the random-port path is preferred so concurrent flows don't clash.
-   */
-  port?: number;
-}
-/**
- * Start a one-shot OAuth callback server. The returned handle's `redirectUri`
- * should be passed to the authorization server as the `redirect_uri` query
- * parameter; `promise` resolves once the user finishes the browser flow.
- *
- * Always `await handle.close()` in a `finally` block — even on success, the
- * server stays open until told to shut down (so it can serve the
- * "you can close this tab" page).
- */
-declare function startOAuthCallback(opts?: OAuthCallbackOptions): Promise<OAuthCallbackHandle>;
-//#endregion
-//#region src/metrics.d.ts
-type MetricAttributes = Record<string, string | number | boolean | undefined>;
-interface Counter {
-  add: (value: number, attributes?: MetricAttributes) => void;
-}
-interface Histogram {
-  record: (value: number, attributes?: MetricAttributes) => void;
-}
-interface UpDownCounter {
-  add: (value: number, attributes?: MetricAttributes) => void;
-}
-interface InstrumentOptions {
-  description?: string;
-  unit?: string;
-}
-/**
- * Minimal Meter interface — structurally identical to OTel's `Meter`.
- * Hosts passing `metrics.getMeter(name)` (from `@opentelemetry/api`)
- * satisfy this without adaptation.
- */
-interface Meter {
-  createCounter: (name: string, options?: InstrumentOptions) => Counter;
-  createHistogram: (name: string, options?: InstrumentOptions) => Histogram;
-  createUpDownCounter: (name: string, options?: InstrumentOptions) => UpDownCounter;
-}
-interface MetricsHooksOptions {
-  meter: Meter;
-  /**
-   * Optional prefix prepended to every instrument name. Default: no prefix
-   * (instrument names follow OTel Gen AI semantic conventions verbatim,
-   * which is the most-portable shape). Set to e.g. `'zidane.'` to
-   * namespace inside a shared meter registry.
-   */
-  namespace?: string;
-  /**
-   * Optional baseline attributes applied to every measurement. Typical
-   * use: `{ service: 'tui', env: 'prod' }`. Per-event attributes win on
-   * key collision.
-   */
-  baseAttributes?: MetricAttributes;
-  /**
-   * Error sink for meter failures. The helper still swallows the throw
-   * so a broken backend can't crash a run; this callback surfaces the
-   * failure for ops dashboards.
-   */
-  onError?: (kind: string, err: unknown) => void;
-}
-interface MetricsHookSet {
-  install: (hooks: Hookable<AgentHooks>) => () => void;
-}
-/**
- * Build a set of metrics hook handlers that can be installed on an agent.
- *
- * @example OpenTelemetry
- * ```ts
- * import { metrics } from '@opentelemetry/api'
- * const meter = metrics.getMeter('zidane')
- * const m = createMetricsHooks({ meter, baseAttributes: { service: 'tui' } })
- * const uninstall = m.install(agent.hooks)
- * try { await agent.run({ prompt }) }
- * finally { uninstall() }
- * ```
- */
-declare function createMetricsHooks(options: MetricsHooksOptions): MetricsHookSet;
-//#endregion
-//#region src/mutation-validation.d.ts
-type MaybePromise<T> = T | Promise<T>;
-type SuccessfulMutationOutcome = Extract<ToolOutcome, 'created' | 'updated' | 'edited'>;
-interface MutationValidationMutation {
-  turnId: string;
-  callId: string;
-  tool: string;
-  displayName: string;
-  input: Record<string, unknown>;
-  outcome: SuccessfulMutationOutcome;
-  result: string | ToolResultContent[];
-}
-interface MutationValidationBatch {
-  turnId: string;
-  mutations: readonly MutationValidationMutation[];
-}
-type MutationValidationResult = {
-  ok: true;
-} | {
-  ok: false;
-  message?: string;
-  errors?: readonly string[];
-};
-interface MutationValidationFailure {
-  batch: MutationValidationBatch;
-  result: Extract<MutationValidationResult, {
-    ok: false;
-  }>;
-  message: string;
-  failureCount: number;
-}
-interface MutationValidationHooksOptions {
-  validate: (batch: MutationValidationBatch) => MaybePromise<MutationValidationResult | void>;
-  /**
-   * Called when validation fails and the run has not crossed
-   * `maxFailuresPerRun`. Hosts typically call `agent.followUp(message)` here.
-   */
-  onFailure?: (failure: MutationValidationFailure) => MaybePromise<void>;
-  buildFailureMessage?: (failure: Omit<MutationValidationFailure, 'message'>) => string;
-  onError?: (error: unknown, batch: MutationValidationBatch) => MaybePromise<void>;
-  maxFailuresPerRun?: number;
-}
-/**
- * Build host-side hooks for post-mutation validation without changing the
- * built-in edit/write tools. The helper only observes successful mutations
- * reported through `tool:after.outcome`; validation commands and recovery
- * prompts remain host policy.
- */
-declare function createMutationValidationHooks(options: MutationValidationHooksOptions): AgentHookMap;
-//#endregion
-//#region src/stats.d.ts
-/**
- * Per-model usage rollup produced by {@link statsByModel}.
- *
- * `turns` counts the number of `TurnUsage` entries attributed to the model
- * across the whole tree (parent loop + every recursively-spawned child).
- * Cache and cost numbers are summed from the same set of turns.
- */
-interface ModelUsage {
-  input: number;
-  output: number;
-  cost: number;
-  cacheRead: number;
-  cacheCreation: number;
-  turns: number;
-}
-/**
- * Depth-first walk over the stats tree, returning every `TurnUsage` entry
- * — parent loop first, then each child subtree in completion order.
- *
- * Closes the cache-token aggregation gap: `TurnUsage.cacheRead` /
- * `cacheCreation` live only on per-turn entries, and the top-level
- * `AgentStats` deliberately doesn't carry cumulative forms (one source of
- * truth, no risk of drift). Anything that needs a tree-wide sum walks
- * through this.
- */
-declare function flattenTurns(stats: AgentStats): TurnUsage[];
-/**
- * Group cumulative usage by `TurnUsage.modelId`. Each entry sums the input,
- * output, cache, cost, and turn-count across every turn the tree attributed
- * to that model — naturally handling cross-model runs (vision-fallback,
- * model-shifted subagents, mixed-provider workflows).
- *
- * Turns missing `modelId` (mock providers, providers that don't echo a model
- * id) are bucketed under the literal string `'(unknown)'`.
- */
-declare function statsByModel(stats: AgentStats): Map<string, ModelUsage>;
-//#endregion
-//#region src/tracing.d.ts
-/** Minimal span shape — any tracer that provides these methods is compatible. */
-interface Span {
-  /** Close the span. Called exactly once per span. */
-  end: () => void;
-  /** Optional: attach additional attributes after the span is started (ignored if unsupported). */
-  setAttributes?: (attrs: Record<string, unknown>) => void;
-  /**
-   * Optional: record a structured event on the span. Used for non-span
-   * occurrences (gate blocks, validation rejects, budget hits, pairing
-   * repairs). Maps to OTel's `Span.addEvent` and Sentry's `addBreadcrumb`.
-   * Tracers without an event surface should treat this as a no-op (the
-   * helper falls back to `setAttributes` with an `event.*` key prefix).
-   */
-  addEvent?: (name: string, attrs?: Record<string, unknown>) => void;
-}
-/**
- * Function that opens a span. Caller-provided so we stay tracer-agnostic.
- *
- * `parentContext` carries opaque trace metadata propagated from another
- * agent (typically a W3C `{ traceparent, tracestate }` carrier received on
- * `agent:start.tracingContext` after a parent agent's tracer injected it on
- * `spawn:before`). Implementations that integrate with OTel should extract
- * the carrier into a `Context` and use it as the parent when opening the
- * span; implementations that don't care about cross-agent linkage can
- * ignore the third argument entirely.
- */
-type StartSpan = (name: string, attrs?: Record<string, unknown>, parentContext?: Readonly<Record<string, string>>) => Span;
-type TracingConventions = 'sentry' | 'otel' | 'both';
-interface TracingHooksOptions {
-  /** Tracer seam. Receives a span name + attributes; must return a `Span`. */
-  startSpan: StartSpan;
-  /**
-   * Optional attribute namespace. Prepended to every span name with a `/`
-   * separator (e.g. `"agent"` → `agent/chat <model>`, `agent/execute_tool Bash`).
-   *
-   * Empty / undefined = no prefix.
-   */
-  namespace?: string;
-  /**
-   * Which Gen-AI attribute conventions to emit.
-   *
-   * - `'sentry'` (default) — Sentry AI Agents conventions. Most common
-   *   choice — Sentry, Datadog AI, Honeycomb derived dashboards and
-   *   Langfuse all consume these.
-   * - `'otel'` — vendor-neutral OpenTelemetry Gen AI semconv v1.36.
-   *   Diverges from Sentry on cache-token keys, cost keys, and TTFT unit.
-   * - `'both'` — emit every variant. Doubles the per-span attribute
-   *   payload; pick when shipping to multiple backends with different
-   *   ingestion conventions.
-   */
-  conventions?: TracingConventions;
-  /**
-   * Capture the actual prompt / completion text on spans
-   * (`gen_ai.input.messages`, `gen_ai.output.messages`,
-   * `gen_ai.system_instructions`, `gen_ai.tool.definitions`,
-   * `gen_ai.tool.call.arguments`, `gen_ai.tool.call.result`).
-   *
-   * Defaults to `true` (required for the Sentry AI Agents conversation
-   * viewer). Full prompts and tool arguments can carry secrets and PII;
-   * captured content flows through `redact`, so pair the default with a
-   * redactor when payloads may hold secrets, or set `false` to keep all
-   * content-shaped data in-process.
-   */
-  captureMessageContent?: boolean;
-  /**
-   * Emit legacy attribute keys (`inputTokens`, `outputTokens`, `toolName`,
-   * `displayName`, `finishReason`, `modelId`) alongside the new
-   * `gen_ai.*` semconv keys. Defaults to `true` so existing dashboards
-   * keep working. Set `false` once you've migrated all consumers off the
-   * legacy names.
-   */
-  legacyAttributes?: boolean;
-  /**
-   * Error sink for tracer failures. Replaces the historic silent-swallow.
-   * Called when `Span.end()`, `setAttributes()`, `addEvent()`, or
-   * `startSpan()` throws — so degraded tracers stay visible. The helper
-   * still does not let tracer errors propagate into the agent loop.
-   *
-   * `kind` identifies which step failed (`'startSpan'`, `'end'`,
-   * `'setAttributes'`, `'addEvent'`, `'redact'`, `'getActiveTraceContext'`).
-   * Default: no-op (silent).
-   */
-  onError?: (kind: string, err: unknown) => void;
-  /**
-   * Optional callback the helper invokes on `spawn:before` (after opening
-   * the spawn span) to read the active trace context. Whatever it returns
-   * is written into `ctx.tracingContext` and forwarded to the child's
-   * `agent.run({ tracingContext })`. Typical use:
-   *
-   * ```ts
-   * getActiveTraceContext: () => {
-   *   const carrier: Record<string, string> = {}
-   *   propagation.inject(context.active(), carrier)
-   *   return carrier
-   * }
-   * ```
-   *
-   * Returning `undefined` or an empty object leaves the carrier empty
-   * and the child runs with no parent context. The helper's own
-   * `propagator` is preferred over this when both are set (the
-   * propagator runs inside the helper; this callback is the escape
-   * hatch for hosts wanting full control).
-   */
-  getActiveTraceContext?: () => Readonly<Record<string, string>> | undefined;
-  /**
-   * Optional in-process span redactor. When set, every potentially
-   * sensitive string (tool input, tool result, system prompt) flows
-   * through this fn before landing on a span attribute / event. Returning
-   * the input unchanged is a no-op.
-   *
-   * Composes with the harness-wide `tracing:redact` hook: if a host has
-   * already registered a hook handler that mutates `ctx.redacted`, the
-   * tracer reuses that pipeline; setting `redact` here registers an extra
-   * step that runs only for the tracer's attributes. The hook is the
-   * canonical path; `redact` is the convenience surface for tracer-only
-   * setups.
-   */
-  redact?: (kind: string, value: string, meta?: Readonly<Record<string, unknown>>) => string;
-}
-/** Value returned by {@link createTracingHooks} — install entrypoint. */
-interface TracingHookSet {
-  /**
-   * Attach every hook handler to the given agent hooks instance.
-   *
-   * @returns an `uninstall` function that detaches every handler and closes any
-   * still-open spans. Safe to call multiple times.
-   */
-  install: (hooks: Hookable<AgentHooks>) => () => void;
-}
-/**
- * Build a set of tracing hook handlers that can be installed on an agent.
- *
- * @example Sentry
- * ```ts
- * const tracing = createTracingHooks({
- *   startSpan: (name, attrs) => Sentry.startInactiveSpan({ name, attributes: attrs }),
- * })
- * const uninstall = tracing.install(agent.hooks)
- * try { await agent.run({ prompt }) }
- * finally { uninstall() }
- * ```
- *
- * @example OpenTelemetry with parent-context propagation
- * ```ts
- * import { trace, context, propagation } from '@opentelemetry/api'
- *
- * const tracer = trace.getTracer('zidane')
- * const tracing = createTracingHooks({
- *   startSpan: (name, attrs, parentCtx) => {
- *     const ctx = parentCtx ? propagation.extract(context.active(), parentCtx) : context.active()
- *     return tracer.startSpan(name, { attributes: attrs }, ctx)
- *   },
- *   getActiveTraceContext: () => {
- *     const carrier: Record<string, string> = {}
- *     propagation.inject(context.active(), carrier)
- *     return carrier
- *   },
- * })
- * ```
- */
-declare function createTracingHooks(options: TracingHooksOptions): TracingHookSet;
-/**
- * OpenTelemetry Gen AI semantic-convention attribute keys used by the
- * built-in tracer. Exported so consumers integrating with raw OTel SDKs
- * (instead of going through `createTracingHooks`) can stay aligned with
- * the names the harness itself emits.
- */
-declare const GEN_AI_ATTRIBUTES: {
-  readonly system: "gen_ai.system";
-  readonly operationName: "gen_ai.operation.name";
-  readonly requestModel: "gen_ai.request.model";
-  readonly responseModel: "gen_ai.response.model";
-  readonly responseFinishReasons: "gen_ai.response.finish_reasons";
-  readonly responseId: "gen_ai.response.id";
-  readonly responseStreaming: "gen_ai.response.streaming";
-  readonly responseTokensPerSecond: "gen_ai.response.tokens_per_second";
-  readonly responseTimeToFirstTokenSeconds: "gen_ai.response.time_to_first_token";
-  readonly responseTimeToFirstTokenMs: "gen_ai.client.time_to_first_token";
-  readonly usageInputTokens: "gen_ai.usage.input_tokens";
-  readonly usageOutputTokens: "gen_ai.usage.output_tokens";
-  readonly usageTotalTokens: "gen_ai.usage.total_tokens";
-  readonly usageInputTokensCached: "gen_ai.usage.input_tokens.cached";
-  readonly usageInputTokensCacheWrite: "gen_ai.usage.input_tokens.cache_write";
-  readonly usageOutputTokensReasoning: "gen_ai.usage.output_tokens.reasoning";
-  readonly usageCacheReadInputTokens: "gen_ai.usage.cache_read_input_tokens";
-  readonly usageCacheCreationInputTokens: "gen_ai.usage.cache_creation_input_tokens";
-  readonly usageReasoningTokens: "gen_ai.usage.reasoning_tokens";
-  readonly costTotalTokens: "gen_ai.cost.total_tokens";
-  readonly costInputTokens: "gen_ai.cost.input_tokens";
-  readonly costOutputTokens: "gen_ai.cost.output_tokens";
-  readonly usageCostUsd: "gen_ai.usage.cost_usd";
-  readonly toolName: "gen_ai.tool.name";
-  readonly toolDescription: "gen_ai.tool.description";
-  readonly toolType: "gen_ai.tool.type";
-  readonly toolCallId: "gen_ai.tool.call.id";
-  readonly toolCallArguments: "gen_ai.tool.call.arguments";
-  readonly toolCallResult: "gen_ai.tool.call.result";
-  readonly toolMessage: "gen_ai.tool.message";
-  readonly toolInputDeprecated: "gen_ai.tool.input";
-  readonly toolOutputDeprecated: "gen_ai.tool.output";
-  readonly requestMaxTokens: "gen_ai.request.max_tokens";
-  readonly requestTemperature: "gen_ai.request.temperature";
-  readonly requestTopP: "gen_ai.request.top_p";
-  readonly requestTopK: "gen_ai.request.top_k";
-  readonly requestSeed: "gen_ai.request.seed";
-  readonly requestFrequencyPenalty: "gen_ai.request.frequency_penalty";
-  readonly requestPresencePenalty: "gen_ai.request.presence_penalty";
-  readonly inputMessages: "gen_ai.input.messages";
-  readonly outputMessages: "gen_ai.output.messages";
-  readonly systemInstructions: "gen_ai.system_instructions";
-  readonly toolDefinitions: "gen_ai.tool.definitions";
-  readonly agentName: "gen_ai.agent.name";
-  readonly agentRunId: "gen_ai.agent.run.id";
-  readonly agentParentRunId: "gen_ai.agent.parent_run.id";
-  readonly agentDepth: "gen_ai.agent.depth";
-  readonly pipelineName: "gen_ai.pipeline.name";
-  readonly turn: "gen_ai.agent.turn";
-  readonly mcpServer: "gen_ai.mcp.server";
-  readonly mcpToolCount: "gen_ai.mcp.tool_count";
-};
-//#endregion
-//#region src/zod.d.ts
-/**
- * Zod v4 integration helper.
- *
- * Normalizes the output of z.toJsonSchema() for use as ToolSpec.inputSchema.
- * Zod is an optional peer dependency — consumers call z.toJsonSchema() themselves.
- *
- * Usage:
- *   import { z } from 'zod'
- *   import { zodToJsonSchema } from 'zidane'
- *   const schema = zodToJsonSchema(z.toJsonSchema(z.object({ name: z.string() })))
- */
-/**
- * Normalize a JSON Schema (e.g. from zod v4's z.toJsonSchema()) for use
- * as a ToolSpec.inputSchema.
- *
- * Strips the $schema key that some providers reject.
- */
-declare function zodToJsonSchema(jsonSchema: Record<string, unknown>): Record<string, unknown>;
-//#endregion
-//#region src/presets/basic.d.ts
-/**
- * Core tools available in every basic preset (without spawn).
- *
- * `edit` and `multi_edit` ship in the basic set because surgical edits are the
- * default modality for production agents — `write_file` is for full overwrites.
- * `glob` and `grep` are exported but opt-in: not every agent needs codebase
- * search, and shipping them by default would force `tool:gate` work onto
- * consumers that prefer the model to use `shell` + classic Unix tools.
- */
-declare const basicTools: {
-  shell: ToolDef;
-  shellKill: ToolDef;
-  waitTask: ToolDef;
-  readFile: ToolDef;
-  writeFile: ToolDef;
-  listFiles: ToolDef;
-  edit: ToolDef;
-  multiEdit: ToolDef;
-};
-declare const _default: Preset;
-//#endregion
-//#region src/presets/index.d.ts
-/**
- * A preset is a reusable slice of `AgentOptions` — spread it into `createAgent()`
- * to configure tools, a default system prompt, aliases, behavior defaults, and
- * agent-lifetime hooks.
- *
- * `provider`, `execution`, `session`, and `mcpConnector` are excluded — they're
- * ambient / per-invocation runtime wiring (a custom `mcpConnector` is the MCP
- * connection seam, often closure-bound to a transport / auth provider), so
- * presets stay shareable and composable.
- *
- * ```ts
- * import { basic } from 'zidane/presets'
- * createAgent({ ...basic, provider })
- * ```
- *
- * ### Composing multiple presets
- *
- * Bare `...spread` is shallow — `{ ...a, ...b }` overwrites every key `b`
- * defines, including `hooks`. Use {@link composePresets} when you want
- * field-aware merging (per-event hook concat, tools shallow-merge, etc.):
- *
- * ```ts
- * createAgent({ ...composePresets(basic, telemetry, mine), provider })
- * ```
- */
-type Preset = Omit<Partial<AgentOptions>, 'provider' | 'execution' | 'session' | 'mcpConnector'>;
-/**
- * Identity helper for type inference when defining a preset.
- */
-declare function definePreset(config: Preset): Preset;
-/**
- * Field-aware composition of presets. Right-most preset wins for scalar fields;
- * objects shallow-merge; arrays and hook handler lists concatenate. Designed so
- * stacking presets does the obvious thing without the spread-collision footgun:
- *
- * - `name`, `system`, `eager`, `skills`              → last-defined wins
- * - `tools`, `toolAliases`, `behavior`               → shallow-merge (later keys override)
- * - `behavior.dedupTools`, `behavior.toolBudgets`    → **deep-merge** (per-tool-name; later wins on collision)
- * - `mcpServers`                                     → concat with last-wins on `name` collision
- * - `hooks`                                          → per-event concat; every handler fires
- *
- * `hooks` always emerges as `event → handler[]` so downstream registration
- * (in `createAgent`) sees a uniform shape. Order of handlers within an event
- * follows preset order: earlier presets register first.
- *
- * `mcpServers` is deduped by `name` because shipping two servers with the same
- * name would trip the connector at runtime — a later preset overriding an
- * earlier preset's `github` server is the practical intent.
- *
- * `behavior.dedupTools` and `behavior.toolBudgets` get the same per-key deep-merge
- * because they are tool-name-keyed records — a preset that ships a dedup hasher
- * for one tool should not erase a hasher another preset ships for a different
- * tool. Last-wins still applies on a per-tool collision so a downstream preset
- * can override an upstream preset's policy for one specific tool. Other
- * `behavior` fields keep last-wins semantics.
- */
-declare function composePresets(...presets: Preset[]): Preset;
-//#endregion
-export { resolvePersistDir as $, SpawnToolState as $n, anchorPreviewFor as $r, createReusableExecutionContext as $t, MetricsHooksOptions as A, ProviderTranscriptFormat as An, selectRecentFiles as Ar, EvalVariantSummary as At, McpCredentialEntry as B, transcriptToProviderMessages as Bn, CompactPromptBuilder as Br, RegisterEvalTestsOptions as Bt, createMutationValidationHooks as C, HeadlessOptions as Cn, utf8ByteLength as Cr, EvalRunSummary as Ct, Meter as D, HeadlessUsage as Dn, buildPostCompactAttachments as Dr, EvalScorer as Dt, InstrumentOptions as E, HeadlessStatus as En, RecentFile as Er, EvalScore as Et, OAuthCallbackResult as F, headlessEventToJsonl as Fn, compactConversation as Fr, MetricDirection as Ft, hasAuthorizationHeader as G, validateToolArgs as Gn, buildFromCompactPrompt as Gr, artifactPath as Gt, McpOAuthProvider as H, WAIT_TASK_TIMED_OUT_PREFIX as Hn, NO_TOOLS_PREAMBLE as Hr, Trajectory as Ht, startOAuthCallback as I, installHeadlessEventAdapter as In, CompactInvalidInputError as Ir, MetricEmitter as It, PersistInput as J, LazyToolEntry as Jn, buildUpToCompactPrompt as Jr, buildTrajectory as Jt, PERSISTED_STUB_PREFIX as K, TailTruncateOptions as Kn, buildFullCompactPrompt as Kr, buildEvalRunSummary as Kt, LoginMcpServerOptions as L, providerTranscriptFormatForProvider as Ln, CompactPromptTooLongError as Lr, MetricSpec as Lt, createMetricsHooks as M, formatHeadlessResult as Mn, CompactOptions as Mr, EvalWorkspaceOptions as Mt, OAuthCallbackHandle as N, formatHeadlessTurnEvent as Nn, CompactResult as Nr, EvalWorkspaceSnapshot as Nt, MetricAttributes as O, OpenAIChatContentPart as On, selectFilesFromReadState as Or, EvalScorerContext as Ot, OAuthCallbackOptions as P, formattedHeadlessTurnEventToJsonl as Pn, CompactStartEvent as Pr, LlmJudgeOptions as Pt, maybePersistToolResult as Q, SpawnToolOptions as Qn, SummaryToTurnInput as Qr, createEvalRunReporter as Qt, LoginMcpServerResult as R, runHeadless as Rn, BASE_INSTRUCTIONS as Rr, MetricSpecMap as Rt, SuccessfulMutationOutcome as S, HeadlessEvent as Sn, estimateTokens as Sr, EvalRunReporterOptions as St, Histogram as T, HeadlessResult as Tn, PostCompactRestoreOptions as Tr, EvalRunUsage as Tt, McpOAuthProviderOptions as U, waitTask as Un, TRAILER as Ur, TrajectoryStep as Ut, McpCredentialStore as V, writeFile as Vn, CompactPromptOptions as Vr, ReusableExecutionContext as Vt, createMemoryMcpCredentialStore as W, ValidationResult as Wn, buildCompactPrompt as Wr, TrajectoryStepKind as Wt, buildPersistedStub as X, createToolSearchTool as Xn, CompactScope as Xr, computeEvalTagScores as Xt, PersistOutcome as Y, ToolSearchToolOptions as Yn, ANCHOR_PREVIEW_MAX_CHARS as Yr, clearRegisteredEvals as Yt, cleanupPersistedSession as Z, ChildAgent as Zn, CompactionSlice as Zr, createEvalAgent as Zt, MutationValidationBatch as _, runEvalCase as _n, createInteractionTool as _r, EvalDefinitionContext as _t, basicTools as a, defaultRepeatGuardTracked as ai, fileContentQuality as an, SkillsRunScriptToolOptions as ar, CreateEvalAgentOptions as at, MutationValidationMutation as b, FormattedHeadlessTurnEvent as bn, edit as br, EvalRunMetricAggregate as bt, Span as c, localReliabilityBehavior as ci, finalizeEvalMetrics as cn, createSkillsReadTool as cr, EvalAgentMcpServers as ct, TracingHookSet as d, formatTrajectoryLine as dn, createShellTool as dr, EvalAgentRunStats as dt, sliceForCompaction as ei, defineEval as en, SubagentDef as er, resolveTasksDir as et, TracingHooksOptions as f, functionalityMetric as fn, shell as fr, EvalAgentStats as ft, statsByModel as g, relativeArtifactPath as gn, InteractionToolOptions as gr, EvalDefinition as gt, flattenTurns as h, registerEvalTests as hn, listFiles as hr, EvalCaseResult as ht, _default as i, defaultRepeatGuardNormalize as ii, fileContains as in, createSkillsUseTool as ir, TOOL_USE_SKIPPED_MESSAGE as it, UpDownCounter as j, exitCodeForHeadlessResult as jn, CompactEndEvent as jr, EvalWorkspaceFile as jt, MetricsHookSet as k, OpenAIChatMessage as kn, selectFilesFromSession as kr, EvalTestRunner as kt, StartSpan as l, formatEvalCaseSummary as ln, shellKill as lr, EvalAgentRunOptions as lt, ModelUsage as m, normalizeMetric as mn, multiEdit as mr, EvalCaseOptions as mt, composePresets as n, summaryToTurn as ni, efficiencyMetricValues as nn, createSpawnTool as nr, SHELL_CASCADE_CANCEL_MESSAGE as nt, zodToJsonSchema as o, normalizeShellCommand as oi, fileExists as on, createSkillsRunScriptTool as or, EFFICIENCY_METRICS as ot, createTracingHooks as p, llmJudge as pn, readFile as pr, EvalArtifacts as pt, PERSISTENCE_PREVIEW_BYTES as q, tailTruncate as qn, buildTailCompactPrompt as qr, buildRegisteredEvals as qt, definePreset as r, truncateHeadForPtlRetry as ri, emitEfficiencyMetrics as rn, SkillsUseToolOptions as rr, TOOL_USE_CANCELLED_MESSAGE as rt, GEN_AI_ATTRIBUTES as s, stableStringify as si, fileExistsOneOf as sn, SkillsReadToolOptions as sr, EvalAgent as st, Preset as t, stripImagesFromTurns as ti, defineMetrics as tn, SubagentRegistry as tr, INTERRUPT_MESSAGE_FOR_TOOL_USE as tt, TracingConventions as u, formatEvalRunSummary as un, CreateShellToolOptions as ur, EvalAgentRunResult as ut, MutationValidationFailure as v, statusCompleted as vn, grep as vr, EvalMetric as vt, Counter as w, HeadlessOutputFormat as wn, PostCompactAttachments as wr, EvalRunSummaryCase as wt, MutationValidationResult as x, HeadlessErrorInfo as xn, BYTES_PER_TOKEN as xr, EvalRunReporter as xt, MutationValidationHooksOptions as y, FormattedHeadlessResult as yn, glob as yr, EvalMetricError as yt, loginMcpServer as z, transcriptToOpenAIMessages as zn, CompactDirection as zr, MetricStats as zt };
-//# sourceMappingURL=index-BtzE3Uaq.d.ts.map