zidane 7.2.4 → 8.0.4

package/dist/turn-operations-C8bMBDl_.d.ts

@@ -1,1258 +0,0 @@
-import { Bv as SkillConfig, Dd as EditOutcome, Jm as CacheBreakInfo, Ld as StreamEvent, Md as Owner, Qu as CompletionReference, U_ as SessionTurn, Zu as CompletionProvider, dv as TurnUsage, kd as EditPayload, nv as ToolResultContent, od as Command, qv as Session, t as Preset } from "./index-BgN1T3lk.js";
-import { V as ApprovalDecision } from "./tool-formatters-DoRLnfuD.js";
-
-//#region src/chat/color-gradient.d.ts
-/**
- * Blend two hex colors in HSL space with shortest-path hue interpolation.
- * `t` ∈ [0, 1]; `t=0` returns `from`, `t=1` returns `to`.
- */
-declare function blendHsl(from: string, to: string, t: number): string;
-/**
- * Static gradient ramp of length `n` going from `from` (index 0) to
- * `to` (index n-1) in HSL space. For the cycling A→B→A→B ramp the
- * throbber uses, see `buildCycleRamp` in `src/tui/crush-throbber.tsx`.
- */
-declare function buildLinearRamp(from: string, to: string, n: number): string[];
-//#endregion
-//#region src/chat/completion-chats.d.ts
-declare const CHATS_TRIGGER = "#";
-type ChatReferenceScope = 'project' | 'all';
-interface ChatReferenceEntry {
-  id: string;
-  title: string;
-  turnCount: number;
-  userMessageCount: number;
-  runCount: number;
-  projectRoot?: string;
-  updatedAt: number;
-  /** Optional (store-dependent); shown as a hint when > 0. */
-  artifactCount?: number;
-}
-interface ChatReferenceData {
-  entry: ChatReferenceEntry;
-  token: string;
-}
-declare function createChatsCompletionProvider(opts: {
-  getCatalog: () => readonly ChatReferenceEntry[];
-  getReferenceCatalog?: () => readonly ChatReferenceEntry[];
-  getScope?: () => ChatReferenceScope;
-  ensureCatalog?: () => Promise<readonly ChatReferenceEntry[]>;
-  limit?: number;
-}): CompletionProvider<ChatReferenceData>;
-declare function uniqueChatIdsFromReferences(references: readonly CompletionReference<unknown>[]): string[];
-declare function chatReferenceTokensFromText(text: string): string[];
-//#endregion
-//#region src/chat/completion-commands.d.ts
-/** Trigger character — shared with skills. */
-declare const COMMANDS_TRIGGER = "/";
-/**
- * Build a commands completion provider against a *live* command list. The
- * getter is re-evaluated per `suggest` so registry toggles / cwd rebuilds
- * take effect without re-instantiating the provider.
- */
-declare function createCommandsCompletionProvider(opts: {
-  getCommands: () => readonly Command[];
-}): CompletionProvider<Command>;
-//#endregion
-//#region src/chat/files-discovery.d.ts
-/**
- * Project file discovery for the `@`-prefixed files completion provider.
- *
- * Primary strategy — `git ls-files --cached --others --exclude-standard`.
- * Git already understands `.gitignore`, `.git/info/exclude`, and global
- * excludes, so we get correctness for free + sub-second performance on
- * even huge monorepos. Falls back to a depth-limited filesystem walk when
- * git isn't available or the directory isn't a repo.
- *
- * Pure: callers cache the returned list (e.g. in App state) and pass it
- * into the provider's `getCatalog`. The list is a snapshot — refresh on
- * cwd change or via a user-driven action.
- */
-/** One row in the project file catalog. `path` is forward-slashed + relative to `cwd`. */
-interface FileEntry {
-  /** Forward-slashed relative path from the discovery cwd. Stable across OSes. No trailing slash for dirs. */
-  path: string;
-  /** Basename — used for prefix ranking in the completion provider. */
-  name: string;
-  /** Source — `git` when listed via `git ls-files`, `fs` from the walk fallback. */
-  source: 'git' | 'fs';
-  /**
-   * Entry kind. Directories are derived from the discovered file paths
-   * (every ancestor of a listed file), so only directories that contain
-   * at least one non-ignored file appear — mirroring `git ls-files`
-   * semantics, which never lists empty or fully-ignored dirs.
-   */
-  kind: 'file' | 'dir';
-}
-/** Options for `listProjectFiles`. */
-interface ListProjectFilesOptions {
-  /** Discovery root. Default: `process.cwd()`. */
-  cwd?: string;
-  /**
-   * Cap on discovered files. Default: 10,000. Bigger lists fall back to
-   * a truncated set. Derived directory entries are appended on top with
-   * their own equal cap, so the returned array can exceed `maxFiles`
-   * (bounded by 2×).
-   */
-  maxFiles?: number;
-  /** Aborts the scan early. Useful when re-running on rapid project switches. */
-  signal?: AbortSignal;
-}
-/**
- * Discover every non-ignored file under `cwd`, plus the directories that
- * contain them (derived from the file paths, `kind: 'dir'`). Tries
- * `git ls-files` first; on failure (no git, not a repo, abort) walks the
- * fs with a hand-rolled skip list.
- *
- * Errors are not thrown — the function always returns an array (possibly
- * empty). Callers wanting failure diagnostics can opt into them via
- * `ZIDANE_DEBUG`.
- */
-declare function listProjectFiles(opts?: ListProjectFilesOptions): Promise<FileEntry[]>;
-//#endregion
-//#region src/chat/completion-files.d.ts
-/** Trigger character — `@` is the conventional file-mention prefix in chat UIs. */
-declare const FILES_TRIGGER = "@";
-/**
- * Build an `@`-prefixed files completion provider against a *live* catalog.
- *
- * The factory captures a getter so the catalog can be re-scanned (cwd
- * change, manual refresh) without re-instantiating the provider — the
- * App keeps one provider for the lifetime of the prompt block and just
- * mutates the underlying state.
- *
- * `limit` caps the result list so the popover stays bounded on huge
- * monorepos. Filtering is substring on `path` + `name`, case-insensitive,
- * with an fzf-scored basename fuzzy fallback so small typos / omissions
- * (`lop.ts` → `loop.ts`) still surface results; ranking prefers (in
- * order): exact name match, name prefix, name substring, path substring,
- * basename fuzzy match, alphabetical.
- */
-declare function createFilesCompletionProvider(opts: {
-  /** Live file catalog. Re-evaluated per call so refreshes take effect immediately. */getCatalog: () => readonly FileEntry[];
-  /**
-   * Optional hook called the first time the host needs the catalog —
-   * e.g. when the user opens the `@` popover. Hosts wire this to a
-   * lazy directory walk so boot doesn't pay for it in monorepos
-   * where the popover may never open. Idempotent contract: callers
-   * may invoke it on every `suggest`; the host caches internally.
-   *
-   * When provided, `suggest()` returns a Promise on the very first
-   * invocation if the catalog is still empty — the popover's loading
-   * state surfaces while the walk completes; subsequent calls are
-   * sync because `getCatalog()` then returns the populated state.
-   */
-  ensureCatalog?: () => Promise<readonly FileEntry[]>; /** Max items returned to the popover. Default: 50. */
-  limit?: number;
-  /**
-   * Rewrite the catalog's project-root-relative path into the form
-   * inserted into the prompt + matched by `parseReferences`. Wire this
-   * to `formatPathForCwd` so paths emitted into the buffer line up
-   * with the agent's CWD-resolving tools when the TUI launches from a
-   * project subdirectory. Default: identity.
-   *
-   * Stable identity expected — `parseReferences` calls it once per
-   * catalog entry per keystroke for the highlight pass; pure
-   * pure-function shape keeps the popover responsive on huge repos.
-   */
-  formatPath?: (entry: FileEntry) => string;
-}): CompletionProvider<FileEntry>;
-/**
- * Walk a reference list and return the deduplicated set of files in
- * first-mention order — input to "attach these files to the prompt"
- * downstream logic.
- */
-declare function uniqueFilesFromReferences(references: readonly CompletionReference<unknown>[]): FileEntry[];
-//#endregion
-//#region src/chat/completion-skills.d.ts
-/** Trigger character — slash-commands convention. */
-declare const SKILLS_TRIGGER = "/";
-/**
- * Build a slash-command completion provider against a *live* skills
- * catalog. The factory captures a getter so the catalog can change across
- * renders (toggles, reload) without re-instantiating the provider.
- *
- * Pass `getEnabled` to additionally hide skills the user has toggled off
- * — when undefined, every catalog entry is offered.
- */
-declare function createSkillsCompletionProvider(opts: {
-  /** Live catalog. Re-evaluated per call so toggles take effect immediately. */getCatalog: () => readonly SkillConfig[]; /** Optional enable-set filter; when undefined every catalog skill is offered. */
-  getEnabled?: () => readonly string[] | undefined;
-  /**
-   * Optional hook called the first time the host needs the catalog —
-   * typically when the user opens the `/` popover. Mirror of the
-   * files provider's `ensureCatalog`; same idempotent contract.
-   *
-   * Hosts wire this to a lazy SKILL.md scan so the boot path stays
-   * free of disk reads in deeply-nested skill trees. Returns a Promise
-   * on the very first `suggest()` call when the catalog is still
-   * empty so the popover surfaces its loading state.
-   */
-  ensureCatalog?: () => Promise<readonly SkillConfig[]>;
-}): CompletionProvider<SkillConfig>;
-/**
- * Walk a parsed prompt for skill references and return the deduplicated
- * list of skill names — input to `agent.activateSkill(name)` calls on
- * submit.
- */
-declare function uniqueSkillNamesFromReferences(references: readonly CompletionReference<unknown>[]): string[];
-//#endregion
-//#region src/chat/edit-approval.d.ts
-/**
- * Convert a per-hunk approval mask into an `EditOutcome[]`. `true` →
- * `applied`; `false` → `denied` with the supplied reason.
- *
- * Length is `Math.max(mask.length, fallbackLength)` so callers passing a
- * shorter mask still get a fully-populated array — missing entries
- * default to applied, matching the "no decision => keep" convention.
- */
-declare function maskToOutcomeKinds(mask: readonly boolean[], fallbackLength: number, deniedReason?: string): EditOutcome[];
-/**
- * Apply an `ApprovalDecision` to a payload, returning the resolved
- * per-hunk outcomes + the gate-level verdict.
- *
- * Pure — does not mutate `input` or `payload`. The TUI's `applyGate`
- * consumes the result: stashes `outcomes` in the pending-annotation map
- * (keyed by callId) so `tool:transform` can append the
- * `<edit-outcomes>` block to the tool result, rebinds `ctx.input.edits`
- * to the approved subset for `partial`, and emits the `syntheticEvent`
- * for fully-denied or fully-blocked calls.
- */
-interface ResolvedApproval {
-  /** Final state of every hunk after the decision (1:1 with payload.hunks). */
-  outcomes: EditOutcome[];
-  /** True when no hunk will be applied — gate should `block` the call. */
-  shouldBlock: boolean;
-  /**
-   * Synthetic `EditPayload` to render in the transcript. Identical to the
-   * incoming payload but with `outcomes` set so the renderer can badge
-   * each hunk. Only meaningful when at least one hunk was denied —
-   * an all-applied decision returns `null` here and the normal
-   * `tool:before` event suffices.
-   */
-  syntheticEvent: EditPayload | null;
-}
-declare function resolveApprovalForPayload(decision: ApprovalDecision, payload: EditPayload): ResolvedApproval;
-/**
- * Render an `EditOutcome[]` as the wire-format annotation block. Returns
- * the body to APPEND to a tool result; callers join with a leading
- * `\n\n` separator. Idempotent on missing reasons — bare `applied` lines
- * stay terse.
- */
-declare function buildEditOutcomesAnnotation(outcomes: readonly EditOutcome[]): string;
-/**
- * Parse an `<edit-outcomes>…</edit-outcomes>` annotation block out of a
- * tool result body. Returns the outcomes keyed by 1-based hunk index, or
- * `null` when the block is missing / malformed.
- *
- * Anchored on the explicit tag pair so the parser doesn't false-positive
- * on natural prose that happens to contain `#1 applied`.
- */
-declare function parseEditOutcomesFromResult(result: string | readonly ToolResultContent[]): EditOutcome[] | null;
-/**
- * Strip the first `<edit-outcomes>…</edit-outcomes>` block out of a tool
- * result body, returning the surrounding text. Used by the
- * `tool:transform` hook to peel a body-emitted annotation before
- * re-appending the merged (approval ∪ body) version — otherwise the
- * result would carry two annotation blocks and
- * {@link parseEditOutcomesFromResult} would only see the first.
- *
- * Anchored on the same `\n<edit-outcomes>\n` / start-of-string newline
- * shape the parser uses, so prose that incidentally mentions
- * `<edit-outcomes>` (e.g. a model summarizing its own format) isn't
- * mistakenly stripped. Trims a single leading `\n\n` separator when
- * present so successive strips don't leave dangling blank lines.
- * Idempotent on inputs that don't contain a properly-anchored block.
- */
-declare function stripEditOutcomesAnnotation(text: string): string;
-/**
- * Merge body-side outcomes (keyed against the approved subset the tool
- * actually ran on, in subset-position order) into approval-side outcomes
- * (1:1 with the model's ORIGINAL `edits` list, with `denied` entries for
- * every hunk the user dropped).
- *
- * Algorithm: walk the approval array; every `applied` placeholder
- * corresponds to one approved hunk that the body ran. Consume body's
- * outcomes in order against those placeholders. Non-`applied` approval
- * entries (`denied`, `skipped`) stay untouched — they describe gate-
- * level decisions the body never saw.
- *
- * Pure. Returns a fresh array; never mutates either input.
- *
- * Edge cases:
- *  - `body` is empty / shorter than the approved count → remaining
- *    approval `applied` placeholders stay as `applied` (the body ran
- *    happily; absence of a body entry means nothing failed).
- *  - `body` longer than approved count → trailing body entries are
- *    ignored. Shouldn't happen in practice (body sees the rebound
- *    subset), but the guard keeps the merge total-pure.
- */
-declare function mergeApprovalAndBodyOutcomes(approval: readonly EditOutcome[], body: readonly EditOutcome[] | null): EditOutcome[];
-/**
- * Rewrite a `multi_edit` body header so the totals reflect the model's
- * ORIGINAL edit list (the merged outcomes count) instead of the subset
- * the body actually saw after gate rebinding. Without this, a partially
- * approved call surfaces a misleading `applied 2 of 2 edits` (subset
- * counts) on the wire even when the original was `applied 2 of 3`.
- *
- * Three body-side shapes are handled (matching `multi_edit`'s emit):
- *   1. `Edited <path>: applied N edits (R replacements).`
- *   2. `Edited <path>: applied N of M edits (R replacements).`
- *   3. `multi_edit error: no edits applied to <path> (M attempted).`
- *
- * The replacements count is preserved verbatim — it's a body-side stat
- * the chat layer can't recompute. When the first line doesn't look like
- * any of the three shapes (e.g. an unrelated error preamble bubbled up),
- * the text is returned unchanged.
- */
-declare function rewriteMultiEditHeader(text: string, merged: readonly EditOutcome[], path: string): string;
-/**
- * Aggregate counts for the transcript's summary badge (`3 applied · 1
- * denied · 1 skipped`). Exported so renderers don't reimplement the
- * tally. Pure / O(n).
- */
-declare function summarizeOutcomes(outcomes: readonly EditOutcome[] | undefined): {
-  applied: number;
-  denied: number;
-  skipped: number;
-  failed: number;
-  pending: number;
-  total: number;
-};
-//#endregion
-//#region src/tools/edit-utils.d.ts
-/**
- * Locate the actual substring in `haystack` that corresponds to `needle`,
- * recovering from typographical mismatch on six escalating fallbacks:
- *
- * 1. Exact substring match (the happy path — no transformation).
- * 2. Curly-quote normalization on both sides — when the model emits straight
- *    quotes but the file has curly ones (or vice versa), the slice of the
- *    file at the matched position carries the file's actual typography.
- * 3. Anthropic-sanitization undo on the needle — the model's `<n>` becomes
- *    the file's `<name>`, etc.
- * 4. Combined: desanitize + quote normalization on the needle.
- * 5. Line-number-prefix strip — when the model pasted a numbered `read_file`
- *    chunk verbatim into `old_string` and the file carries no such prefix.
- * 6. Combined: line-number strip + quote normalization — paste-back of a
- *    numbered chunk against a file whose typography differs from the model's.
- *
- * Returns `{ actual, occurrences }` — `actual` is the string that exists in
- * the file (use this to do the actual replace; preserves the file's
- * typography). `occurrences` is the count of those matches in the file.
- *
- * Fallbacks 3-4 (desanitize-class) only fire when the transformed needle is
- * UNIQUE in the file — they rewrite the needle's meaning rather than its
- * typography, so an ambiguous match risks silently retargeting the wrong
- * text (see the inline comment at step 3).
- *
- * Returns `null` when no recovery worked.
- */
-interface ResolvedMatch {
-  actual: string;
-  occurrences: number;
-  /** Recovery path — `'exact'` when no transformation was applied. */
-  via: 'exact' | 'quotes' | 'desanitize' | 'quotes+desanitize' | 'line-numbers' | 'quotes+line-numbers';
-}
-//#endregion
-//#region src/chat/edit-diff.d.ts
-declare function extractEditPayload(name: string, input: Record<string, unknown>, priorContent?: string): EditPayload | undefined;
-type DiffOp = 'context' | 'add' | 'remove';
-interface DiffLine {
-  op: DiffOp;
-  text: string;
-}
-declare function computeLineDiff(oldString: string, newString: string): DiffLine[];
-/**
- * Split a string into lines preserving empty lines but dropping the
- * implicit trailing `""` produced by a final `\n`. Exported only for
- * its tests — callers should use `computeLineDiff`.
- */
-declare function splitLines(s: string): string[];
-interface InlineSegment {
-  text: string;
-  changed: boolean;
-}
-interface InlineDiff {
-  oldSegments: InlineSegment[];
-  newSegments: InlineSegment[];
-}
-declare function computeInlineDiff(oldLine: string, newLine: string): InlineDiff;
-/**
- * Tokenize on word / non-word boundaries. Each run of `\w+` is one
- * token; each run of `\W+` (whitespace, punctuation) is another. This
- * gives the right granularity for renames (`oldName` → `newName`) and
- * for symbol swaps (`+ → -`) without exploding into per-char segments.
- *
- * Exported only for its tests.
- */
-declare function tokenize(s: string): string[];
-/**
- * Apply the payload's hunks against `priorContent` and return the
- * resulting file body. Mirrors the agent's tool-side semantics:
- *   - `replaceAll === true`  → `String.replaceAll`
- *   - otherwise              → first-occurrence `String.replace`
- *
- * Hunks are applied in order — a `multi_edit` later hunk operates on
- * the output of the earlier ones, just like the actual tool.
- */
-declare function applyEditPayload(payload: EditPayload, priorContent: string): string;
-/**
- * Like `buildUnifiedDiff` but operating against the full file content
- * so the diff carries *real* file line numbers and configurable
- * surrounding context.
- *
- * Strategy:
- *   1. Apply the payload to `priorContent` → `newContent`.
- *   2. Run `computeLineDiff` over the whole file.
- *   3. Group non-context ops into hunks, padding each with up to
- *      `contextLines` of context above and below. Adjacent hunks
- *      whose context regions touch are merged so we don't emit two
- *      `@@` headers separated by zero context lines.
- *
- * The output line numbers in the `@@` header are 1-based and reflect
- * the change's position in the actual file — what the user expects
- * when reading a diff alongside their editor.
- *
- * For `write_file` creating a new file (priorContent === ''), this
- * falls back to the same `--- /dev/null` convention as
- * `buildUnifiedDiff`.
- */
-declare function buildContextualDiff(payload: EditPayload, priorContent: string, contextLines?: number): string;
-interface EditHunkSummary {
-  /** 1-based line number in the new file where the change starts; undefined when unknown (no priorContent). */
-  line?: number;
-  /** Number of lines added in this hunk. */
-  added: number;
-  /** Number of lines removed in this hunk. */
-  removed: number;
-  /** First removed line preview (trimmed, may be empty for pure additions). */
-  firstOld?: string;
-  /** First added line preview (trimmed, may be empty for pure deletions). */
-  firstNew?: string;
-}
-interface EditSummary {
-  totalAdded: number;
-  totalRemoved: number;
-  hunks: EditHunkSummary[];
-}
-/**
- * Build a per-hunk digest used by the compact diff view.
- *
- * Strategy:
- *  - When `priorContent` is present and the payload describes a real
- *    file transformation, compute the contextual diff once, then walk
- *    the LCS ops splitting at runs of `add` / `remove` to anchor each
- *    summary entry to the **real** file line. This guarantees the
- *    summary's `L<n>` matches what the user sees in their editor.
- *  - Otherwise, fall back to per-hunk LCS over the (oldString,
- *    newString) snippet pair. Line numbers are absent because the
- *    snippet has no file position.
- */
-declare function summarizeEditPayload(payload: EditPayload): EditSummary;
-interface HunkResolution {
-  /**
-   * True when the tool body would find this hunk's `old_string` AND apply
-   * it without ambiguity. False when `resolveOldString` returned null OR
-   * the match was ambiguous (multiple occurrences and `replace_all` off).
-   */
-  resolved: boolean;
-  /** Path the resolver took — `'exact'` when no recovery was needed. */
-  via?: ResolvedMatch['via'];
-  /** Match count in the running content for the hunk. */
-  occurrences?: number;
-  /** True when the resolver found >1 match without `replace_all`. */
-  ambiguous?: boolean;
-}
-interface PreviewResult {
-  /** Full unified diff of the (resolvable) hunks against `priorContent`. */
-  diffText: string;
-  /** 1:1 with `payload.hunks`. */
-  resolution: HunkResolution[];
-  /**
-   * Per-hunk isolated diff text rendered against the cumulative content
-   * after applying all earlier resolved hunks. Useful for the modal's
-   * focused-hunk view so hunk #N's preview reflects the state hunks
-   * 1..N-1 will leave the file in (same as the tool's order).
-   */
-  perHunkDiff: string[];
-  /**
-   * Resolved hunks with `oldString` rewritten to the haystack's actual
-   * bytes and `newString` re-styled to preserve curly-quote typography
-   * / line-prefix conventions. Pass this to `buildContextualDiff` to
-   * paint the unified diff.
-   */
-  resolvedPayload: EditPayload;
-}
-declare function previewEditPayload(payload: EditPayload, priorContent: string, contextLines?: number): PreviewResult;
-declare function buildUnifiedDiff(payload: EditPayload): string;
-declare function filetypeFromPath(path: string): string | undefined;
-//#endregion
-//#region src/chat/footer-chips.d.ts
-/**
- * `warn` = a real cache break (a named dimension changed, so it was
- * avoidable); `dim` = ordinary TTL expiry, which is not anyone's fault and
- * should not shout.
- */
-type CacheChipTone = 'warn' | 'dim';
-interface CacheChipContent {
-  tone: CacheChipTone;
-  /** Leading glyph. Kept out of `label` so a surface can style it separately. */
-  glyph: string;
-  label: string;
-}
-/**
- * Build the chip for a cache break.
- *
- * `costUsd` is OPTIONAL and omitted entirely on a rate miss — never rendered
- * as `$0.00`. A fabricated zero would read as "this was free", which is the
- * opposite of what the chip exists to say. When present it is prefixed `~`
- * because it is an estimate (registry rates × re-billed prefix), and clamped
- * to `<0.01` rather than rounding a real charge down to nothing.
- */
-declare function cacheBreakChip(info: CacheBreakInfo & {
-  costUsd?: number;
-}): CacheChipContent;
-/**
- * Transcript-row text for a persisted cache-break notice. Multi-line, one
- * fact per line, so both hosts can show a short headline and fold or list
- * the rest:
- *
- *   cache break ↑116.9k tokens ~$0.48
- *   messagePrefix: message 16 of 41→43 rewritten
- *   likely compaction or history trimming
- *
- * The footer chip stays terse; the row carries the culprit so a break is
- * diagnosable from the transcript. Only the headline on a TTL / eviction
- * break (nothing was done wrong).
- */
-declare function cacheBreakNoticeText(info: CacheBreakInfo & {
-  costUsd?: number;
-}): string;
-/**
- * Provider-retry label — `retrying 2/5`, or `retrying 2/5 · child-3` when the
- * stalled stream belongs to a subagent rather than the parent.
- *
- * Naming the source matters: with subagents in flight, an unattributed
- * "retrying" leaves the user unable to tell whether their own turn is stuck or
- * a delegated worker is.
- */
-declare function retryLabel(info: {
-  attempt: number;
-  max: number;
-  source: string;
-}): string;
-/**
- * Footer label while a compaction summary is being generated:
- * `Compacting...`, then `~12k` once the loop reports a token estimate, then
- * ` · 8s` once a second has passed. Same rule on every surface so a
- * minutes-long compaction of a large transcript reads as progress — not a
- * hang — identically in the TUI and the GUI.
- *
- * `now` is injectable so callers driving a 1 Hz tick don't have to re-read
- * the clock, and so tests are deterministic.
- */
-/**
- * Live counter for the parent turn currently streaming: `↓1.2k` when the
- * provider counted the tokens, `↓~1.2k` when it is the character heuristic.
- * Empty until the first token so a tool-only turn shows just the spinner.
- * Tokens-per-second appears after two seconds (`↓1.2k · 41 tok/s`) — earlier
- * the rate is dominated by time-to-first-token and would swing wildly.
- */
-declare function streamingLabel(progress: {
-  outputTokens: number;
-  estimated: boolean;
-  elapsedMs: number;
-} | null | undefined, opts?: {
-  rate?: boolean;
-}): string;
-/**
- * Session cost while a turn streams: settled figure plus the running estimate
- * for the in-flight turn. `estimated` tells the surface to render it dimmed
- * (the number will move, then snap to the settled value at turn end). `null`
- * when there is nothing to show — never `$0.00`.
- */
-declare function liveSessionCost(settledUsd: number, progress: {
-  estCostUsd?: number;
-} | null | undefined): {
-  usd: number;
-  estimated: boolean;
-} | null;
-declare function compactingLabel(estTokens: number | null | undefined, startedAt: number | null | undefined, now?: number): string;
-//#endregion
-//#region src/chat/format.d.ts
-/** Compact token formatter — 12_415 → "12.4k", 1_234_567 → "1.23M". */
-declare function fmtTokens(n: number): string;
-/**
- * USD cost, dollar-prefixed — 2 decimals, 4 below a cent so tiny spends
- * stay visible (a haiku worker's $0.0007 must not render as $0.00).
- */
-declare function fmtCost(cost: number): string;
-/** Compact relative-time formatter — "just now / 5m / 3h / 2d". */
-declare function ageString(ts: number, now?: number): string;
-/** Six-char short form of a session id for headers and lists. */
-declare function shortId(id: string): string;
-/**
- * Single-line preview of a multi-line string, capped at `max` chars and
- * ellipsis-terminated when truncated.
- *
- * Whitespace runs (newlines, tabs, multiple spaces) collapse into one
- * space so the rendered output stays on a single visual row no matter
- * how the input was shaped. Used by every transcript "preview" surface
- * (spawn-start task, `tool: shell (background): <command>`,
- * `<task-notification>` summary line, etc.) — without the whitespace
- * collapse, a 60-char `slice` on a string with an inline `\n\n` paints
- * the second paragraph below the first, producing the visible
- * "preview text spills onto multiple lines" bug (and, downstream,
- * misaligned spawn markers when the wrapped lines collide with
- * other events).
- *
- * Reserves one slot for the `…` so the displayed width is exactly
- * `max` when truncation kicks in.
- */
-declare function previewLine(s: string, max: number): string;
-/**
- * Compact human-readable duration formatter shared by background-task
- * surfaces (the `<task-notification>` summary, the TUI banner, the
- * `shell_kill` tool result, etc.).
- *
- * Format ladder:
- *   - `< 1s`   →  `"Nms"`
- *   - `< 10s`  →  `"N.Ns"` (one decimal)
- *   - `< 1m`   →  `"Ns"`   (whole seconds)
- *   - `< 1h`   →  `"NmNs"` / `"Nm"` when seconds round to 0
- *   - `≥ 1h`   →  `"NhNm"` / `"Nh"` when minutes round to 0
- *
- * Single source of truth so a 60s task renders the same across the
- * model-facing XML summary and the user-facing banner. Earlier
- * separate formatters disagreed (XML said `"60.0s"`, banner said `"1m"`)
- * which was confusing to the user reading both side by side.
- */
-declare function formatDuration(ms: number): string;
-/**
- * Status label for a terminated background task — `"exited <code>"`
- * for natural exits, `"killed"` (with the signal name when known)
- * for our-issued SIGTERMs.
- *
- * Pulled out as its own function so the `<task-notification>` XML
- * summary, the TUI banner header, the `shell_kill` tool result, and
- * future surfaces all read the same string.
- */
-declare function formatTaskStatus(info: {
-  status: 'exited' | 'killed';
-  exitCode: number;
-  signal?: NodeJS.Signals;
-}): string;
-/**
- * One-line summary of a terminated background task — the shape used by
- * the `<task-notification>` XML's `<summary>` tag AND the TUI banner's
- * `event.text` fallback string. Three dot-separated segments:
- *
- *   `<command preview · status · duration>`
- *
- * Centralizes the format so live + replay + wire all agree, and so a
- * future cosmetic tweak (separator glyph, segment ordering) lands in
- * exactly one place.
- */
-declare function formatTaskSummary(info: {
-  command: string;
-  status: 'exited' | 'killed';
-  exitCode: number;
-  signal?: NodeJS.Signals;
-  durationMs: number;
-}, maxCommandChars?: number): string;
-/**
- * Compact an absolute path for display: replace the user's `$HOME`
- * prefix with `~` (so `/Users/yael/Code/zidane` → `~/Code/zidane`),
- * and optionally left-truncate with an ellipsis when the result
- * still exceeds `maxWidth` (so the path's *tail* — the part the user
- * recognizes — stays visible: `…/zidane` rather than `/Users/yaeluil…`).
- *
- * `maxWidth` is the maximum *display width* in cells. Omit to skip
- * truncation. Paths outside `$HOME` are returned verbatim modulo
- * truncation. The ellipsis (`…`) counts as one cell.
- *
- * `home` overrides `os.homedir()` for tests; production callers leave
- * it undefined and pay the cheap one-syscall lookup per call.
- */
-declare function compactPath(path: string, maxWidth?: number, home?: string): string;
-//#endregion
-//#region src/chat/provider-usage-format.d.ts
-/**
- * Node-free half of provider usage: the wire types and the two presentation
- * helpers every surface needs to RENDER a snapshot.
- *
- * Split out of `provider-usage.ts` because that module reads
- * `credentials.json` and so cannot be reached from `zidane/chat/pure`. The
- * Electron renderer receives snapshots over IPC (main does the fetching) and
- * must draw them with the same rounding and the same "which window bites
- * first" rule as the TUI — a renderer that re-derived either would be the
- * duplication that let the TUI and GUI report different facts about one event.
- *
- * `provider-usage.ts` re-exports everything here, so existing importers keep
- * their single import.
- */
-/** One rate-limit window on a subscription (e.g. "5h", "weekly"). */
-interface ProviderUsageWindow {
-  /** Stable id from the provider, used as a React / list key. */
-  id: string;
-  /** Human label as the provider names it. */
-  label: string;
-  /** 0..100, may be fractional. */
-  usedPercent: number;
-  /** Epoch ms when the window resets, or `null` when the provider omits it. */
-  resetsAt: number | null;
-}
-/** Remaining credits for pay-as-you-go style providers. */
-interface ProviderUsageCredits {
-  remaining: number;
-  total: number | null;
-}
-type ProviderUsageStatus = 'ok' | 'unauthorized' | 'unavailable';
-interface ProviderUsageSnapshot {
-  /** Registry key (`anthropic`, `openai`, …). */
-  providerKey: string;
-  /** Display label for the provider. */
-  label: string;
-  /**
-   * Credentials-file key of the credential this snapshot was probed with. A
-   * provider holding several OAuth accounts yields one snapshot per account;
-   * this is what tells them apart (and the stable list key).
-   */
-  credentialKey: string;
-  /**
-   * Account name for OAuth-backed snapshots (`Default`, `work`, …); `null` for
-   * API-key probes. Surfaces show it only when the provider has more than one
-   * snapshot, so a single-account provider stays as quiet as before.
-   */
-  account: string | null;
-  /** True when this credential is the one requests use (the canonical slot). */
-  activeCredential: boolean;
-  status: ProviderUsageStatus;
-  /** Plan name when the provider reports one. */
-  plan: string | null;
-  windows: readonly ProviderUsageWindow[];
-  credits: ProviderUsageCredits | null;
-  fetchedAt: number;
-  error: string | null;
-}
-/**
- * Whether a snapshot should show its account name: only when another snapshot
- * in the same list belongs to the same provider. One account is the provider.
- */
-declare function showsAccount(snapshot: ProviderUsageSnapshot, all: readonly ProviderUsageSnapshot[]): boolean;
-/**
- * The snapshot the footer indicator shows for a provider: the one probed with
- * the credential requests use, else the first reported. `null` when none.
- */
-declare function activeSnapshotFor(all: readonly ProviderUsageSnapshot[], providerKey: string): ProviderUsageSnapshot | null;
-/**
- * The window closest to its ceiling, which is the one that will bite first and
- * the only one a single-line indicator has room for. `null` when the snapshot
- * carries no windows.
- */
-declare function mostConstrainedWindow(snapshot: ProviderUsageSnapshot): ProviderUsageWindow | null;
-/**
- * Percent for display: integers print bare, fractions keep one decimal (so a
- * status bar never reads `100%` for `99.9`).
- */
-declare function formatUsagePercent(usedPercent: number): string;
-/**
- * Severity tone for a usage percent. `error` ≥ 85, `warn` ≥ 60, else `ok`.
- * Surfaces map tones to their own palette.
- */
-type UsageTone = 'ok' | 'warn' | 'error';
-declare function usageTone(usedPercent: number): UsageTone;
-/**
- * Time to reset, coarsened to whole days past 24h. `null` when the provider
- * reported no reset, `resetting` once it is due.
- *
- * Every step rounds DOWN, like the percent: 36h reads as `1d`, not `2d`.
- * Overstating the headroom left on a window is the wrong direction to be
- * wrong in.
- */
-declare function resetLabel(resetsAt: number | null, now?: number): string | null;
-/**
- * `updated 12s ago` / `updated 3m ago` for the newest snapshot in a list, so a
- * refresh that returns identical numbers is still visibly a refresh. `null`
- * when the list is empty.
- */
-declare function updatedLabel(snapshots: readonly ProviderUsageSnapshot[], now?: number): string | null;
-/** Balances are dollars for OpenRouter and opaque units elsewhere. */
-declare function formatCredits(value: number): string;
-/** `20.00 / 25.00`, or just the remainder when no total is reported. */
-declare function formatBalance(credits: ProviderUsageCredits): string;
-//#endregion
-//#region src/chat/streaming-pure.d.ts
-/** Flip any trailing streaming markdown blocks (any owner) to finalized. */
-declare function finalizeStreamingMarkdown(events: StreamEvent[]): StreamEvent[];
-/** Flip the trailing streaming markdown block for one specific owner. */
-declare function finalizeStreamingMarkdownForOwner(events: StreamEvent[], owner: Owner): StreamEvent[];
-/**
- * Effective context size for a single turn.
- *
- * `usage.input` is misleading on its own when prompt caching is active: providers
- * (Anthropic, OpenRouter→Anthropic, Gemini) report `input` as the *new uncached*
- * tokens only — the cached prefix shows up in `cacheRead`, and newly-cached
- * tokens in `cacheCreation`. The model still saw all three buckets, so the real
- * context-window utilization is their sum.
- *
- * Non-caching providers leave `cacheRead`/`cacheCreation` undefined, so this
- * collapses to plain `input` for them.
- */
-declare function turnContextSize(usage: TurnUsage | undefined): number;
-/**
- * Display-layer transcript bounds. Each rendered event holds live React
- * fibers + OpenTUI renderables + native text buffers even when scrolled
- * off-screen — measured at roughly 0.13 MB RSS per markdown-heavy event —
- * so an uncapped multi-thousand-event session (a normal working day with
- * tool calls) climbs into the hundreds of MB and eventually OOM/thrash.
- *
- * The cap bounds ONLY what is materialized on screen: session turns on
- * disk are complete, and switching sessions / re-activating replays the
- * most recent window again. Trimming happens at TURN boundaries so a
- * turn's rows are never orphaned, and re-caps fold into one cumulative
- * marker rather than stacking markers.
- */
-declare const MAX_TRANSCRIPT_EVENTS = 1500;
-/** Post-trim size — the hysteresis gap keeps re-trims O(rare), not per-append. */
-declare const TRANSCRIPT_TRIM_TO_EVENTS = 1200;
-/**
- * Bound a transcript event array for display. Identity below the cap
- * (no re-render churn on the hot append path); above it, drops the
- * oldest events down to {@link TRANSCRIPT_TRIM_TO_EVENTS} — extended to
- * the next turn boundary — and prepends a cumulative hidden-count
- * marker. Callers: the stream buffer's drain commit and every
- * `eventsFromTurns` replay site.
- */
-declare function capTranscriptEvents(events: StreamEvent[], max?: number, trimTo?: number): StreamEvent[];
-//#endregion
-//#region src/chat/todos.d.ts
-declare const TODOWRITE_TOOL = "todowrite";
-declare const TODOREAD_TOOL = "todoread";
-/** True when `name` is one of the todo tool canonical names. */
-declare function isTodoTool(name: string): boolean;
-/** `session.metadata[TODOS_METADATA_KEY]: TodosBag` — see {@link TodosBag}. */
-declare const TODOS_METADATA_KEY = "todos";
-/** `session.metadata[TODO_WRITE_COUNTS_METADATA_KEY]: CountsBag` — mirrors `TodosBag` shape. */
-declare const TODO_WRITE_COUNTS_METADATA_KEY = "todoWriteCounts";
-type TodoStatus = 'pending' | 'in_progress' | 'completed' | 'cancelled';
-interface TodoItem {
-  /** Stable id — the model picks it. Reusing an id replaces that item. */
-  id: string;
-  /** One-line task summary (Markdown allowed; renderers may sanitize). */
-  content: string;
-  status: TodoStatus;
-}
-/**
- * On-disk shape at `session.metadata[TODOS_METADATA_KEY]`.
- *
- * Sub-fields are absent (not empty) when they carry no data — keeps the
- * persisted metadata clean and lets `JSON.stringify` skip empty bags
- * entirely on session save.
- */
-interface TodosBag {
-  /** Top-level slot — shared across runs whose `parentRunId` is unset. */
-  session?: TodoItem[];
-  /** Per-subagent-run slots, keyed by the child run's id. */
-  byRun?: Record<string, TodoItem[]>;
-  /**
-   * Most-recent non-empty list per slot — sidecar for UI surfaces, NOT
-   * visible to `todoread`. Updated on every non-empty write; **preserved**
-   * across the auto-clear path. Lets the modal keep showing "what was just
-   * completed" after a fully-done batch wipes the live slot. Empty writes
-   * never touch the archive — clearing the live list shouldn't erase the
-   * audit trail.
-   */
-  archive?: {
-    session?: TodoItem[];
-    byRun?: Record<string, TodoItem[]>;
-  };
-}
-/**
- * Default ceiling on a single todo list. Exported so every write boundary caps
- * identically — a boundary with a different cap would let a list through that
- * the tool would have truncated.
- */
-declare const DEFAULT_MAX_TODO_ITEMS = 100;
-declare const TODO_STATUS_GLYPHS: Readonly<Record<TodoStatus, string>>;
-interface CreateTodoToolsOptions {
-  /**
-   * Maximum item count per `todowrite`. Excess items are truncated by the
-   * recursive validator and reported back to the model in the tool_result.
-   *
-   * Default: `100`. The default is generous; a planning agent that exceeds
-   * 100 items per call is usually flailing.
-   */
-  maxItems?: number;
-  /**
-   * Per-run cap on `todowrite` calls, plumbed into `behavior.toolBudgets`.
-   * `onMaxWrites` chooses the reaction (steer / block) — see
-   * {@link AgentBehavior.toolBudgets} for the contract.
-   *
-   * **Default: `0` (no cap).** `todowrite` is a state-transition tool —
-   * a legitimate run of an N-item list needs at least `N + 1` calls
-   * (initial plan + one transition per item) to complete, so a hard
-   * cap punishes the legitimate path. The nudges that DO apply are the
-   * `remindAfter` reminder (soft, in-band) and the identical-payload
-   * dedup check (silent, structural). Hosts that want a true hard cap
-   * can opt in by setting `maxWritesPerRun: N`.
-   *
-   * **Counting semantics** (when opted in): the budget counts every
-   * dispatched call, including dedup substitutes (zidane spec). The
-   * {@link remindAfter} counter counts execute-only dispatches —
-   * dedup hits replay the prior result and never reach the tool body.
-   * Use this budget (not the reminder) as the hard limit.
-   */
-  maxWritesPerRun?: number;
-  onMaxWrites?: 'steer' | 'block';
-  /**
-   * Hard stop for **consecutive identical** `todowrite` payloads — the
-   * exact loop the in-body `dedupIdentical` check only *whispers* about
-   * ("No change — N items already tracked"). Plumbs a run-scoped
-   * `behavior.dedupTools.todowrite` entry in `block-after` mode: the
-   * gate replays the unchanged result for the first `N - 1` identical
-   * calls, then refuses the `N`th (and every subsequent identical one)
-   * with a `Blocked: …` tool_result so the model breaks out instead of
-   * re-checkpointing forever.
-   *
-   * This is safe to leave on by default — unlike {@link maxWritesPerRun}
-   * it only ever blocks a payload byte-identical to the one already
-   * tracked, so a legitimate "finish the N-item plan" run (which writes
-   * a *different* list each transition) is never touched. The counter
-   * resets the moment the model writes anything different.
-   *
-   * Run-scoped via `DedupToolConfig.scope: 'run'`, so a parent and a
-   * subagent writing the same list never share the counter — the precise
-   * conflation that kept `todowrite` off `behavior.dedupTools` before.
-   *
-   * Set to `0` to opt out (e.g. a host that installs its own loop
-   * hardening). Default: `5`. Values `< 2` are clamped to `2` by the
-   * dedup middleware (a threshold of 1 would block the first call).
-   */
-  maxIdenticalWrites?: number;
-  /**
-   * Custom refusal text for the {@link maxIdenticalWrites} block. Receives
-   * the 1-indexed identical-call count (including the blocked call). Leave
-   * unset for the built-in "you've written the same list N times in a
-   * row" message.
-   */
-  identicalBlockReason?: (count: number) => string;
-  /**
-   * Append a "you've checkpointed N times — only call this at significant
-   * task transitions" nudge to the tool_result once `todowrite` has fired
-   * this many times in the current run. The nudge rides on the result
-   * string, so the model sees it on its next turn without `system:transform`
-   * plumbing.
-   *
-   * Counts only executed dispatches (dedup hits skip the tool body and so
-   * skip the increment). For a hard cap that also covers dedup hits, use
-   * {@link maxWritesPerRun}.
-   *
-   * Set to `0` to opt out. Default: `3`.
-   */
-  remindAfter?: number;
-  /**
-   * Custom reminder text. Receives the post-call count and the items that
-   * were just written. Return `''` (or `undefined`) to suppress the reminder
-   * for this specific call. Default text nudges towards "back to executing,
-   * not re-planning."
-   */
-  reminderText?: (count: number, items: readonly TodoItem[]) => string | undefined;
-  /**
-   * Short-circuit the tool body when the incoming payload is identical to
-   * the **current slot** (session-shared for top-level runs, per-run for
-   * subagents). The model gets a "No change — N items already tracked."
-   * acknowledgment instead of a fresh "Updated N items." line.
-   * Default: `true`.
-   *
-   * Read `session.metadata.todos` via {@link getTodosForRun} for the
-   * comparison — so the resolution naturally follows the keying rule
-   * (top-level reads the session slot, subagent reads its own). Does
-   * NOT plumb through `behavior.dedupTools`: that cache lives at the
-   * gate, is keyed per session, and would conflate top-level + subagent
-   * re-writes of structurally identical payloads.
-   *
-   * Counter advances on identical re-writes regardless — the model
-   * called the tool, that's a call. Lets the reminder threshold catch
-   * spam. Set `false` to skip the check entirely (every call rewrites
-   * the slot, useful when state-shape comparisons are pointless for
-   * your usage).
-   */
-  dedupIdentical?: boolean;
-  /**
-   * Override the JSON-schema-level descriptions surfaced to the model.
-   * Useful for telemetry experiments. Leave unset to inherit the built-in
-   * doctrine prose.
-   */
-  writeDescription?: string;
-  readDescription?: string;
-}
-/**
- * Read the active list for `runId`. Top-level runs see the session-shared
- * slot; subagent runs see their own. Returns a fresh `[]` (not stored in
- * metadata) when no slot exists — the caller can mutate the result
- * without affecting state.
- */
-declare function getTodosForRun(session: Session, runId: string): TodoItem[];
-/**
- * Replace the active list for `runId`. Routes to the session-shared slot
- * for top-level runs and to the per-run slot for subagents. Empty arrays
- * delete the slot entirely so persisted metadata stays clean.
- *
- * Side effect: a **non-empty** write also stashes the same list into
- * `bag.archive` (same routing). Empty writes never touch the archive —
- * clearing the live list (whether explicitly or via the tool's auto-
- * clear) preserves the "last shown" snapshot so UI surfaces can keep
- * rendering what was just completed. See {@link getArchivedTodosForRun}.
- *
- * `opts.clearArchive` opts OUT of that preservation, and exists because the
- * archive is only the right answer for the AUTO-CLEAR path. UI surfaces render
- * `todos.length > 0 ? todos : archive`, so a user who deletes every todo would
- * otherwise watch the archive fall straight back into view with the same items
- * — a destructive action they confirmed, with no visible effect, and the footer
- * chip still counting the list they just deleted. Pass it for user-initiated
- * writes; leave it off for the tool.
- */
-declare function setTodosForRun(session: Session, runId: string, items: readonly TodoItem[], opts?: {
-  clearArchive?: boolean;
-}): void;
-/**
- * Read the archived (most-recent non-empty) list for `runId`. Same slot
- * routing as {@link getTodosForRun}, but reads `bag.archive` instead of
- * the live slot. Returns a fresh `[]` when no archive exists.
- *
- * UI surfaces use this to keep showing "what was just completed" after
- * the live list auto-clears. The model never sees the archive — it's a
- * read-only sidecar for human-facing rendering.
- */
-declare function getArchivedTodosForRun(session: Session, runId: string): TodoItem[];
-/**
- * Reconcile `session.metadata.todos.byRun` (live + archive) against
- * `session.runs`. Drops subagent slots whose runId isn't in the run
- * list. The top-level `session` slot is unaffected — it's session-
- * scoped, not per-run, so there's no orphan to GC.
- *
- * Useful after `session.setRuns()` (fork / restore) or to GC stale
- * metadata mutated by an external caller. Also prunes the parallel
- * counter bag so the two don't drift.
- *
- * `dropped` reports the live-byRun orphans only (archive-only orphans
- * are silently swept). The live half is the contract callers actually
- * observe.
- */
-declare function pruneTodosByRun(session: Session): {
-  dropped: readonly string[];
-};
-/**
- * Build a `Preset` carrying the `{ todowrite, todoread }` tool pair.
- *
- * Loop hardening is layered, soft → hard:
- *   1. **In-body identical dedup** (`dedupIdentical`, on) — resolves
- *      against the active slot (session-shared for top-level runs,
- *      per-run for subagents) and returns "No change — N items already
- *      tracked." Advisory; the model can ignore it.
- *   2. **In-band reminder** (`remindAfter`, on) — appends a "you've
- *      checkpointed N times" nudge to the result. Also advisory.
- *   3. **Consecutive-identical hard block** (`maxIdenticalWrites`, ON by
- *      default) — a run-scoped `behavior.dedupTools.todowrite` entry in
- *      `block-after` mode. After N byte-identical writes in a row the
- *      gate refuses with `Blocked: …` and the body never runs. This is
- *      the real loop breaker, and it's safe-by-default precisely because
- *      it only fires on *identical* payloads — a legitimate N-item plan
- *      writes a *different* list each step and never trips it.
- *
- * By default the preset adds **no** `toolBudgets` entry — a blanket
- * per-call cap is the wrong abstraction for a state-transition tool (it
- * punishes the legitimate "finish the N-item plan" path). Hosts that
- * want a ceiling on *all* writes (not just identical ones) pass
- * `maxWritesPerRun: N` explicitly; the factory then also plumbs a
- * `behavior.toolBudgets.todowrite` entry.
- *
- * Returning a `Preset` (not a bare tool map) lets the result flow
- * through {@link composePresets} unchanged. `behavior.dedupTools` and
- * `behavior.toolBudgets` are tool-name-keyed records that
- * `composePresets` deep-merges, so a caller's entries for other tools
- * survive the layering, and a caller's override for `todowrite` itself
- * wins by being placed later in the chain.
- *
- * ```ts
- * import { basic, composePresets } from 'zidane/presets'
- * import { createTodoTools } from 'zidane/chat'
- *
- * // Default: soft dedup + reminder + a run-scoped hard block after 5
- * // identical writes in a row.
- * createAgent({ ...composePresets(basic, createTodoTools()), provider })
- *
- * // Tune (or disable) the identical-write block.
- * createTodoTools({ maxIdenticalWrites: 3 })  // stricter
- * createTodoTools({ maxIdenticalWrites: 0 })  // off — soft signals only
- *
- * // Opt-in blanket cap on *all* writes (counts distinct ones too).
- * createAgent({
- *   ...composePresets(basic, createTodoTools({ maxWritesPerRun: 20 })),
- *   provider,
- * })
- * ```
- *
- * For the trivial "just add the tools to an existing config" case, plain
- * spread is also fine — the returned `Preset` sets `tools` plus a
- * `behavior` block (carrying the default identical-write dedup):
- *
- * ```ts
- * createAgent({ ...basic, ...createTodoTools(), provider })
- * ```
- */
-declare function createTodoTools(options?: CreateTodoToolsOptions): Preset;
-/**
- * Validate an untrusted todo list, dropping malformed rows and capping length.
- *
- * The single validator for every write/read boundary: model tool input,
- * persisted metadata on read, and user edits arriving over IPC. Keeping them on
- * one implementation is what makes "well-formed" mean the same thing at each —
- * a boundary that only picked fields (as `normalizeItem` does) would admit an
- * invalid `status` that the read path then silently drops, so the write appears
- * to succeed and the row vanishes with nothing reported.
- */
-declare function sanitizeTodoItems(raw: readonly unknown[], cap?: number): TodoItem[];
-interface TodoTally {
-  pending: number;
-  in_progress: number;
-  completed: number;
-  cancelled: number;
-}
-interface ActiveTodosState {
-  /** Run the slice came from. `null` ⇒ no session / no runs / no active run. */
-  runId: string | null;
-  /**
-   * Live list — what `todoread` would return. Empty when the slot was
-   * cleared (e.g. auto-clear after every item completed) or never
-   * written. Source of truth for the model's view.
-   */
-  todos: readonly TodoItem[];
-  /**
-   * Most-recent non-empty list for the active slot, preserved across
-   * auto-clear. Equals `todos` when the live list is non-empty;
-   * otherwise the last batch that was shown (commonly the all-`completed`
-   * close-out). UI surfaces fall back to this when `todos` is empty so
-   * the user can still glance back at "what was just finished" — until
-   * the model writes a new list. Empty array when no list was ever
-   * written for this slot.
-   */
-  archive: readonly TodoItem[];
-  /**
-   * The first `in_progress` item from `todos` (the **live** list), when
-   * one exists. Drives the inline indicator above the prompt. Always
-   * `null` when the live list is empty — even if the archive carries
-   * an in-progress item, that item is by definition stale.
-   */
-  inProgress: TodoItem | null;
-  /**
-   * Per-status counts. Computed over `todos` when non-empty, else over
-   * `archive`. Zeros only when both are empty. Lets the modal header
-   * show a meaningful tally for the archived "last batch" view.
-   */
-  tally: TodoTally;
-}
-/**
- * Pick the "active" run for UI surfaces that show one slot at a time
- * (todos indicator, todos modal, footer ctx indicator). The resolved
- * runId then routes through {@link getTodosForRun} — top-level runs
- * land on the session-shared slot, subagent runs on their own.
- *
- * - A currently-running run wins (latest-started one if several).
- * - Otherwise the most recently appended run wins.
- * - `null` when the session has no runs.
- *
- * Mirrors the "most recent thing that mattered" policy that drives
- * `lastContextSizeFromTurns` — but walks `session.runs` rather than
- * `session.turns` because the active todo slot is a function of the
- * run, not of message history.
- */
-declare function pickActiveRunId(session: Session | null | undefined): string | null;
-/**
- * Pure selector — derive the active-todos state from a session snapshot.
- * Used by {@link useActiveTodos} and directly testable without React.
- *
- * Resolves both `todos` (live, model-facing) and `archive` (last
- * non-empty snapshot for UI fallback). The tally folds over whichever
- * list is non-empty; `inProgress` is sourced strictly from `todos`
- * because an archived in-progress item is by definition stale.
- */
-declare function selectActiveTodos(session: Session | null | undefined): ActiveTodosState;
-/**
- * React hook — active-todos state for the supplied session. Recomputes
- * on every parent re-render; the work is O(runs + todos), both bounded
- * by small constants in practice.
- *
- * Why no memoization: `Session.runs` is mutated in place by `completeRun`
- * / `abortRun` (status flips without changing array length or item
- * identity), so any memo keyed off length / bag identity would silently
- * return stale state when e.g. a child subagent run completes and the
- * "active" run should reflow to the parent. The selector is cheap
- * enough that running it every parent render is the simpler, correct
- * answer — see `selectActiveTodos` for the O(n) cost.
- *
- * The hook lives in `chat/` so a GUI consumer can mount it verbatim.
- * Renderer-agnostic — no `@opentui/*` imports.
- */
-declare function useActiveTodos(session: Session | null | undefined): ActiveTodosState;
-//#endregion
-//#region src/chat/turn-operations.d.ts
-/**
- * Fork — keep every turn up to and including `turnId`, then strip any
- * `tool_call` blocks left without a matching `tool_result` in the slice.
- *
- * Semantics:
- *   - Include the selected turn ("branch from HERE" mental model — the
- *     user wants the selected message to be the latest in the fork).
- *   - If the selected turn is an assistant turn with unresolved
- *     `tool_call` blocks (their `tool_result`s live in turns AFTER the
- *     slice), strip those calls. Otherwise the fork would post an
- *     assistant turn with no matching tool results, breaking the next
- *     provider call.
- *   - Drop turns that become empty (all blocks stripped).
- *
- * Returns `null` when `turnId` doesn't exist in `turns` — caller should
- * surface a "turn not found" error rather than silently no-op.
- */
-declare function truncateTurnsAt(turns: readonly SessionTurn[], turnId: string): SessionTurn[] | null;
-/**
- * Delete — remove the turn with `turnId` and any tool blocks left
- * orphaned by the removal. Returns `null` when `turnId` doesn't exist.
- *
- * Strategy:
- *   1. Drop the target turn.
- *   2. Scan the remaining turns for `tool_call`s without a matching
- *      `tool_result` (orphaned by removing the user turn that carried
- *      the result), and `tool_result`s without a matching `tool_call`
- *      (orphaned by removing the assistant turn that issued the call).
- *      Strip both sides.
- *   3. Drop turns whose content is now empty.
- *
- * This guarantees the resulting history is protocol-clean — a follow-up
- * `agent.run()` against the modified session can post turns without the
- * provider rejecting the history.
- */
-declare function deleteTurnSafely(turns: readonly SessionTurn[], turnId: string): SessionTurn[] | null;
-/**
- * Serialize a turn's content to a clean text representation suited for
- * the clipboard. Joins text + thinking blocks verbatim; tool calls and
- * tool results get bracketed labels so the user can paste a readable
- * record of what happened without losing structure.
- *
- * Empty turns return `''`.
- */
-declare function turnAsText(turn: SessionTurn): string;
-/**
- * Count turns before / after the one identified by `turnId` in the
- * given list. Returns `null` when the id is missing. Used to label the
- * turn-details modal with `N before · M after`.
- */
-declare function countNeighbors(turnIds: readonly string[], turnId: string): {
-  before: number;
-  after: number;
-} | null;
-//#endregion
-export { formatTaskSummary as $, chatReferenceTokensFromText as $t, finalizeStreamingMarkdown as A, buildEditOutcomesAnnotation as At, formatCredits as B, uniqueSkillNamesFromReferences as Bt, sanitizeTodoItems as C, extractEditPayload as Ct, MAX_TRANSCRIPT_EVENTS as D, summarizeEditPayload as Dt, useActiveTodos as E, splitLines as Et, ProviderUsageStatus as F, rewriteMultiEditHeader as Ft, updatedLabel as G, ListProjectFilesOptions as Gt, mostConstrainedWindow as H, createFilesCompletionProvider as Ht, ProviderUsageWindow as I, stripEditOutcomesAnnotation as It, compactPath as J, createCommandsCompletionProvider as Jt, usageTone as K, listProjectFiles as Kt, UsageTone as L, summarizeOutcomes as Lt, turnContextSize as M, mergeApprovalAndBodyOutcomes as Mt, ProviderUsageCredits as N, parseEditOutcomesFromResult as Nt, TRANSCRIPT_TRIM_TO_EVENTS as O, tokenize as Ot, ProviderUsageSnapshot as P, resolveApprovalForPayload as Pt, formatTaskStatus as Q, ChatReferenceScope as Qt, activeSnapshotFor as R, SKILLS_TRIGGER as Rt, pruneTodosByRun as S, computeLineDiff as St, setTodosForRun as T, previewEditPayload as Tt, resetLabel as U, uniqueFilesFromReferences as Ut, formatUsagePercent as V, FILES_TRIGGER as Vt, showsAccount as W, FileEntry as Wt, fmtTokens as X, ChatReferenceData as Xt, fmtCost as Y, CHATS_TRIGGER as Yt, formatDuration as Z, ChatReferenceEntry as Zt, createTodoTools as _, PreviewResult as _t, ActiveTodosState as a, cacheBreakNoticeText as at, isTodoTool as b, buildUnifiedDiff as bt, TODOREAD_TOOL as c, retryLabel as ct, TODO_STATUS_GLYPHS as d, DiffOp as dt, createChatsCompletionProvider as en, previewLine as et, TODO_WRITE_COUNTS_METADATA_KEY as f, EditHunkSummary as ft, TodosBag as g, InlineSegment as gt, TodoTally as h, InlineDiff as ht, turnAsText as i, cacheBreakChip as it, finalizeStreamingMarkdownForOwner as j, maskToOutcomeKinds as jt, capTranscriptEvents as k, ResolvedApproval as kt, TODOS_METADATA_KEY as l, streamingLabel as lt, TodoStatus as m, HunkResolution as mt, deleteTurnSafely as n, blendHsl as nn, CacheChipContent as nt, CreateTodoToolsOptions as o, compactingLabel as ot, TodoItem as p, EditSummary as pt, ageString as q, COMMANDS_TRIGGER as qt, truncateTurnsAt as r, buildLinearRamp as rn, CacheChipTone as rt, DEFAULT_MAX_TODO_ITEMS as s, liveSessionCost as st, countNeighbors as t, uniqueChatIdsFromReferences as tn, shortId as tt, TODOWRITE_TOOL as u, DiffLine as ut, getArchivedTodosForRun as v, applyEditPayload as vt, selectActiveTodos as w, filetypeFromPath as wt, pickActiveRunId as x, computeInlineDiff as xt, getTodosForRun as y, buildContextualDiff as yt, formatBalance as z, createSkillsCompletionProvider as zt };
-//# sourceMappingURL=turn-operations-C8bMBDl_.d.ts.map