zidane 6.2.24 → 6.2.27

package/dist/{agent-tLfGSSQw.js → agent-DIe8yzcb.js}

@@ -5,9 +5,10 @@ import { a as hydrateReadStateFromSessionAsync, c as resolveReadStateMap, n as g
 import { n as estimateTokens, r as utf8ByteLength } from "./utils-ngQzYzZD.js";
 import { t as buildContextBreakdown } from "./context-breakdown-Dzo25N45.js";
 import { a as formatDuration, c as previewLine, o as formatTaskStatus, s as formatTaskSummary } from "./format-BF745pLL.js";
-import { c as parseGitLsFiles, r as isOutputExceededMessage, s as GIT_LS_FILES_COMMAND } from "./output-cap-kBUHBlnq.js";
+import { i as parseGitLsFiles, r as GIT_LS_FILES_COMMAND } from "./glob-DluQFSw1.js";
 import { n as alwaysQuote, r as shellQuote } from "./exec-file-size-PXkr-MGA.js";
-import { r as createProcessContext, t as resolveDetachedTasksCapability } from "./contexts-A4ep-iJs.js";
+import { i as isOutputExceededMessage } from "./output-cap-DM1HrgIp.js";
+import { r as createProcessContext, t as resolveDetachedTasksCapability } from "./contexts-0rmrBhTK.js";
 import { i as AgentProviderError, l as errorMessage, m as toTypedError, n as AgentBudgetExceededError, o as AgentToolPairingError, t as AgentAbortedError, u as isAbortLikeError } from "./errors-DJUxZg9b.js";
 import { C as stripShellInterpolations, O as validateResourcePathReal, S as interpolateShellCommands, _ as lastLine, b as resolveSubdirRoot, d as installAllowedToolsGate, f as createSkillActivationState, g as fetchInstallSource, h as defaultWhich, j as projectUserPaths, l as buildCatalog, m as defaultExec, p as InstallSourceError, t as resolveSkills, v as parseInstallSource, x as escapeXml, y as resolveNpmVersion } from "./resolve-BPTA1RpX.js";
 import { n as writeFileAtomicAsync, t as writeFileAtomic } from "./atomic-write-B7zr1ddF.js";
@@ -16,8 +17,8 @@ import { n as reconcileImageMediaType } from "./media-sniff-Bn76JxAu.js";
 import { c as wrapDiscoveredMcpTools, i as nonOwningMcpView, n as connectMcpServers, r as deriveMcpToolMeta } from "./mcp-H6bqyM94.js";
 import { C as canonicalizePrompt, S as buildPromptMessage } from "./openai-compat-pHI0kBWH.js";
 import { appendStaticSection, renderSystemForWire } from "./prompt.js";
-import { a as detectTurnInterruption, c as filterUnresolvedToolUses, d as remintDuplicateToolCallIds, f as resolveContentRefsInMessages, n as SYNTHETIC_TOOL_RESULT_PLACEHOLDER, o as ensureEndsWithUserMessage, s as ensureToolResultPairing } from "./messages-CvHfYB7f.js";
-import { a as getExtensionSessionState, c as setExtensionSessionState, l as withExtensionSession, n as currentExtensionSession, r as deleteExtensionSessionState, s as resumeChainRunIds } from "./session-jLsc_kMH.js";
+import { a as detectTurnInterruption, c as filterUnresolvedToolUses, f as remintDuplicateToolCallIds, n as SYNTHETIC_TOOL_RESULT_PLACEHOLDER, o as ensureEndsWithUserMessage, p as resolveContentRefsInMessages, s as ensureToolResultPairing } from "./messages-Dy9t7DbQ.js";
+import { a as getExtensionSessionState, c as setExtensionSessionState, l as withExtensionSession, n as currentExtensionSession, r as deleteExtensionSessionState, s as resumeChainRunIds } from "./session-DkVnYGm9.js";
 import { n as flattenTurns, r as formatTokenUsage, t as effectiveInputFromTurn } from "./stats-DAKBEKjc.js";
 import { a as withInactivityTimeout, i as settleWithinTimeout, n as linkAbortSignal, o as withTimeout$1, r as resolveTimeoutMs, t as OperationTimeoutError } from "./timeout-BDetbuN6.js";
 import { createRequire } from "node:module";
@@ -25,7 +26,7 @@ import { basename, delimiter, dirname, isAbsolute, join, resolve, sep } from "no
 import { createHooks } from "hookable";
 import { Buffer } from "node:buffer";
 import { cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { readdir, rm, stat, unlink } from "node:fs/promises";
+import { copyFile, mkdir, readdir, rm, stat, unlink } from "node:fs/promises";
 import { pathToFileURL } from "node:url";
 import { homedir, tmpdir } from "node:os";
 import { createHash } from "node:crypto";
@@ -215,6 +216,7 @@ const DEFAULT_FAILED_MUTATIONS = 3;
 const DEFAULT_NOOP_MUTATIONS = 3;
 const DEFAULT_VALIDATION_REJECTS = 3;
 const DEFAULT_TOOL_ERRORS = 3;
+const DEFAULT_SINGLE_CALL_TURNS = 3;
 const DEFAULT_MAX_NUDGES$1 = 3;
 const DEFAULT_READ_ONLY_TOOLS = /* @__PURE__ */ new Set([
 	"read_file",
@@ -228,6 +230,17 @@ const DEFAULT_READ_ONLY_TOOLS = /* @__PURE__ */ new Set([
 	"skills_read",
 	"todoread"
 ]);
+/**
+* Discovery chains are inherently sequential — each call's input needs the
+* prior result (`tool_search` → load → call, `skills_read` after `skills_use`)
+* and `todoread` is a singleton by nature. Their single-call turns are not
+* "unbatched", so they reset the streak instead of extending it.
+*/
+const SINGLE_CALL_EXEMPT_TOOLS = /* @__PURE__ */ new Set([
+	"tool_search",
+	"skills_read",
+	"todoread"
+]);
 function threshold(value, fallback) {
 	if (value === false) return false;
 	return clampPositiveInt(value, fallback);
@@ -239,6 +252,7 @@ function defaultMessage(kind) {
 		case "noopMutations": return "Several mutation calls produced no file changes. Check whether the requested state is already reached; if so, report that instead of issuing more edits.";
 		case "validationRejects": return "Several tool calls had invalid arguments. Re-check the advertised tool schema and emit one well-formed native tool call.";
 		case "toolErrors": return "Several tool calls errored. Pivot from repeating the failing call: inspect the error, adjust the input or approach, then continue with one concrete action.";
+		case "singleCallTurns": return "You are issuing one tool call per response. Independent read-only calls (file reads, searches, listings) have no dependencies between them — batch all of them into a single response instead of one per turn. Only sequence calls whose inputs depend on a previous result.";
 	}
 }
 function messageFor(config, kind, count) {
@@ -256,10 +270,12 @@ function installProgressNudges(hooks, config, deps) {
 	const noopMutations = threshold(resolvedConfig.noopMutations, DEFAULT_NOOP_MUTATIONS);
 	const validationRejects = threshold(resolvedConfig.validationRejects, DEFAULT_VALIDATION_REJECTS);
 	const toolErrors = threshold(resolvedConfig.toolErrors, DEFAULT_TOOL_ERRORS);
+	const singleCallTurns = resolvedConfig.singleCallTurns === void 0 ? false : threshold(resolvedConfig.singleCallTurns, DEFAULT_SINGLE_CALL_TURNS);
 	const readOnlyTools = /* @__PURE__ */ new Set([...resolvedConfig.readOnlyTools ?? DEFAULT_READ_ONLY_TOOLS]);
 	let nudgeCount = 0;
 	const fired = /* @__PURE__ */ new Set();
 	let consecutiveReadOnlyTurns = 0;
+	let consecutiveSingleCallTurns = 0;
 	let consecutiveFailedMutations = 0;
 	let consecutiveNoopMutations = 0;
 	let validationRejectCount = 0;
@@ -301,8 +317,17 @@ function installProgressNudges(hooks, config, deps) {
 		}),
 		hooks.hook("turn:after", (ctx) => {
 			const entries = Object.entries(ctx.toolCounts.turn).filter(([, count]) => count > 0);
-			if (entries.length === 0) return;
-			if (!entries.every(([tool]) => readOnlyTools.has(tool))) {
+			if (entries.length === 0) {
+				consecutiveSingleCallTurns = 0;
+				return;
+			}
+			const readOnly = entries.every(([tool]) => readOnlyTools.has(tool));
+			const totalCalls = entries.reduce((sum, [, count]) => sum + count, 0);
+			if (readOnly && totalCalls === 1 && !SINGLE_CALL_EXEMPT_TOOLS.has(entries[0][0])) {
+				consecutiveSingleCallTurns++;
+				maybeNudge("singleCallTurns", consecutiveSingleCallTurns, singleCallTurns);
+			} else consecutiveSingleCallTurns = 0;
+			if (!readOnly) {
 				consecutiveReadOnlyTurns = 0;
 				return;
 			}
@@ -3316,6 +3341,11 @@ function createInteractionTool(options) {
 function entryPath(entry) {
 	return typeof entry === "string" ? entry : entry.path;
 }
+/**
+* Entry ceiling — matches glob's default limit so a pathological
+* 100k-entry directory can't flood the context window.
+*/
+const MAX_ENTRIES = 1e3;
 const listFiles = {
 	isConcurrencySafe: true,
 	spec: {
@@ -3333,7 +3363,9 @@ const listFiles = {
 	async execute({ path }, ctx) {
 		const target = path || ".";
 		try {
-			return (await ctx.execution.listFiles(ctx.handle, target)).map(entryPath).join("\n") || "(empty directory)";
+			const entries = await ctx.execution.listFiles(ctx.handle, target);
+			if (entries.length > MAX_ENTRIES) return `${entries.slice(0, MAX_ENTRIES).map(entryPath).join("\n")}\n…(${entries.length - MAX_ENTRIES} more entries omitted; use glob with a narrower pattern)`;
+			return entries.map(entryPath).join("\n") || "(empty directory)";
 		} catch (err) {
 			ctx.reportOutcome?.("failed");
 			const message = errorMessage(err);
@@ -3964,6 +3996,8 @@ const readFile$1 = {
 		if (extMedia) {
 			const sizeCap = normalizeReadFileInteger(maxBytes, defaults.attachmentMaxBytes);
 			try {
+				const probed = await ctx.execution.fileSize?.(ctx.handle, path) ?? null;
+				if (probed !== null && sizeCap > 0 && probed > sizeCap) return `[image too large to inline: ${path}, ${probed} bytes (cap ${sizeCap}). Raise maxBytes, or use shell to inspect.]`;
 				const { base64, byteLength } = await readFileAsBase64(ctx.execution, ctx.handle, path);
 				if (sizeCap > 0 && byteLength > sizeCap) return `[image too large to inline: ${path}, ${byteLength} bytes (cap ${sizeCap}). Raise maxBytes, or use shell to inspect.]`;
 				const imgMedia = reconcileImageMediaType(extMedia, base64);
@@ -3984,6 +4018,8 @@ const readFile$1 = {
 		if (docMedia) {
 			const sizeCap = normalizeReadFileInteger(maxBytes, defaults.attachmentMaxBytes);
 			try {
+				const probed = await ctx.execution.fileSize?.(ctx.handle, path) ?? null;
+				if (probed !== null && sizeCap > 0 && probed > sizeCap) return `[document too large to attach: ${path}, ${probed} bytes (cap ${sizeCap}). Raise maxBytes, or use shell/read text extraction to inspect.]`;
 				const { base64, byteLength } = await readFileAsBase64(ctx.execution, ctx.handle, path);
 				if (sizeCap > 0 && byteLength > sizeCap) return `[document too large to attach: ${path}, ${byteLength} bytes (cap ${sizeCap}). Raise maxBytes, or use shell/read text extraction to inspect.]`;
 				if (docMedia === "application/pdf" && !isPdfBase64(base64)) return `[binary file: ${path}, ${byteLength} bytes; extension suggests PDF but file header does not start with %PDF-]`;
@@ -5344,7 +5380,8 @@ function buildSpawnTool(options, state) {
 				let index = childRuns.findIndex((r) => r.label === wanted);
 				if (index < 0) {
 					const labelMatch = /^child-(\d+)$/.exec(wanted);
-					index = labelMatch ? Number(labelMatch[1]) - 1 : childRuns.findIndex((r) => r.id === wanted);
+					const anyLabeled = childRuns.some((r) => r.label !== void 0);
+					index = labelMatch && !anyLabeled ? Number(labelMatch[1]) - 1 : childRuns.findIndex((r) => r.id === wanted);
 				}
 				const run = index >= 0 ? childRuns[index] : void 0;
 				if (!run) return {
@@ -9415,6 +9452,158 @@ async function persistElidedToolResults(messages, items, opts) {
 	});
 }
 /**
+* Subdirectory of the session persist dir holding blobs written by
+* {@link releaseReplacedTurnContent}. Deliberately separate from the
+* top-level `<callId>.txt` blobs: once a released stub round-trips into the
+* session store (`session.save()` is delete-all-and-reinsert), the blob is
+* the ONLY remaining copy of that content — it must never be LRU-evicted by
+* {@link enforcePersistDirCap}, whose sweep only scans top-level `*.txt`
+* files. Released blobs live and die with the session
+* ({@link cleanupPersistedSession} removes the dir recursively).
+*/
+const RELEASED_BLOB_SUBDIR = "released";
+/**
+* Post-compaction memory release — swap the in-memory bodies of turns a
+* compaction summary just replaced for recoverable `<persisted-output …>`
+* stubs, so a long-lived host process stops retaining tool output the model
+* can never see again (`applyCompactSummaryCutoff` elides these turns from
+* every future wire projection).
+*
+* MUTATES the passed turn objects in place — that is the point: the session's
+* `data.turns` is the single canonical in-memory copy, and releasing anywhere
+* else would leave it pinned. Only `tool_result` blocks with large string /
+* all-text outputs are touched (media already lives behind content refs);
+* everything else — prompts, assistant text, thinking — is kept verbatim.
+*
+* Durability contract: each released output is written to
+* `<persistDir>/released/<callId>.txt` first, so even if a host later
+* round-trips the stubbed turns to the session store, the content stays
+* retrievable from the stub's path. Blobs are always written HOST-side
+* (never through an execution context): the session store is host-local,
+* so its recovery copy must be too — a sandboxed context write would
+* strand the only durable copy inside an ephemeral container. A blob write
+* failure skips that block — the original stays in memory rather than
+* being lost.
+*
+* Opt-in via `autoCompact.releaseReplacedTurns`: hosts that need the lossless
+* inline transcript (SFT capture, exporters) keep the default-off behavior.
+*/
+async function releaseReplacedTurnContent(turns, replacedTurnIds, opts) {
+	const result = {
+		releasedBlocks: 0,
+		releasedBytes: 0
+	};
+	if (replacedTurnIds.size === 0 || !isAbsolute(opts.persistDir)) return result;
+	const minBytes = opts.minBytes ?? 2048;
+	const maxDirBytes = opts.maxDirBytes ?? 268435456;
+	const blobDir = join(opts.persistDir, RELEASED_BLOB_SUBDIR);
+	let dirBytes = 0;
+	try {
+		for (const entry of await readdir(blobDir)) try {
+			dirBytes += (await stat(join(blobDir, entry))).size;
+		} catch {}
+	} catch {}
+	const replaced = turns.filter((t) => t.id !== void 0 && replacedTurnIds.has(t.id));
+	const toolNameByCallId = /* @__PURE__ */ new Map();
+	for (const turn of replaced) for (const block of turn.content) if (block.type === "tool_call") toolNameByCallId.set(block.id, block.name);
+	const callIdOccurrences = /* @__PURE__ */ new Map();
+	for (const turn of replaced) for (let i = 0; i < turn.content.length; i++) {
+		const block = turn.content[i];
+		if (block.type !== "tool_result") continue;
+		const ordinal = (callIdOccurrences.get(block.callId) ?? 0) + 1;
+		callIdOccurrences.set(block.callId, ordinal);
+		const text = textForPersistence(block.output);
+		if (text === null || text.startsWith("<persisted-output tool=\"")) continue;
+		const bytes = utf8ByteLength(text);
+		if (bytes < minBytes) continue;
+		if (!SAFE_CALL_ID.test(block.callId) || block.callId.includes("..")) continue;
+		const persistedPath = join(blobDir, ordinal === 1 ? `${block.callId}.txt` : `${block.callId}.${ordinal}.txt`);
+		let exists = false;
+		try {
+			exists = (await stat(persistedPath)).isFile();
+		} catch {
+			exists = false;
+		}
+		if (!exists) {
+			if (dirBytes + bytes > maxDirBytes) continue;
+			try {
+				await writeAtomic(persistedPath, text);
+				dirBytes += bytes;
+			} catch {
+				continue;
+			}
+		}
+		turn.content[i] = {
+			...block,
+			output: buildPersistedStub({
+				toolName: toolNameByCallId.get(block.callId) ?? "tool",
+				originalBytes: bytes,
+				persistedPath,
+				output: text,
+				previewBytes: ELIDE_PERSIST_PREVIEW_BYTES
+			})
+		};
+		result.releasedBlocks++;
+		result.releasedBytes += bytes;
+	}
+	return result;
+}
+/**
+* Re-home `<persisted-output …>` stubs when turns are copied into a NEW
+* session (fork): released blob paths are per-session
+* (`resolvePersistDir` keys on the session id), so a fork that keeps the
+* origin's paths loses its content the moment the origin session is
+* deleted ({@link cleanupPersistedSession} removes the origin's blob dir).
+* Copies each referenced blob under `fromPersistDir` into the same
+* relative location under `toPersistDir` and rewrites the stub's `path`
+* attribute. Copy-on-write: input turns are never mutated (they are
+* usually shared with the origin session's live `data.turns`); a new turn
+* object is returned only where a stub was rewritten. A missing/uncopyable
+* blob leaves that stub pointing at the origin — no worse than before.
+*
+* Prefix matching happens on the XML-escaped attribute text: `escapeXml`
+* maps characters independently, so `escapeXml(a + b)` ===
+* `escapeXml(a) + escapeXml(b)` and a prefix match on escaped text is
+* exact. Blob filenames are `SAFE_CALL_ID`-constrained (`[\w.-]`), so the
+* relative remainder is escape-invariant.
+*/
+async function rehomePersistedStubs(turns, fromPersistDir, toPersistDir) {
+	if (!isAbsolute(fromPersistDir) || !isAbsolute(toPersistDir) || fromPersistDir === toPersistDir) return [...turns];
+	const fromPrefix = `path="${escapeXml(fromPersistDir)}/`;
+	const out = [];
+	for (const turn of turns) {
+		let content;
+		for (let i = 0; i < turn.content.length; i++) {
+			const block = turn.content[i];
+			if (block.type !== "tool_result" || typeof block.output !== "string" || !block.output.startsWith("<persisted-output tool=\"")) continue;
+			const start = block.output.indexOf(fromPrefix);
+			if (start === -1) continue;
+			const restStart = start + fromPrefix.length;
+			const end = block.output.indexOf("\"", restStart);
+			if (end === -1) continue;
+			const relative = block.output.slice(restStart, end);
+			if (relative.includes("..")) continue;
+			try {
+				const target = join(toPersistDir, relative);
+				await mkdir(dirname(target), { recursive: true });
+				await copyFile(join(fromPersistDir, relative), target);
+			} catch {
+				continue;
+			}
+			content ??= [...turn.content];
+			content[i] = {
+				...block,
+				output: `${block.output.slice(0, start)}path="${escapeXml(toPersistDir)}/${relative}${block.output.slice(end)}`
+			};
+		}
+		out.push(content ? {
+			...turn,
+			content
+		} : turn);
+	}
+	return out;
+}
+/**
 * Write-then-rename for atomicity — delegates to the shared
 * {@link writeFileAtomicAsync} helper (unique pid+counter tmp suffix,
 * fsync before rename, tmp cleanup on failure). Creates the parent
@@ -9769,6 +9958,24 @@ function applyCompactSummaryCutoff(turns) {
 const COMPACTION_STUB = "[…elided: older tool output trimmed to fit the context budget.]";
 const COMPACTION_STUB_BYTES = toolOutputByteLength(COMPACTION_STUB);
 const COMPACT_CHUNK_TURNS = 8;
+/**
+* Cross-turn memo for `toolOutputBudgetByteLength`, keyed on the tool_result
+* block object. The wire pipeline preserves block references for unchanged
+* blocks (sanitize/alias/elision copy only what they touch), so the same
+* block objects flow through the byte-accounting loops on every turn of a
+* run. Without the memo, tail compaction re-measures the ENTIRE transcript's
+* tool output each turn — O(total transcript bytes) per turn, O(n²) per run.
+* Blocks are immutable by pipeline convention; a transform that changes an
+* output produces a new object, which simply misses the memo once.
+*/
+const toolResultBudgetBytesMemo = /* @__PURE__ */ new WeakMap();
+function memoizedToolResultBudgetBytes(block) {
+	const hit = toolResultBudgetBytesMemo.get(block);
+	if (hit !== void 0) return hit;
+	const bytes = toolOutputBudgetByteLength(block.output);
+	toolResultBudgetBytesMemo.set(block, bytes);
+	return bytes;
+}
 function applyTailCompaction(messages, threshold, keepTurns, options) {
 	const elidedReadPaths = [];
 	const persistableElided = [];
@@ -9780,7 +9987,7 @@ function applyTailCompaction(messages, threshold, keepTurns, options) {
 		persistableElided
 	};
 	let totalBytes = 0;
-	for (const msg of messages) for (const block of msg.content) if (block.type === "tool_result") totalBytes += toolOutputBudgetByteLength(block.output);
+	for (const msg of messages) for (const block of msg.content) if (block.type === "tool_result") totalBytes += memoizedToolResultBudgetBytes(block);
 	if (totalBytes <= threshold) return {
 		messages,
 		elidedReadPaths,
@@ -9796,7 +10003,7 @@ function applyTailCompaction(messages, threshold, keepTurns, options) {
 	let keptBytes = 0;
 	let budgetCutoff = floorCutoff;
 	for (let i = messages.length - 1; i >= 0; i--) {
-		for (const block of messages[i].content) if (block.type === "tool_result") keptBytes += toolOutputBudgetByteLength(block.output);
+		for (const block of messages[i].content) if (block.type === "tool_result") keptBytes += memoizedToolResultBudgetBytes(block);
 		if (keptBytes > threshold) {
 			budgetCutoff = i + 1;
 			break;
@@ -10418,11 +10625,58 @@ async function runLoop(ctx) {
 		unregisterTtftTool();
 	}
 }
+/**
+* Per-run LRU for resolved content-ref payloads, keyed by `type:ref`.
+*
+* Refs are content-addressed (`attachment://<hash>` and persist-dir blobs are
+* immutable once written), so within a run the same ref always resolves to the
+* same bytes — but the wire pipeline re-resolves EVERY ref in the history on
+* EVERY turn (resolution runs before media age-out, which then discards most
+* of the resolved base64 again). Without this cache an image-heavy session
+* re-reads and re-base64s each attachment from disk once per turn, O(refs)
+* disk I/O per turn → O(turns × refs) per run.
+*
+* Keyed on the LoopContext via WeakMap so the cache dies with the run and no
+* cross-run staleness question arises. Byte-bounded (UTF-8 bytes, measured
+* once at insert — `.length` counts UTF-16 code units and would let the
+* budget retain up to 2× its nominal size on multi-byte text), evicting
+* oldest-first (Map insertion order; hits re-insert to refresh recency).
+*/
+const CONTENT_REF_CACHE_MAX_BYTES = 64 * 1024 * 1024;
+const contentRefCaches = /* @__PURE__ */ new WeakMap();
 async function resolveContentRefsForWire(ctx, messages) {
 	return resolveContentRefsInMessages(messages, { resolveContentRef: async (block) => {
+		const key = `${block.type}:${block.ref}`;
+		let cache = contentRefCaches.get(ctx);
+		if (!cache) {
+			cache = {
+				bytes: 0,
+				entries: /* @__PURE__ */ new Map()
+			};
+			contentRefCaches.set(ctx, cache);
+		}
+		const hit = cache.entries.get(key);
+		if (hit !== void 0) {
+			cache.entries.delete(key);
+			cache.entries.set(key, hit);
+			return { data: hit.data };
+		}
 		const hookCtx = { block };
 		await ctx.hooks.callHook("content-ref:resolve", hookCtx);
 		if (typeof hookCtx.data !== "string") throw new Error(`Content ref "${block.ref}" (${block.type}) was not resolved by a content-ref:resolve hook.`);
+		const dataBytes = Buffer.byteLength(hookCtx.data, "utf8");
+		if (dataBytes <= CONTENT_REF_CACHE_MAX_BYTES) {
+			cache.entries.set(key, {
+				data: hookCtx.data,
+				bytes: dataBytes
+			});
+			cache.bytes += dataBytes;
+			for (const [k, v] of cache.entries) {
+				if (cache.bytes <= CONTENT_REF_CACHE_MAX_BYTES) break;
+				cache.entries.delete(k);
+				cache.bytes -= v.bytes;
+			}
+		}
 		return { data: hookCtx.data };
 	} });
 }
@@ -10587,10 +10841,15 @@ function stripInvalidAnthropicThinking(content) {
 	};
 }
 /**
-* Permanently quarantine historical Anthropic reasoning after the API proves
-* its opaque signature is invalid. Runtime turns and the bound session are
-* separate arrays on resume, so repair both; persist the session with its
-* full turn set (including child runs invisible to the parent runtime).
+* Quarantine historical Anthropic reasoning after the API proves its opaque
+* signature is invalid. Runtime turns and the bound session are separate
+* arrays on resume, so repair both — IN MEMORY ONLY. Durable persistence
+* (`session.save()`) is deliberately deferred to the stream-settle boundary
+* in {@link streamWithWatchdogs}: this function runs inside the provider's
+* `stream()` call stack, where durable-execution hosts (e.g. Restate
+* journaling the provider call) cannot touch their context — an inline
+* save would silently no-op there and the session would re-poison on every
+* run.
 *
 * Turns minted by the CURRENT run are never touched: their signatures are
 * fresh (same account/model that is streaming right now), and Anthropic
@@ -10598,7 +10857,8 @@ function stripInvalidAnthropicThinking(content) {
 * stripping them would trade one 400 for another. An invalid signature is
 * by definition historical (prior run, prior account, or a session edit).
 */
-async function repairInvalidAnthropicThinkingHistory(ctx, streamOptions, repair) {
+function repairInvalidAnthropicThinkingHistory(ctx, streamOptions, repair) {
+	const turnIds = /* @__PURE__ */ new Set();
 	let removed = 0;
 	for (const turn of ctx.turns) {
 		if (turn.runId === ctx.runId) continue;
@@ -10606,6 +10866,7 @@ async function repairInvalidAnthropicThinkingHistory(ctx, streamOptions, repair)
 		if (scrubbed.removed === 0) continue;
 		turn.content = scrubbed.content;
 		removed += scrubbed.removed;
+		if (turn.id !== void 0) turnIds.add(turn.id);
 	}
 	const limit = repair.wireMessageIndex;
 	streamOptions.messages = streamOptions.messages.map((message, index) => {
@@ -10617,34 +10878,72 @@ async function repairInvalidAnthropicThinkingHistory(ctx, streamOptions, repair)
 		} : message;
 	});
 	const session = ctx.session;
-	if (!session) return removed;
+	if (!session) return {
+		removed,
+		turnIds
+	};
 	let sessionRemoved = 0;
 	const sessionTurns = session.turns.map((turn) => {
 		if (turn.runId === ctx.runId) return turn;
 		const scrubbed = stripInvalidAnthropicThinking(turn.content);
 		sessionRemoved += scrubbed.removed;
+		if (scrubbed.removed > 0 && turn.id !== void 0) turnIds.add(turn.id);
 		return scrubbed.removed > 0 ? {
 			...turn,
 			content: scrubbed.content
 		} : turn;
 	});
-	if (sessionRemoved === 0 && removed === 0) return 0;
+	if (sessionRemoved === 0 && removed === 0) return {
+		removed: 0,
+		turnIds
+	};
 	session.setTurns(sessionTurns);
-	try {
-		await session.save();
+	return {
+		removed: removed + sessionRemoved,
+		turnIds
+	};
+}
+/**
+* Flush a deferred thinking-signature repair at the stream-settle boundary:
+* persist the already-repaired session and fire the host-facing
+* `history:repair` hook. Runs OUTSIDE the provider call stack (safe for
+* journaled hosts) and on both stream outcomes — a scrubbed block is
+* invalid regardless of whether the retry ultimately succeeded, and
+* persisting prevents the next run from re-poisoning.
+*/
+async function flushThinkingRepair(ctx, pending) {
+	let persisted = false;
+	if (ctx.session?.store) try {
+		await ctx.session.save();
+		persisted = true;
 	} catch (err) {
 		if (process.env.ZIDANE_DEBUG) process.stderr.write(`[zidane/loop] persisting thinking-signature repair failed: ${errorMessage(err)}\n`);
 	}
-	return Math.max(removed, sessionRemoved);
+	await settledHook(ctx, "hook history:repair", ctx.hooks.callHook("history:repair", {
+		reason: "invalid-anthropic-thinking-signature",
+		runId: ctx.runId,
+		...ctx.session ? { sessionId: ctx.session.id } : {},
+		turnIds: [...pending.turnIds],
+		removedBlocks: pending.removed,
+		persisted
+	}));
 }
 async function streamWithWatchdogs(ctx, options, callbacks, turnId, opts) {
 	let { startTimeoutMs, totalTimeoutMs } = providerWatchdogTimeouts(ctx);
 	if (opts?.startTimeoutCapMs !== void 0 && startTimeoutMs > 0) startTimeoutMs = Math.min(startTimeoutMs, opts.startTimeoutCapMs);
 	const callerHistoryRepair = callbacks.onHistoryRepair;
+	let pendingRepair;
 	callbacks = {
 		...callbacks,
 		async onHistoryRepair(repair) {
-			if (repair.type === "invalid-anthropic-thinking-signature") await repairInvalidAnthropicThinkingHistory(ctx, options, repair);
+			if (repair.type === "invalid-anthropic-thinking-signature") {
+				const result = repairInvalidAnthropicThinkingHistory(ctx, options, repair);
+				if (result.removed > 0) if (pendingRepair === void 0) pendingRepair = result;
+				else {
+					pendingRepair.removed += result.removed;
+					for (const id of result.turnIds) pendingRepair.turnIds.add(id);
+				}
+			}
 			await callerHistoryRepair?.(repair);
 		}
 	};
@@ -10705,7 +11004,7 @@ async function streamWithWatchdogs(ctx, options, callbacks, turnId, opts) {
 		throw err;
 	}
 	streamPromise.catch(() => {});
-	return await new Promise((resolve, reject) => {
+	const raced = new Promise((resolve, reject) => {
 		const failTimeout = (kind, timeoutMs) => {
 			if (settled) return;
 			settled = true;
@@ -10732,6 +11031,11 @@ async function streamWithWatchdogs(ctx, options, callbacks, turnId, opts) {
 			reject(err);
 		});
 	});
+	try {
+		return await raced;
+	} finally {
+		if (pendingRepair !== void 0) await flushThinkingRepair(ctx, pendingRepair);
+	}
 }
 /** Max bytes of provider error text inlined into the assistant turn placeholder. */
 const ERROR_PLACEHOLDER_MAX = 280;
@@ -10864,7 +11168,8 @@ function resolveAutoCompact(raw, opts = {}) {
 		restore: cfg.restore !== false,
 		maxFailures: typeof cfg.maxFailures === "number" && Number.isFinite(cfg.maxFailures) && cfg.maxFailures > 0 ? Math.floor(cfg.maxFailures) : DEFAULT_AUTO_COMPACT_MAX_FAILURES,
 		provider: cfg.provider ?? null,
-		model: typeof cfg.model === "string" && cfg.model.length > 0 ? cfg.model : null
+		model: typeof cfg.model === "string" && cfg.model.length > 0 ? cfg.model : null,
+		releaseReplacedTurns: cfg.releaseReplacedTurns === true
 	};
 }
 /**
@@ -10966,6 +11271,11 @@ async function maybeAutoCompact(ctx, turn, lastTurnUsage, state) {
 		}
 		ctx.turns.push(summaryTurn, ...restorationTurns);
 		await ctx.persistTurns?.();
+		if (cfg.releaseReplacedTurns && ctx.persistDir && result.summarizedTurnIds.length > 0) try {
+			await releaseReplacedTurnContent(ctx.turns, new Set(result.summarizedTurnIds), { persistDir: ctx.persistDir });
+		} catch (err) {
+			if (process.env.ZIDANE_DEBUG) process.stderr.write(`[zidane/loop] post-compact turn release failed: ${errorMessage(err)}\n`);
+		}
 		const absorbedIds = /* @__PURE__ */ new Set([...result.summarizedTurnIds, ...result.droppedDueToPtl]);
 		const onWireReads = new Set(readFilePathsInTurns(applyCompactSummaryCutoff(ctx.turns)));
 		markReadStateForElidedPaths(ctx, ctx.handle.cwd, readFilePathsInTurns(ctx.turns, absorbedIds).filter((p) => !onWireReads.has(p)));
@@ -11113,10 +11423,12 @@ async function executeTurn(ctx, turn, priorUsage) {
 	}
 	const wireMessages = rewriteMessagesToWire(canonicalMessages, ctx.aliasMaps);
 	let sanitizedMessages = sanitizeStoredToolResults(ctx.provider, wireMessages);
+	let callMapsMemo;
+	const callMaps = () => callMapsMemo ??= collectCallMaps(canonicalMessages);
 	if (ctx.compactStrategy === "tail") {
 		const threshold = typeof ctx.compactThreshold === "number" && ctx.compactThreshold > 0 ? ctx.compactThreshold : 131072;
 		const keep = typeof ctx.compactKeepTurns === "number" && ctx.compactKeepTurns >= 0 ? ctx.compactKeepTurns : 4;
-		const { readPathByCallId, toolNameByCallId } = collectCallMaps(canonicalMessages);
+		const { readPathByCallId, toolNameByCallId } = callMaps();
 		const compacted = applyTailCompaction(sanitizedMessages, threshold, keep, {
 			readPathByCallId,
 			toolNameByCallId,
@@ -11134,7 +11446,7 @@ async function executeTurn(ctx, turn, priorUsage) {
 		const threshold = typeof ctx.compactThreshold === "number" && ctx.compactThreshold > 0 ? ctx.compactThreshold : 131072;
 		const keep = typeof ctx.compactKeepTurns === "number" && ctx.compactKeepTurns >= 0 ? ctx.compactKeepTurns : 4;
 		let totalBytes = 0;
-		for (const msg of sanitizedMessages) for (const block of msg.content) if (block.type === "tool_result") totalBytes += toolOutputBudgetByteLength(block.output);
+		for (const msg of sanitizedMessages) for (const block of msg.content) if (block.type === "tool_result") totalBytes += memoizedToolResultBudgetBytes(block);
 		try {
 			const compacted = await ctx.compactStrategy(sanitizedMessages, {
 				threshold,
@@ -11147,7 +11459,7 @@ async function executeTurn(ctx, turn, priorUsage) {
 		}
 	}
 	if (typeof ctx.mediaKeepTurns === "number" && ctx.mediaKeepTurns >= 0 && ctx.tools.read_file) {
-		const { readPathByCallId } = collectCallMaps(canonicalMessages);
+		const { readPathByCallId } = callMaps();
 		const aged = applyMediaAgeout(sanitizedMessages, ctx.mediaKeepTurns, {
 			chunkTurns: COMPACT_CHUNK_TURNS,
 			readPathByCallId,
@@ -11293,7 +11605,7 @@ async function executeTurn(ctx, turn, priorUsage) {
 				}
 			}
 			if (!wasAborted && classified?.kind === "context_exceeded" && cleanSlate && overflowRecoveries < CONTEXT_OVERFLOW_KEEP_TURNS.length) {
-				const { readPathByCallId, toolNameByCallId } = collectCallMaps(canonicalMessages);
+				const { readPathByCallId, toolNameByCallId } = callMaps();
 				let recoveredMessages;
 				const elidedReadPaths = [];
 				for (let k = overflowRecoveries; k < CONTEXT_OVERFLOW_KEEP_TURNS.length; k++) {
@@ -12993,6 +13305,7 @@ const HOOK_EVENT_SET = /* @__PURE__ */ new Set([
 	"compact:start",
 	"compact:progress",
 	"compact:end",
+	"history:repair",
 	"oauth:refresh",
 	"content-ref:resolve",
 	"tool:gate",
@@ -15100,6 +15413,6 @@ function createAgent(rawOptions) {
 	};
 }
 //#endregion
-export { composeExtensionPreset as $, discoverExtensions as $t, ANCHOR_PREVIEW_MAX_CHARS as A, createInteractionTool as At, ExtensionInstallError as B, ensureKeybindingsFile as Bt, NO_TOOLS_PREAMBLE as C, readFile$1 as Ct, buildFullCompactPrompt as D, formatModelLine as Dt, buildFromCompactPrompt as E, createModelSearchTool as Et, truncateHeadForPtlRetry as F, resolveStorageDirs as Ft, readExtensionInstallProvenance as G, mergeKeybindings as Gt, installExtensionFromSpec as H, groupBindings as Ht, CompactInvalidInputError as I, DEFAULT_KEYBINDINGS as It, createExtensionHud as J, readKeybindingsRaw as Jt, removeInstalledExtension as K, parseBindingSpec as Kt, CompactPromptTooLongError as L, KEYBINDING_DEFS as Lt, sliceForCompaction as M, glob as Mt, stripImagesFromTurns as N, edit as Nt, buildTailCompactPrompt as O, matchModelEntries as Ot, summaryToTurn as P, validateToolArgs as Pt, buildExtensionRegistry as Q, defaultExtensionScanPaths as Qt, EMPTY_EXTENSION_REGISTRY as R, KEYBINDING_DEF_BY_ACTION as Rt, BASE_INSTRUCTIONS as S, tailTruncate as St, buildCompactPrompt as T, multiEdit as Tt, listExtensionCandidates as U, keybindingsPath as Ut, fetchExtensionSource as V, formatBindingForDisplay as Vt, parseExtensionInstallSource as W, matchesBinding as Wt, discoverAndBuildExtensionRegistry as X, stripJsonComments as Xt, registerExtensionHostModules as Y, resolveExtensionKeybindings as Yt, buildExtensionPreset as Z, ENTRY_CANDIDATES as Zt, buildPostCompactAttachments as _, defaultRepeatGuardNormalize as _n, createSkillsRunScriptTool as _t, SHELL_CASCADE_CANCEL_MESSAGE as a, clampExtensionConfigNumber as an, createWorkspaceSurface as at, selectRecentFiles as b, stableStringify as bn, createShellTool as bt, applyCompactSummaryCutoff as c, isValidExtensionConfigValue as cn, basicTools as ct, buildPersistedStub as d, sanitizeExtensionConfigActionPatch as dn, WAIT_TASK_TIMED_OUT_PREFIX as dt, inlineLoadedExtension as en, disposeExtensionRegistry as et, cleanupPersistedSession as f, toWireConfigSchema as fn, waitTask as ft, resolveTasksDir as g, shouldAutoCompact as gn, createSkillsUseTool as gt, resolvePersistDir as h, effectiveContextWindow as hn, isSpawnTool as ht, INTERRUPT_MESSAGE_FOR_TOOL_USE as i, defineExtension as in, createExtensionHostRuntimeBridge as it, anchorPreviewFor as j, grep as jt, buildUpToCompactPrompt as k, listFiles as kt, PERSISTED_STUB_PREFIX as l, resolveExtensionConfig as ln, basic_default as lt, resolveMcpWarningsDir as m, OUTPUT_RESERVE_TOKENS as mn, createSpawnTool as mt, normalizeProviders as n, parseExtensionScanPathEnv as nn, mergeContributions as nt, TOOL_USE_CANCELLED_MESSAGE as o, coerceExtensionConfigInput as on, composePresets as ot, maybePersistToolResult as p, AUTO_COMPACT_MIN_GROWTH_FRACTION as pn, createToolSearchTool as pt, updateInstalledExtension as q, readKeybindings as qt, resolveModelTargets as r, scanExtensionDirectories as rn, partitionExtensionCatalog as rt, TOOL_USE_SKIPPED_MESSAGE as s, isValidExtensionConfigItem as sn, definePreset as st, createAgent as t, isExtensionDefinition as tn, filterExtensionRegistry as tt, PERSISTENCE_PREVIEW_BYTES as u, resolveExtensionConfigValue as un, writeFile$1 as ut, selectFilesFromReadState as v, defaultRepeatGuardTracked as vn, createSkillsReadTool as vt, TRAILER as w, looksBinary as wt, compactConversation as x, shell as xt, selectFilesFromSession as y, normalizeShellCommand as yn, shellKill as yt, createExtensionPromptBridge as z, KEYBINDING_KEY_COL_WIDTH as zt };
+export { buildExtensionRegistry as $, defaultExtensionScanPaths as $t, buildUpToCompactPrompt as A, listFiles as At, createExtensionPromptBridge as B, KEYBINDING_KEY_COL_WIDTH as Bt, BASE_INSTRUCTIONS as C, tailTruncate as Ct, buildFromCompactPrompt as D, createModelSearchTool as Dt, buildCompactPrompt as E, multiEdit as Et, summaryToTurn as F, validateToolArgs as Ft, parseExtensionInstallSource as G, matchesBinding as Gt, fetchExtensionSource as H, formatBindingForDisplay as Ht, truncateHeadForPtlRetry as I, resolveStorageDirs as It, updateInstalledExtension as J, readKeybindings as Jt, readExtensionInstallProvenance as K, mergeKeybindings as Kt, CompactInvalidInputError as L, DEFAULT_KEYBINDINGS as Lt, anchorPreviewFor as M, grep as Mt, sliceForCompaction as N, glob as Nt, buildFullCompactPrompt as O, formatModelLine as Ot, stripImagesFromTurns as P, edit as Pt, buildExtensionPreset as Q, ENTRY_CANDIDATES as Qt, CompactPromptTooLongError as R, KEYBINDING_DEFS as Rt, compactConversation as S, shell as St, TRAILER as T, looksBinary as Tt, installExtensionFromSpec as U, groupBindings as Ut, ExtensionInstallError as V, ensureKeybindingsFile as Vt, listExtensionCandidates as W, keybindingsPath as Wt, registerExtensionHostModules as X, resolveExtensionKeybindings as Xt, createExtensionHud as Y, readKeybindingsRaw as Yt, discoverAndBuildExtensionRegistry as Z, stripJsonComments as Zt, resolveTasksDir as _, shouldAutoCompact as _n, createSkillsUseTool as _t, SHELL_CASCADE_CANCEL_MESSAGE as a, defineExtension as an, createExtensionHostRuntimeBridge as at, selectFilesFromSession as b, normalizeShellCommand as bn, shellKill as bt, applyCompactSummaryCutoff as c, isValidExtensionConfigItem as cn, definePreset as ct, buildPersistedStub as d, resolveExtensionConfigValue as dn, writeFile$1 as dt, discoverExtensions as en, composeExtensionPreset as et, cleanupPersistedSession as f, sanitizeExtensionConfigActionPatch as fn, WAIT_TASK_TIMED_OUT_PREFIX as ft, resolvePersistDir as g, effectiveContextWindow as gn, isSpawnTool as gt, resolveMcpWarningsDir as h, OUTPUT_RESERVE_TOKENS as hn, createSpawnTool as ht, INTERRUPT_MESSAGE_FOR_TOOL_USE as i, scanExtensionDirectories as in, partitionExtensionCatalog as it, ANCHOR_PREVIEW_MAX_CHARS as j, createInteractionTool as jt, buildTailCompactPrompt as k, matchModelEntries as kt, PERSISTED_STUB_PREFIX as l, isValidExtensionConfigValue as ln, basicTools as lt, rehomePersistedStubs as m, AUTO_COMPACT_MIN_GROWTH_FRACTION as mn, createToolSearchTool as mt, normalizeProviders as n, isExtensionDefinition as nn, filterExtensionRegistry as nt, TOOL_USE_CANCELLED_MESSAGE as o, clampExtensionConfigNumber as on, createWorkspaceSurface as ot, maybePersistToolResult as p, toWireConfigSchema as pn, waitTask as pt, removeInstalledExtension as q, parseBindingSpec as qt, resolveModelTargets as r, parseExtensionScanPathEnv as rn, mergeContributions as rt, TOOL_USE_SKIPPED_MESSAGE as s, coerceExtensionConfigInput as sn, composePresets as st, createAgent as t, inlineLoadedExtension as tn, disposeExtensionRegistry as tt, PERSISTENCE_PREVIEW_BYTES as u, resolveExtensionConfig as un, basic_default as ut, buildPostCompactAttachments as v, defaultRepeatGuardNormalize as vn, createSkillsRunScriptTool as vt, NO_TOOLS_PREAMBLE as w, readFile$1 as wt, selectRecentFiles as x, stableStringify as xn, createShellTool as xt, selectFilesFromReadState as y, defaultRepeatGuardTracked as yn, createSkillsReadTool as yt, EMPTY_EXTENSION_REGISTRY as z, KEYBINDING_DEF_BY_ACTION as zt };
 
-//# sourceMappingURL=agent-tLfGSSQw.js.map
+//# sourceMappingURL=agent-DIe8yzcb.js.map