zidane 5.6.11 → 5.6.13

package/docs/ARCHITECTURE.md

@@ -80,17 +80,22 @@ flowchart TB
     T1["Generate turnId"] --> T2["turnsToMessages()"]
     T2 --> T2B["sanitizeStoredToolResults()\n(flatten images for non-vision providers)"]
     T2B --> T3["context:transform hook"]
-    T3 --> T3B["system:transform hook\n(per-request system mutation)"]
+    T3 --> T3A["applyPairingRepair() + ensureEndsWithUserMessage()\n(wire-only orphan tool_use / tool_result repair,\nuser-tail guard for prefill-rejecting models)"]
+    T3A --> T3B["system:transform hook\n(per-request system mutation)"]
     T3B --> T3C["applyThinkingDecay()\n(per-turn budget taper)"]
     T3C --> T4["turn:before hook"]
-    T4 --> STREAM
+    T4 --> T4A["applyPairingRepair() + ensureEndsWithUserMessage() — re-run\n(idempotent; seals last-mile messages mutation)"]
+    T4A --> STREAM
 
     subgraph STREAM ["provider.stream()"]
         S1["Send system + messages + tools to LLM"] --> S2["Stream text chunks"]
         S2 --> S3["stream:text hook (per chunk)"]
     end
 
-    STREAM -->|error| CATCH["stream:error hook (raw err)\nturn:after hook (zero usage)\nRethrow"]
+    STREAM -->|error| RETRY{"retryable +\nno output yet?"}
+    RETRY -->|yes, attempts left| BACKOFF["stream:retry hook\nabortable backoff sleep"]
+    BACKOFF --> STREAM
+    RETRY -->|no| CATCH["stream:error hook (raw err)\nturn:after hook (zero usage)\nRethrow"]
     STREAM -->|ok| S4{"Has text?"}
     S4 -->|yes| S5["stream:end hook"]
     S4 -->|no| AFTER
@@ -192,7 +197,7 @@ Built-in tools are opinionated about output sizes — drop your v2 `tool:transfo
 | `write_file` | Reads existing content; returns `Created` / `Updated` / `No change needed: …` so the model detects no-ops without a separate read. Race window in shared docker/sandbox contexts documented and accepted. |
 | `edit` | Fails clearly on non-unique `old_string` (unless `replace_all: true`). On not-found, includes a nearest-match preview so the model recovers without re-reading. |
 | `multi_edit` | Sequential edits to one file. **Best-effort, per-hunk** — each step runs against the file as left by the previous APPLIED step; a per-step failure (`old_string` not found, ambiguous without `replace_all`, identical strings, malformed input) is reported in the result but doesn't block siblings. Writes the file iff at least one step applied. All-applied returns the legacy `Edited <path>: applied N edits (M replacements).` so the renderer's success-suppression keeps the diff alone; any failure emits `Edited <path>: applied N of M edits …` (or `multi_edit error: no edits applied to <path> (M attempted).` when nothing landed) plus per-failure lines + an `<edit-outcomes>` block. Approval is a host concern: the chat layer's `tool:gate` rebinds `ctx.input.edits` to the approved subset (rebind, not mutate — the model's original `tool_call` block in `session.turns` stays untouched), and a `tool:transform` hook merges the body's subset-keyed outcomes with the approval-side denied/skipped entries (`mergeApprovalAndBodyOutcomes`) before appending the canonical `<edit-outcomes>` block. `parseEditOutcomesFromResult` re-parses it on reload. See CHAT.md → Per-edit approval. |
-| `grep` | Wraps `rg` when present (with explicit `.` path to avoid stdin hangs). Bun.Glob fallback otherwise. `head_limit=250`, `offset` paginates. |
+| `grep` | Wraps `rg` when present (with explicit `.` path to avoid stdin hangs). `node:fs/promises` glob fallback otherwise (post-filters directories via `stat` — Bun's port doesn't yet support `withFileTypes`). `head_limit=250`, `offset` paginates. |
 
 ## Per-edit approval — harness purity
 
@@ -295,7 +300,7 @@ native error
 
 When `behavior.cache: true` (default), zidane injects `cache_control: { type: 'ephemeral' }` breakpoints on three stable prefixes:
 
-1. **System prompt** — last text block.
+1. **System prompt** — `cache_control` on the static prefix (see boundary marker below); single block when no marker is present.
 2. **Tool definitions** — last tool in the array.
 3. **Conversation** — last content block of the last message, skipping trailing `thinking` / `redacted_thinking` blocks that can't carry `cache_control`.
 
@@ -314,6 +319,56 @@ Provider semantics:
 Cache-read + cache-write counts surface on `TurnUsage.cacheRead` / `TurnUsage.cacheCreation`,
 populated from Anthropic's native fields and from OpenRouter's `prompt_tokens_details`.
 
+### System-prompt boundary
+
+Per-turn churn in the system prompt (e.g. `<env>` cwd/date rewrites) used to invalidate the entire cached prefix — `cache_control` on the last block covered the whole text. The `SYSTEM_PROMPT_BOUNDARY` marker splits it into two:
+
+```
+┌──────────────┐  cache_control: ephemeral
+│ STATIC half  │  doctrine + skills catalog + tool catalog + user instructions
+├──────────────┤  ← __ZIDANE_SYSTEM_PROMPT_BOUNDARY__
+│ DYNAMIC half │  env (cwd / date / platform), IDE state, anything per-turn
+└──────────────┘  (no cache_control)
+```
+
+The static prefix rides the prompt cache across turns/sessions; the dynamic suffix re-bills per turn. The marker is structural metadata — providers strip it from the wire bytes before the model sees the prompt.
+
+**Public API** (`zidane`):
+
+| Symbol | Purpose |
+|---|---|
+| `SYSTEM_PROMPT_BOUNDARY` | The literal marker. Embed it in your system prompt to opt in. |
+| `splitSystemPrompt(s)` | Returns `{ static, dynamic }`. Marker-free input ⇒ everything is static. |
+| `joinSystemPrompt(static, dynamic)` | Compose; marker omitted when `dynamic` is empty. |
+| `appendStaticSection(s, extra)` | Append to the static half (used internally for skills + lazy tool catalogs). |
+| `appendDynamicSection(s, extra)` | Append to the dynamic half (used by hosts for per-turn state). |
+| `replaceDynamicSection(s, next)` | Replace the dynamic half wholesale (used by the TUI's env rewriter). |
+| `renderSystemForWire(s)` | Strip the marker for providers that can't honor `cache_control`. |
+| `hasSystemPromptBoundary(s)` | Boolean probe. |
+
+The built-in profiles (`buildBuildSystem` / `buildPlanSystem` in `zidane/chat`) emit the boundary automatically when `cwd` is provided. Custom callers calling `createAgent({ system })` directly stay marker-free by default — zero overhead, identical wire bytes to before.
+
+**Provider integration:**
+
+- `anthropic` — `applyAnthropicCacheBreakpoints(params, originalSystem)` splits string system prompts on the marker. The OAuth path skips the split (the canonical CC prompt occupies `params.system`; the user doctrine lives in an injected user message).
+- `openaiCompat` — `toOAIMessages` strips the marker; `applyOAICacheBreakpoints(messages, originalSystem)` splits the leading system message into static + dynamic content parts when caching is on.
+- `openai` (Codex), `cerebras`, and any cache-disabled route — marker is collapsed via `renderSystemForWire` so it never reaches the model.
+
+### Cache-break diagnosis
+
+`installCacheBreakLogger(hooks, options?)` hashes per-request dimensions (`system`, `tools`, `model`, `thinking`, `thinkingBudget`) at `turn:before` and compares against the previous turn on `turn:after`. When `cacheRead` is zero on turn 2+ and dimensions differ, it logs the responsible dimension(s) — turning "cache broke" into "tools array changed at turn 7 because MCP server X loaded".
+
+```ts
+import { installCacheBreakLogger } from 'zidane'
+
+const uninstall = installCacheBreakLogger(agent.hooks, {
+  log: line => logger.debug(line),   // defaults to console.error
+  verbose: !!process.env.ZIDANE_DEBUG?.includes('cache'),
+})
+```
+
+Heuristic only: skips providers that don't report `cacheRead` (Codex / Cerebras). Pure helpers `snapshotCacheDimensions`, `diffCacheDimensions`, and `fnv1a32` are exported for custom telemetry that needs to stamp the same hashes onto spans.
+
 ## Tool aliasing (wire vs. canonical)
 
 Aliasing lives at the LLM boundary only:
@@ -395,33 +450,40 @@ partitionToolDisclosure(toolsBySpecName, mcpToolNames, servers, mode, aliases)
   → lazyEntries (wire name + canonicalName + description + inputSchema + server?)
   → eagerCanonicalNames
 
-unlocked = new Set(eagerCanonicalNames)
+initialUnlocked = new Set(eagerCanonicalNames)   // never mutated — phase-1 filter
+unlocked        = new Set(eagerCanonicalNames)   // mutated as tools surface
+dynamicUnlockOrder = []                          // append-only log
+
 if (lazyEntries && toolSearch.tool !== false && !host-defined tool_search):
-  tools.tool_search = createToolSearchTool({ catalog: lazyEntries, unlocked, defaultLimit })
+  tools.tool_search = createToolSearchTool({ catalog: lazyEntries, unlocked, addUnlock, defaultLimit })
   unlocked.add('tool_search')
+  initialUnlocked.add('tool_search')   // pinned to the cached prefix
 
 system += buildSearchableCatalog(lazyEntries)   // wire names, XML-escaped, no inputSchema
 installLazyDisclosureGate                       // tool:gate refuses lazy ∉ unlocked
 
-per turn:
-  buildFormattedTools()  → filter ctx.tools by unlocked, alias through aliasMaps
+per turn — buildFormattedTools() emits in two phases:
+  1. registry-order walk filtered by initialUnlocked  ← byte-stable cached prefix
+  2. dynamicUnlockOrder, in unlock order              ← append-only tail
 
 tool_search({ names | query | server, limit? }):
-  match wire-keyed byName/byServer indexes
-  unlocked.add(canonicalName) per match
+  for each match: unlocked.add(canonical); addUnlock(canonical)
+                  (addUnlock is the framework-supplied recorder that
+                   appends to dynamicUnlockOrder; legacy hosts that only
+                   pass `unlocked` still work, just lose tail-ordering.)
   return <tool_search_results>…<input_schema>{json}</input_schema>…
     (inputSchema JSON inlined with `<` → `\u003c` so a hostile schema can't break the envelope)
 
-run end: uninstallLazyDisclosureGate; unlocked GC-eligible on next run()
+run end: uninstallLazyDisclosureGate; per-run state GC-eligible on next run()
 ```
 
 **Aliasing.** `LazyToolEntry.name` is the wire name (the only one the provider accepts). `LazyToolEntry.canonicalName` keys `unlocked` and dispatches `ctx.tools[name]`. `session.turns`, `ToolHookContext.name`, and `ctx.tools` keys stay canonical throughout.
 
 **Hard gate vs. provider validation.** Production providers (Anthropic, OpenAI) refuse `tool_use` blocks for tools absent from the request — the gate is mostly redundant there. It exists for custom / mock / lenient providers and makes the lazy boundary observable via `tool:gate`. Refusal points at the discovery tool's wire name.
 
-**Cache cost.** Each `tool_search` advances the tool-list cache breakpoint — one miss per discovery wave; subsequent same-unlocked turns hit cache. Still beats eager (every schema, every turn) when lazy tools are many and discovery waves few. The system-prompt catalog is byte-stable (alphabetical) so it rides the system-prompt cache cleanly.
+**Cache-stable injection.** Every successful `tool_search` invalidates only the SUFFIX of the wire tools array starting at the first new schema — the eager-tool + `tool_search` prefix never moves. Providers cache the prefix on the first turn and serve it from cache every subsequent turn regardless of how many discovery waves the model runs. Mid-array insertion would break the prefix; the two-phase emit above is what keeps it stable. The system-prompt catalog is byte-stable (alphabetical) so it rides the system-prompt cache cleanly.
 
-**Host-defined `tool_search`.** A host tool named `tool_search` (or aliased to that wire name) shadows the auto-injection. The host implementation must call `createToolSearchTool({ catalog, unlocked })` to drive the unlock flow — bare implementations leave the gate refusing every lazy call. For custom flows, prefer `toolSearch.tool: false`.
+**Host-defined `tool_search`.** A host tool named `tool_search` (or aliased to that wire name) shadows the auto-injection. The host implementation must call `createToolSearchTool({ catalog, unlocked, addUnlock? })` to drive the unlock flow — bare implementations leave the gate refusing every lazy call. Pass the same `addUnlock` callback the framework supplies (or a moral equivalent) to keep tail-ordering. For custom flows, prefer `toolSearch.tool: false`.
 
 ## Hook Firing Order
 
@@ -442,7 +504,7 @@ All tool hooks carry `turnId` + `callId`. Typed via `ToolHookContext` / `McpTool
 
 Hooks marked **[mutable]** have ctx fields that affect downstream behavior when handlers mutate them. Last-writer wins.
 
-> **Ordering note:** `context:transform` fires **before** `turn:before` — "transform the context that will be sent". For per-turn observation, use `turn:before`. For editing messages just before the provider call, use `context:transform`.
+> **Ordering note:** `context:transform` fires **before** `turn:before` — "transform the context that will be sent". For per-turn observation, use `turn:before`. For editing messages just before the provider call, use `context:transform` — it lands upstream of the defensive pairing repair (`ensureToolResultPairing` + `ensureEndsWithUserMessage`) so a mutation can't strand orphan `tool_use` / `tool_result` blocks on the wire. `turn:before` is `[mutable: options]` too as a last-mile escape hatch (per-turn reminders, audit-tag wrappers); the loop re-runs both defenses after the hook so the same guarantee holds, at the cost of one extra walk over the message list. Downstream consumers building provider requests **outside** `agent.run()` should use `session.toMessages({ provider })` / `toWireMessages(turns, { provider })` — these apply the same repair so raw `session.turns` never reach a provider as the `tool_result must be preceded by a tool_call with the same toolCallId` 400.
 
 ```
 context:transform     [mutable: messages]       ← edit messages before LLM call
@@ -451,7 +513,8 @@ turn:before                                      ← turn starts
   oauth:refresh                                  ← (when provider supports it)
   stream:thinking (n) / stream:text (n)          ← each streamed chunk
   stream:end                                     ← text complete (if text present)
-  stream:error                                   ← provider rejected before stream:end (omitted on user-initiated aborts)
+  stream:retry (n)                               ← retryable error caught; sleep then re-enter stream (only fires on intermediate failures)
+  stream:error                                   ← provider rejected terminally (omitted on user-initiated aborts and on retries that recover)
 turn:after                                       ← always fires (incl. errors); SessionTurn + toolCounts
   tool:gate           [mutable: block, reason, result?]  ← refuse / substitute / run
   tool:unknown        [mutable: result?, suppressError]  ← no toolDef registered
@@ -473,7 +536,7 @@ budget:exceeded / tool-budget:exceeded           ← byte / per-tool caps trippe
 
 **`tool-results:after`** is the durable-persistence seam. The assistant turn carrying `tool_use` blocks and the user turn carrying matching `tool_result` blocks must be persisted as a pair — otherwise a process death between turns leaves an orphan `tool_use` that Anthropic rejects on resume. Subscribe here to write the pair atomically. The scheduler also synthesizes `Interrupt: …` / `Skipped: …` tool_results for any unstarted calls when abort / steering interrupts a batch (and `synthesizeMissingToolResults` in `src/agent.ts` covers the `turn:after` throw path), so the assistant turn's `tool_use` ids always stay matched.
 
-`tool:unknown` replaces `tool:before` when no `toolDef` exists; `validation:reject` fires after coercion attempts fail. The model receives a result string in both cases (substituted or `Validation error: …`) so it can recover.
+**Unknown-tool path.** When no `toolDef` matches the call name, the loop fires `tool:before` with `ctx.unknown: true` first (so UI consumers binding `tool:before` still see the model's attempt as a card), then `tool:unknown` (substitute / suppressError seam), then `tool:error` (unless `suppressError`), then `tool:dispatched` with `outcome: 'unknown'`. `tool:after` is NOT in the chain — the body never executed. The model receives either the consumer's substitute or `Tool error: Unknown tool: <name>`. `validation:reject` fires after coercion attempts fail.
 
 ### Per run
 
@@ -550,6 +613,15 @@ child:turn:after
 
 `BUBBLED_MUTABLE_EVENTS` (`src/tools/spawn.ts`) is the canonical list: `tool:gate`, `mcp:tool:gate`, `tool:transform`. The bubbled ctx is the same reference the child loop awaits on, so a parent listener can refuse / substitute / annotate a subagent's tool call without registering on the child agent. The chat layer's per-edit annotation flow registers on both `tool:transform` and `child:tool:transform` so subagent-issued `multi_edit` calls also get `<edit-outcomes>` blocks appended to their results.
 
+**Subagent type registry** (`createSpawnTool({ subagents })`). When set, the spawn tool's input schema gains a `subagent_type` enum (the registered keys plus the always-available `'general-purpose'` fallback). The matching `SubagentDef` overlays the parent's resolved config for that one dispatch:
+
+- `system` — preset system prompt. Per-call `input.system` still wins (model specialization beats preset defaults).
+- `tools: readonly string[]` — restrict the child to this canonical-name allow-list (strict subset of the parent's tools; unknown names silently dropped). Matched on `tool.spec.name`, not registry key.
+- `readonly: true` — convenience for `tools: ['read_file', 'grep', 'glob', 'list_files']`. `tools` wins when both are set.
+- `description` — short blurb rendered into the schema field so the model can pick a type without round-tripping through docs.
+
+Unknown `subagent_type` values are routed to `'general-purpose'` (no overlay) — Claude-Code-trained models emitting `subagent_type: 'Verification'` against hosts that didn't wire that type still run, just with the parent's defaults. Empty / unset registry omits the `subagent_type` schema field entirely (historical schema).
+
 ## Dependency Graph
 
 ```mermaid
@@ -636,7 +708,7 @@ Merge rules:
 
 `run.behavior` > `agent.behavior` > defaults (field-by-field merge).
 
-Defaults: unlimited turns (set `maxTurns` as a safety net), `maxTokens: 16384`, level-based thinking; `cache: true`, `dedupReads: true`, `requireReadBeforeEdit: false`, `maxConcurrentTools: 10`, `compactStrategy: 'off'`, `compactThreshold: 128 KiB`, `compactKeepTurns: 4`, `toolDisclosure: 'eager'`, `readLineNumbers: true`, `elideStaleReads: false`. All other knobs (`toolOutputBudget`, `dedupTools`, `toolBudgets`, `thinkingDecay`, `toolSearch`, `persistThreshold`, `persistDir`, `persistExcludeTools`, `persistMaxBytes`, `maxCostUsd`, `maxTotalTokens`) are `undefined`. The chat-layer profiles (`BUILD_AGENT` / `PLAN_AGENT`) override several of these — see CHAT.md → Agents.
+Defaults: unlimited turns (set `maxTurns` as a safety net), `maxTokens: 16384`, level-based thinking; `cache: true`, `dedupReads: true`, `requireReadBeforeEdit: false`, `maxConcurrentTools: 10`, `compactStrategy: 'off'`, `compactThreshold: 128 KiB`, `compactKeepTurns: 4`, `toolDisclosure: 'eager'`, `readLineNumbers: true`, `elideStaleReads: false`, `surfaceMcpInstructions: true`, `maxConsecutivePauseTurns: 5`. All other knobs (`toolOutputBudget`, `dedupTools`, `toolBudgets`, `thinkingDecay`, `toolSearch`, `persistThreshold`, `persistDir`, `persistExcludeTools`, `persistMaxBytes`, `maxCostUsd`, `maxTotalTokens`, `retry`) are `undefined` (`retry` defaults to 3 attempts with 1s → 30s exponential backoff when absent). The chat-layer profiles (`BUILD_AGENT` / `PLAN_AGENT`) override several of these — see CHAT.md → Agents.
 
 **`toolOutputBudget`** (off by default). The loop sums every tool result's `outputBytes` after `tool:transform`, so consumer truncation counts. On overshoot, a synthetic user message is appended:
 
@@ -644,11 +716,16 @@ Defaults: unlimited turns (set `maxTurns` as a safety net), `maxTokens: 16384`,
 
 `budget:exceeded` fires with `{ turn, turnId, bytes, budget }`. The next turn picks up the message as latest input — model self-compacts instead of being cut.
 
-**`compactStrategy: 'tail'`** — client-side companion for non-Anthropic providers. After `sanitizeStoredToolResults` and before `context:transform`, the loop sums tool-result bytes; on overshoot, `tool_result` blocks older than `compactKeepTurns` are replaced with a stub. Text and image blocks pass through; `session.turns` is untouched. Anthropic users should prefer the server-side `context-management-2025-06-27` beta (token-accurate) via `anthropic({ extraBetas, contextManagement })`.
+**`compactStrategy: 'tail' | CompactFunction`** — client-side companion for non-Anthropic providers. `'tail'` sums tool-result bytes after `sanitizeStoredToolResults` and before `context:transform`; on overshoot, `tool_result` blocks older than `compactKeepTurns` are replaced with a stub. Text and image blocks pass through; `session.turns` is untouched. Anthropic users should prefer the server-side `context-management-2025-06-27` beta (token-accurate) via `anthropic({ extraBetas, contextManagement })`. Pluggable form: pass a `(messages, { threshold, keepTurns, totalBytes }) => messages | Promise<messages>` for LLM-summary or custom semantic compaction — same wire-only contract, must preserve `tool_use ↔ tool_result` adjacency and the trailing user message. Throws degrade gracefully (logged via `console.error`, original payload survives).
 
 **`dedupReads` + `requireReadBeforeEdit`** share the same per-session `WeakMap<Session, Map<canonicalAbsPath, { contentHash, offset, limit, maxBytes, mtimeMs }>>`. The key is the canonical absolute path (via `node:path.resolve(handle.cwd, modelProvidedPath)`) so all path shapes the model can write — `src/x`, `./src/x`, `/abs/cwd/src/x` — converge on one entry. Map population happens whenever **either** feature is enabled; the dedup *short-circuit* (returning the "unchanged since the previous read" stub) is what `dedupReads` actually gates. This decoupling means `dedupReads: false` no longer breaks the `requireReadBeforeEdit` guard. `edit` / `multi_edit` reject when no entry exists or the on-disk hash drifted; both update the hash on success so chained edits don't need re-reads. Optional `AgentOptions.readState` (also exposed on `ToolContext.readState`) forwards an explicit map — used by `createSpawnTool({ shareReadState: true })` so a sessionless child still feeds the parent's tracking without sharing turn persistence. GC'd with the session when no explicit map is in play.
 
-**`dedupTools`** generalizes the same pattern via a consumer hasher per tool. Parallel `WeakMap<Session, Map<toolName, { hash, result }>>` keeps only the most recent hash. On hit, the prior result replays verbatim — substitute path fires `tool:transform` + `tool:after` so budgets stay coherent. Tools with side effects or non-deterministic outputs MUST NOT be listed.
+**`dedupTools`** generalizes the same pattern via a consumer hasher per tool. Parallel `WeakMap<Session, Map<toolName, { hash, result, repeats }>>` keeps only the most recent hash. Two forms:
+
+- **Hasher function** (legacy / `mode: 'replay'`) — on hit, the prior result replays verbatim. Substitute path fires `tool:transform` + `tool:after` so budgets stay coherent. Makes loops cheap, doesn't break them.
+- **Config object with `mode: 'block-after'`** — `{ hasher, mode: 'block-after', threshold, reason? }`. Replays for the first `threshold − 1` identical calls; the `threshold`-th identical call (and all subsequent ones) gets refused via `tool:gate` `ctx.block = true` with `Blocked: <reason>`. Counter is sticky on the same hash — once the cap trips it stays tripped until a different input resets the counter. `threshold` defaults to `4`, clamps at `2`. `reason` accepts a string or `(input, count) => string`; default is `"Identical \`<tool>\` call repeated N times — break the loop by changing your approach or moving on to a different step."`.
+
+Tools with side effects or non-deterministic outputs MUST NOT be listed (no safety net beyond the consumer hasher).
 
 **`toolBudgets`** caps per-tool calls per run. When `runToolCounts[name] >= max`, fires `onExceed`: `'block'` refuses with `Blocked: <message>`, `'steer'` enqueues a synthetic user message (one per tool per run, deduped). Function form returns `{ mode, message }` dynamically. Fires `tool-budget:exceeded` (distinct from byte-level `budget:exceeded`). Counts include dedup substitutes by design.
 
@@ -660,6 +737,10 @@ Defaults: unlimited turns (set `maxTurns` as a safety net), `maxTokens: 16384`,
 
 **Run-level budget circuit breaker** (`behavior.maxCostUsd` + `behavior.maxTotalTokens`). Soft caps the cumulative spend / token consumption of a single `agent.run()`. Checked **after** each turn (post-`turn:after` + `usage` hooks), so the breaching turn's numbers are visible before the throw lands. Trips throw `AgentBudgetExceededError` (`limit: 'cost' | 'tokens'`, `limitValue`, `actualValue`); the agent finalizes the session run as `'aborted'` so the persisted record distinguishes operator-imposed stops from runtime errors. Cost check wins when both axes would trip on the same turn (operators set ceilings against dollar accounting). Token ledger sums `input + output` only — cache reads/creates are billed at a discount and counting them at par would under-estimate affordability. `0` / negative / non-finite values disable the corresponding axis. Off by default; `maxTurns` is the count-based companion.
 
+**`maxConsecutivePauseTurns`** caps consecutive empty `pause_turn` recoveries (Anthropic 4.6+ streaming edge case where the model returns a `pause_turn` stop reason with no text and no tool calls). Each empty pause counts; any productive turn — text, thinking, OR tool calls — resets the counter. When the counter reaches the cap, the loop exits cleanly (no `agent:abort` fire — this is graceful termination, not user-driven cancel). The last `TurnUsage.finishReason` stays `'pause'` so consumers detect pause exhaustion from `stats`. Default `5`; set `0` to disable.
+
+**Retry-with-backoff** (`behavior.retry`: `{ maxAttempts, initialDelayMs, maxDelayMs }`). Wraps each `provider.stream()` call. Triggers only when `Provider.classifyError` returns `{ kind: 'provider_error', retryable: true }` (429, 5xx, Anthropic `overloaded_error` / `api_error` / `timeout_error` SSE events, OpenAI-compat stream truncation, OpenAI Codex transient messages) **and** nothing has streamed yet this turn — the partial-output guard avoids replaying content the user already saw; prefill-continuation (replaying with the partial assistant response prefilled so the model continues from there) is a separate, larger change. Fires `stream:retry` before each backoff sleep with `{ attempt, nextAttempt, delayMs, err, statusCode?, requestId? }`; `stream:error` only fires on the terminal failure. Backoff is `min(maxDelayMs, initialDelayMs * 2^(attempt-1))` with full jitter (`Math.random() * computed`); `retry-after` / `retry-after-ms` headers, when present on the error, override the schedule (still capped at `maxDelayMs`). The sleep is `signal`-aware so `agent.abort()` cancels cleanly. Defaults: `maxAttempts: 3`, `initialDelayMs: 1000`, `maxDelayMs: 30_000`. Set `maxAttempts: 1` to disable. The Anthropic SDK's own pre-stream retry (default `maxRetries: 2` for the initial HTTP request) sits below this layer; the loop-level retry covers mid-stream errors the SDK can't replay.
+
 ## Related
 
 - `docs/SKILL.md` — public API surface (createAgent, providers, presets, hooks, sessions, skills, MCP).

package/docs/CHAT.md

@@ -333,27 +333,49 @@ Both share `SHARED_BEHAVIOR`:
 
 ## System prompt
 
-Renderer-agnostic fragments designed to be byte-stable across sessions so the Anthropic ephemeral cache breakpoint keeps hitting. Every constant in `agent-prompt` is a self-contained section; the two composers (`buildBuildSystem`, `buildPlanSystem`) assemble them in cache-friendly order.
+Renderer-agnostic fragments designed to be byte-stable across sessions so the Anthropic ephemeral cache breakpoint keeps hitting. Every constant in `agent-prompt` is a self-contained section; the two composers (`buildBuildSystem`, `buildPlanSystem`) assemble them in cache-friendly order around the `SYSTEM_PROMPT_BOUNDARY` marker:
 
 ```ts
 buildBuildSystem({ cwd: projectDir, allowInteraction: true })
-// → IDENTITY_PREFIX + envSection({ cwd, date, platform })
+// STATIC (cached):
+//   IDENTITY_PREFIX
 //   + DOING_TASKS_DOCTRINE + ACTIONS_WITH_CARE_DOCTRINE + TOKEN_DISCIPLINE_DOCTRINE
 //   + SUBAGENT_GUIDANCE + COMMUNICATION_DOCTRINE
 //   + (allowInteraction ? INTERACTION_GUIDANCE : INTERACTION_GUIDANCE_NO_PROMPTS)
+//   + opts.userInstructions
+// ── __ZIDANE_SYSTEM_PROMPT_BOUNDARY__ ──
+// DYNAMIC (not cached):
+//   envSection({ cwd, date, platform })
 
 buildPlanSystem({ cwd: projectDir, allowInteraction: true })
-// → IDENTITY_PREFIX + envSection(...)
+// STATIC (cached):
+//   IDENTITY_PREFIX
 //   + (allowInteraction ? PLAN_MODE_DOCTRINE : PLAN_MODE_DOCTRINE_NO_PROMPTS)
 //   + TOKEN_DISCIPLINE_DOCTRINE + COMMUNICATION_DOCTRINE
 //   + (allowInteraction ? INTERACTION_GUIDANCE : INTERACTION_GUIDANCE_NO_PROMPTS)
+//   + opts.userInstructions
+// ── __ZIDANE_SYSTEM_PROMPT_BOUNDARY__ ──
+// DYNAMIC (not cached):
+//   envSection(...)
 ```
 
+The provider attaches `cache_control` to the static prefix only; per-turn `<env>` rewrites in the TUI re-bill the dynamic suffix but don't invalidate the cached doctrine above. When `cwd` is omitted (no `envSection` to render), the marker is dropped automatically — single-block cache, identical wire bytes to before. See `docs/ARCHITECTURE.md` § Prompt caching > System-prompt boundary for the underlying mechanism.
+
 Pass `allowInteraction: false` (mirror of `Settings.allowInteraction`) to swap in the no-prompts variants — the host should also drop `ask_user` / `present_plan` from the tool set at agent build time so the model can't call tools that aren't reflected in the prompt.
 
-The TUI rebuilds the system prompt at session activation with the project root injected via `envSection({ cwd })`; SDK consumers calling `createAgent({ ...BUILD_AGENT.preset })` directly get the cwd-less variant from the preset and can wrap their own env section.
+**Per-turn env rewrite.** The TUI installs a `system:transform` hook that calls `replaceDynamicSection(ctx.system, envSection(...))` each turn — refreshes the cwd / project root / date below the boundary while leaving the cached static prefix byte-identical:
+
+```ts
+import { replaceDynamicSection } from 'zidane'
+
+agent.hooks.hook('system:transform', (ctx) => {
+  ctx.system = replaceDynamicSection(ctx.system, envSection({ cwd, projectRoot, allowInteraction }))
+})
+```
+
+SDK consumers calling `createAgent({ ...BUILD_AGENT.preset })` directly get the cwd-less, marker-free variant and can wrap their own env section via `appendDynamicSection` / `replaceDynamicSection`.
 
-Custom profiles: import the doctrine fragments and spread them in any order — `buildBuildSystem` is just one composition.
+Custom profiles: import the doctrine fragments and spread them in any order — `buildBuildSystem` is just one composition. Use `joinSystemPrompt(static, dynamic)` to opt into the boundary in your own composer, or skip the marker entirely for whole-prompt caching.
 
 ## Settings
 

package/docs/RESTATE.md

@@ -188,7 +188,7 @@ createAgent({
 |---|---|
 | Crash between turn N and N+1 | Re-enter the handler. Journal replays turns 1..N from cache. Turn N+1 runs live. |
 | Crash mid-tool-call | Re-enter. Journal replays prior turns + already-completed tools. The in-flight tool re-executes (Restate didn't see it complete). Tools that should not be re-run on retry need application-level idempotency (e.g. a `requestId` in the API call). |
-| Provider rate limit / 5xx | `restateProvider`'s default `maxRetryAttempts: 3` retries inside the journal entry. Beyond that, surfaces as `AgentProviderError`. |
+| Provider rate limit / 5xx | The agent loop's `behavior.retry` (3 attempts, exponential backoff) runs first, inside a single journal entry. If still failing, `restateProvider`'s default `maxRetryAttempts: 3` retries the whole journal entry. Beyond that, surfaces as `AgentProviderError`. |
 | Tool throws | `restateTool`'s default `maxRetryAttempts: 1` — no blind retry. The error is journaled; replay returns the same error. |
 | Restate runtime down | Handler invocations queue / fail at the SDK transport layer; Zidane never sees them. Recovery is operational, not in-app. |
 

package/docs/SKILL.md

@@ -222,8 +222,8 @@ Alias only when semantically equivalent. `shell → Bash` is safe; `list_files
 | `edit` | Surgical `old_string` → `new_string`. Clear errors on non-unique (unless `replace_all`) / not-found (with nearest-match preview). |
 | `multiEdit` | Sequential edits to one file. Best-effort, per-hunk — each step runs against the file as left by the previous APPLIED step; a per-step rejection is recorded against that step alone, siblings still run. All-applied → legacy `Edited <path>: applied N edits (M replacements).`; any failure → header + per-failure lines + `<edit-outcomes>` block. Per-edit approval is a host concern: the chat layer's `tool:gate` rebinds `ctx.input.edits` to the user-approved subset before the body runs, then a `tool:transform` hook merges body + approval outcomes and appends the canonical `<edit-outcomes>` annotation (see `docs/CHAT.md`). |
 | `listFiles` | Directory listing. |
-| `glob` | `**`, `*`, `?` pattern matching via Bun.Glob; shells out in docker/sandbox. |
-| `grep` | ripgrep + Bun.Glob fallback. Full Claude Code Grep semantics. `head_limit=250`, `offset` paginates. |
+| `glob` | `**`, `*`, `?` pattern matching via `node:fs/promises` glob; shells out in docker/sandbox. |
+| `grep` | ripgrep + `node:fs/promises` glob fallback. Full Claude Code Grep semantics. `head_limit=250`, `offset` paginates. |
 | `spawn` | Sub-agent delegation (via `createSpawnTool`). |
 | `createInteractionTool` | HITL factory (not a tool — instantiate per use). |
 
@@ -320,7 +320,7 @@ Hooks fire at every lifecycle point via [hookable](https://github.com/unjs/hooka
 | `stream:end` | Text stream complete (only if text present) | — | `text, turnId` |
 | `turn:after` | Assistant turn complete (always fires, even on error) | — | `turn, turnId, usage, message, toolCounts: { turn, run }` |
 | `tool-results:after` | After the user-role tool-results turn is pushed (persistence seam — write the pair together) | — | `turn, turnId, message, results: readonly ToolResult[]` |
-| `tool:gate` | Before each tool call | **yes** (`block, reason, result?`) | `turnId, callId, name, displayName, input, runToolCounts` |
+| `tool:gate` | Before each tool call | **yes** (`block, reason, result?`) | `turnId, callId, name, displayName, input, runToolCounts` — set `block` to refuse with `tool_result.content = "Blocked: <reason>"` + `is_error: true` (pinned contract); set `result` to substitute and skip execute (fires `tool:transform` + `tool:after`); `block` wins over `result` |
 | `tool:before` | Tool execution starts | — | `turnId, callId, name, displayName, input, runToolCounts, priorContent?` |
 | `tool:unknown` | Model called an unregistered tool | **yes** (`result?, suppressError`) | `turnId, callId, name, displayName, input` |
 | `validation:reject` | Tool args failed validation (after auto-coerce) | — | `+ reason: string, schema: Record<string, unknown>` |
@@ -430,6 +430,16 @@ await agent.destroy()       // clean up execution + MCP
 
 `cancelTool` returns `true` when a live call was flipped, `false` otherwise (idempotent). The matching call's `ctx.signal` aborts, `tool:cancelled` fires, and the wire result becomes `TOOL_USE_CANCELLED_MESSAGE` with `isError: true` — other parallel calls in the same batch keep running, and the assistant turn closes normally on the next batch boundary. Distinguished from `abort()` (whole-run abort, batch-layer `INTERRUPT_MESSAGE_FOR_TOOL_USE`) and `TOOL_USE_SKIPPED_MESSAGE` (steered out) so consumers can split the three causes by string match.
 
+Agents also implement `Symbol.asyncDispose` (aliased to `destroy`) so they work with TC39 explicit-resource-management:
+
+```ts
+await using agent = createAgent({ provider, mcpServers })
+await agent.run({ prompt: 'go' })
+// destroy() runs automatically at scope exit
+```
+
+Requires Node 20+ (or Bun). Idempotent, same semantics as calling `destroy()` directly.
+
 ## Background tasks
 
 The `shell` tool accepts an optional `run_in_background: true` flag that returns immediately with a task handle (`bash_<n>`) instead of blocking the model's turn. The companion `shell_kill` tool terminates a running task. The framework owns the lifecycle:
@@ -564,6 +574,22 @@ Two **independent** flags control what crosses the parent/child boundary:
 
 Use `shareReadState: true` (without `persist`) when you want the parent's `requireReadBeforeEdit` gate to honor reads the child performed, without polluting the parent's session with child turns. The gate's error message now hints at this when the entry is missing — re-read in the calling context OR opt into one of the sharing flags.
 
+### Subagent type registry
+
+When configured, the spawn tool's input schema gains a `subagent_type` enum the model uses to pick a per-type preset. Mirrors the Claude Code SDK surface — trained models routinely emit `subagent_type: 'Explore' | 'Plan' | 'Verification' | 'general-purpose'` and the registry routes that decision into the framework instead of forcing every host to invent its own dispatch layer.
+
+```ts
+createSpawnTool({
+  subagents: {
+    Explore: { description: 'read-only research', readonly: true },
+    Plan: { description: 'design changes', system: 'You are the planning subagent. Do not edit.' },
+    Verification: { description: 'run tests', tools: ['shell', 'read_file'] },
+  },
+})
+```
+
+Per-type overlay fields: `system` (preset system prompt — per-call `input.system` still wins), `tools: string[]` (canonical-name allow-list, strict subset of the parent's tools), `readonly: true` (convenience for `['read_file', 'grep', 'glob', 'list_files']`), `description` (rendered into the schema for model self-selection). Unknown type names degrade to `'general-purpose'` (no overlay, no error) so models emitting types the host didn't wire keep working. Empty / unset registry drops the schema field entirely.
+
 ## Interaction Tool
 
 Lets the agent request structured input. Not in any preset by default. `onRequest` can be async — the agent waits.
@@ -624,6 +650,16 @@ For `transport: 'stdio'`, `env` **merges** on top of the MCP SDK's inherited-env
 
 `enabledTools` / `disabledTools` / `toolFilter` apply at config time (before registration); the `mcp:tools:filter` hook is the runtime escape hatch when host-side policy depends on the user / environment. Config filters compose: allow-list first, then deny-list, then predicate, then hook. `cachedTools` skips the `tools/list` round-trip when the host can supply the schemas itself; `lazyConnect: true` (requires `cachedTools`, incompatible with `auth: 'oauth'`) defers `client.connect()` to the first `tools/call`.
 
+### Server instructions
+
+Servers can return an `instructions` payload on the MCP `initialize` handshake — free-form text telling the model how to use the server's tools ("project is provisioned, use `apply_migration` directly"). Zidane captures these via the SDK's `getInstructions()` and renders them into the system prompt as a `# MCP Server Instructions` section, grouped by server name in `mcpServers` config order. Lives on the static (cached) half of the system prompt, so it rides the prefix cache.
+
+Opt out with `behavior.surfaceMcpInstructions: false` (default `true`). Only eager-connect servers contribute — `lazyConnect: true` servers would have to force a connection to fetch the field, which defeats the deferral.
+
+### Tool naming
+
+Canonical wire form is `mcp_<server>_<tool>` (single underscore). Models trained on the Claude Code SDK may emit the double-underscore form (`mcp__<server>__<tool>`); zidane auto-recognises that as an inbound alias for every MCP tool, so a model calling `mcp__supabase__apply_migration` against a server registered as `mcp_supabase_apply_migration` resolves correctly. Inbound-only — the wire still advertises the single-underscore canonical, so the provider tool-list bytes don't change.
+
 ## Progressive tool disclosure
 
 `behavior.toolDisclosure: 'lazy'` swaps MCP tools for a name-only catalog and auto-injects a `tool_search` native tool. Native + skill tools stay eager.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zidane",
-  "version": "5.6.11",
+  "version": "5.6.13",
   "description": "an agent that goes straight to the goal",
   "type": "module",
   "private": false,
@@ -82,6 +82,9 @@
     "tui",
     "tui/npm/*"
   ],
+  "engines": {
+    "bun": ">=1.3.0"
+  },
   "scripts": {
     "auth": "bun run src/auth.ts",
     "start": "bun run src/start.ts",
@@ -97,7 +100,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@mariozechner/pi-ai": "0.70.5",
+    "@earendil-works/pi-ai": "0.76.0",
     "chalk": "^5.6.2",
     "fzf": "^0.5.2",
     "hookable": "^6.1.1"

package/dist/agent-C9AKTU_V.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"agent-C9AKTU_V.d.ts","names":[],"sources":["../src/errors.ts","../src/types.ts","../src/providers/anthropic.ts","../src/providers/cerebras.ts","../src/providers/openai.ts","../src/providers/openai-compat.ts","../src/providers/openrouter.ts","../src/providers/schema-sanitize.ts","../src/providers/index.ts","../src/session/file-map.ts","../src/session/memory.ts","../src/session/messages.ts","../src/session/remote.ts","../src/session/index.ts","../src/skills/types.ts","../src/tools/read-state.ts","../src/tools/types.ts","../src/mcp/index.ts","../src/skills/activation.ts","../src/agent.ts"],"mappings":"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"}

package/dist/index-6f4T7Gc0.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-6f4T7Gc0.d.ts","names":[],"sources":["../src/compact/messages.ts","../src/compact/prompt.ts","../src/compact/errors.ts","../src/compact/compact.ts","../src/compact/restore.ts","../src/compact/utils.ts","../src/logger.ts","../src/loop.ts","../src/loop-persistence.ts","../src/mcp/oauth-provider.ts","../src/mcp/login.ts","../src/mcp/oauth-callback.ts","../src/metrics.ts","../src/run-summary.ts","../src/stats.ts","../src/tools/edit.ts","../src/tools/glob.ts","../src/tools/grep.ts","../src/tools/interaction.ts","../src/tools/list-files.ts","../src/tools/multi-edit.ts","../src/tools/read-file.ts","../src/tools/shell.ts","../src/tools/shell-kill.ts","../src/tools/skills-read.ts","../src/tools/skills-run-script.ts","../src/tools/skills-use.ts","../src/tools/spawn.ts","../src/tools/tool-search.ts","../src/tools/validation.ts","../src/tools/write-file.ts","../src/tracing.ts","../src/zod.ts","../src/presets/basic.ts","../src/presets/index.ts"],"mappings":"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"}