zidane 6.6.4 → 7.0.1

package/dist/{turn-operations-Cuc9pwiB.d.ts → turn-operations-DKFYWP3O.d.ts}

@@ -1,5 +1,5 @@
-import { Al as CompletionReference, Bh as TurnUsage, Ed as StreamEvent, Rl as Command, _d as EditOutcome, bh as SessionTurn, fg as SkillConfig, jh as ToolResultContent, kl as CompletionProvider, xd as Owner, yd as EditPayload } from "./index-D0O-QO7Z.js";
-import { B as ApprovalDecision } from "./tool-formatters-NrzD6Fkk.js";
+import { Cu as StreamEvent, Hg as TurnUsage, Ng as ToolResultContent, Np as CacheBreakInfo, Rl as CompletionProvider, Sg as SessionTurn, gu as EditPayload, m_ as SkillConfig, mu as EditOutcome, ql as Command, t as Preset, vu as Owner, x_ as Session, zl as CompletionReference } from "./index-B-FSaM3_.js";
+import { V as ApprovalDecision } from "./tool-formatters-DO56YBBw.js";
 
 //#region src/chat/color-gradient.d.ts
 /**
@@ -486,6 +486,56 @@ declare function previewEditPayload(payload: EditPayload, priorContent: string,
 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;
+/**
+ * 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.
+ */
+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;
@@ -583,6 +633,82 @@ declare function formatTaskSummary(info: {
  */
 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;
+  status: ProviderUsageStatus;
+  /** Plan name when the provider reports one. */
+  plan: string | null;
+  windows: readonly ProviderUsageWindow[];
+  credits: ProviderUsageCredits | null;
+  fetchedAt: number;
+  error: string | 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;
+/** 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[];
@@ -627,6 +753,377 @@ declare const TRANSCRIPT_TRIM_TO_EVENTS = 1200;
  */
 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
@@ -683,5 +1180,5 @@ declare function countNeighbors(turnIds: readonly string[], turnId: string): {
   after: number;
 } | null;
 //#endregion
-export { uniqueFilesFromReferences as $, buildUnifiedDiff as A, buildEditOutcomesAnnotation as B, EditSummary as C, PreviewResult as D, InlineSegment as E, previewEditPayload as F, rewriteMultiEditHeader as G, mergeApprovalAndBodyOutcomes as H, splitLines as I, SKILLS_TRIGGER as J, stripEditOutcomesAnnotation as K, summarizeEditPayload as L, computeLineDiff as M, extractEditPayload as N, applyEditPayload as O, filetypeFromPath as P, createFilesCompletionProvider as Q, tokenize as R, EditHunkSummary as S, InlineDiff as T, parseEditOutcomesFromResult as U, maskToOutcomeKinds as V, resolveApprovalForPayload as W, uniqueSkillNamesFromReferences as X, createSkillsCompletionProvider as Y, FILES_TRIGGER as Z, formatTaskSummary as _, MAX_TRANSCRIPT_EVENTS as a, CHATS_TRIGGER as at, DiffLine as b, finalizeStreamingMarkdown as c, ChatReferenceScope as ct, ageString as d, uniqueChatIdsFromReferences as dt, FileEntry as et, compactPath as f, blendHsl as ft, formatTaskStatus as g, formatDuration as h, turnAsText as i, createCommandsCompletionProvider as it, computeInlineDiff as j, buildContextualDiff as k, finalizeStreamingMarkdownForOwner as l, chatReferenceTokensFromText as lt, fmtTokens as m, deleteTurnSafely as n, listProjectFiles as nt, TRANSCRIPT_TRIM_TO_EVENTS as o, ChatReferenceData as ot, fmtCost as p, buildLinearRamp as pt, summarizeOutcomes as q, truncateTurnsAt as r, COMMANDS_TRIGGER as rt, capTranscriptEvents as s, ChatReferenceEntry as st, countNeighbors as t, ListProjectFilesOptions as tt, turnContextSize as u, createChatsCompletionProvider as ut, previewLine as v, HunkResolution as w, DiffOp as x, shortId as y, ResolvedApproval as z };
-//# sourceMappingURL=turn-operations-Cuc9pwiB.d.ts.map
+export { CacheChipContent as $, finalizeStreamingMarkdown as A, stripEditOutcomesAnnotation as At, formatUsagePercent as B, listProjectFiles as Bt, sanitizeTodoItems as C, ResolvedApproval as Ct, MAX_TRANSCRIPT_EVENTS as D, parseEditOutcomesFromResult as Dt, useActiveTodos as E, mergeApprovalAndBodyOutcomes as Et, ProviderUsageStatus as F, FILES_TRIGGER as Ft, compactPath as G, ChatReferenceEntry as Gt, resetLabel as H, createCommandsCompletionProvider as Ht, ProviderUsageWindow as I, createFilesCompletionProvider as It, formatDuration as J, createChatsCompletionProvider as Jt, fmtCost as K, ChatReferenceScope as Kt, UsageTone as L, uniqueFilesFromReferences as Lt, turnContextSize as M, SKILLS_TRIGGER as Mt, ProviderUsageCredits as N, createSkillsCompletionProvider as Nt, TRANSCRIPT_TRIM_TO_EVENTS as O, resolveApprovalForPayload as Ot, ProviderUsageSnapshot as P, uniqueSkillNamesFromReferences as Pt, shortId as Q, formatBalance as R, FileEntry as Rt, pruneTodosByRun as S, tokenize as St, setTodosForRun as T, maskToOutcomeKinds as Tt, usageTone as U, CHATS_TRIGGER as Ut, mostConstrainedWindow as V, COMMANDS_TRIGGER as Vt, ageString as W, ChatReferenceData as Wt, formatTaskSummary as X, blendHsl as Xt, formatTaskStatus as Y, uniqueChatIdsFromReferences as Yt, previewLine as Z, buildLinearRamp as Zt, createTodoTools as _, extractEditPayload as _t, ActiveTodosState as a, DiffOp as at, isTodoTool as b, splitLines as bt, TODOREAD_TOOL as c, HunkResolution as ct, TODO_STATUS_GLYPHS as d, PreviewResult as dt, CacheChipTone as et, TODO_WRITE_COUNTS_METADATA_KEY as f, applyEditPayload as ft, TodosBag as g, computeLineDiff as gt, TodoTally as h, computeInlineDiff as ht, turnAsText as i, DiffLine as it, finalizeStreamingMarkdownForOwner as j, summarizeOutcomes as jt, capTranscriptEvents as k, rewriteMultiEditHeader as kt, TODOS_METADATA_KEY as l, InlineDiff as lt, TodoStatus as m, buildUnifiedDiff as mt, deleteTurnSafely as n, compactingLabel as nt, CreateTodoToolsOptions as o, EditHunkSummary as ot, TodoItem as p, buildContextualDiff as pt, fmtTokens as q, chatReferenceTokensFromText as qt, truncateTurnsAt as r, retryLabel as rt, DEFAULT_MAX_TODO_ITEMS as s, EditSummary as st, countNeighbors as t, cacheBreakChip as tt, TODOWRITE_TOOL as u, InlineSegment as ut, getArchivedTodosForRun as v, filetypeFromPath as vt, selectActiveTodos as w, buildEditOutcomesAnnotation as wt, pickActiveRunId as x, summarizeEditPayload as xt, getTodosForRun as y, previewEditPayload as yt, formatCredits as z, ListProjectFilesOptions as zt };
+//# sourceMappingURL=turn-operations-DKFYWP3O.d.ts.map

package/dist/turn-operations-DKFYWP3O.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn-operations-DKFYWP3O.d.ts","names":[],"sources":["../src/chat/color-gradient.ts","../src/chat/completion-chats.ts","../src/chat/completion-commands.ts","../src/chat/files-discovery.ts","../src/chat/completion-files.ts","../src/chat/completion-skills.ts","../src/chat/edit-approval.ts","../src/tools/edit-utils.ts","../src/chat/edit-diff.ts","../src/chat/footer-chips.ts","../src/chat/format.ts","../src/chat/provider-usage-format.ts","../src/chat/streaming-pure.ts","../src/chat/todos.ts","../src/chat/turn-operations.ts"],"mappings":"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"}

package/dist/{types-BIarq1qE.js → types-CWgENVLY.js}

@@ -1,5 +1,27 @@
 import { Buffer } from "node:buffer";
 //#region src/types.ts
+/**
+* Thinking / extended-reasoning configuration.
+*
+* - `'off'` — no thinking.
+* - `'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max'` — explicit
+*   effort tier. Maps to provider-specific reasoning controls (Anthropic
+*   `output_config.effort`; OpenAI-compatible providers clamp to their
+*   supported tiers).
+* - `'adaptive'` — let the model decide per-turn whether and how much to think.
+*   Anthropic-only (`thinking.type='adaptive'`). Other providers fall back to
+*   no reasoning when this value is supplied.
+*/
+const THINKING_LEVELS = [
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max",
+	"adaptive"
+];
 /** Native clock backing the default (Date.now + crypto.randomUUID). */
 const DEFAULT_AGENT_CLOCK = {
 	now: () => Date.now(),
@@ -226,6 +248,6 @@ function isWireTurn(turn) {
 	return turn.role === "user" || turn.role === "assistant";
 }
 //#endregion
-export { isWireTurn as a, toolOutputByteLength as c, documentBlockMarker as i, toolResultToText as l, assertResolvedMediaBlock as n, sanitizeToolResultMetadata as o, coerceToolResultContent as r, toolOutputBudgetByteLength as s, DEFAULT_AGENT_CLOCK as t };
+export { documentBlockMarker as a, toolOutputBudgetByteLength as c, coerceToolResultContent as i, toolOutputByteLength as l, THINKING_LEVELS as n, isWireTurn as o, assertResolvedMediaBlock as r, sanitizeToolResultMetadata as s, DEFAULT_AGENT_CLOCK as t, toolResultToText as u };
 
-//# sourceMappingURL=types-BIarq1qE.js.map
+//# sourceMappingURL=types-CWgENVLY.js.map