zidane 5.5.0 → 5.5.4

package/dist/{stats-DgOvY7wd.js.map → stats-Lc3zL3RM.js.map}

@@ -1 +1 @@
-{"version":3,"file":"stats-DgOvY7wd.js","names":[],"sources":["../src/stats.ts"],"sourcesContent":["/**\n * Pure derivations over `AgentStats`.\n *\n * Both helpers are tree-shakeable — import only what you need. They never\n * touch agent state, never do I/O, and always operate on the recursive\n * `AgentStats` tree returned by `agent.run()`.\n */\n\nimport type { AgentStats, TurnUsage } from './types'\n\n/**\n * Per-model usage rollup produced by {@link statsByModel}.\n *\n * `turns` counts the number of `TurnUsage` entries attributed to the model\n * across the whole tree (parent loop + every recursively-spawned child).\n * Cache and cost numbers are summed from the same set of turns.\n */\nexport interface ModelUsage {\n  input: number\n  output: number\n  cost: number\n  cacheRead: number\n  cacheCreation: number\n  turns: number\n}\n\n/**\n * Common shape for token-usage helpers. Mirrors `AgentStats`'s cumulative\n * fields. Callers working with `TurnUsage` / `SessionRun.totalUsage`\n * (`input` / `output` / `cacheRead` / `cacheCreation`) map their fields in\n * at the call site — we don't accept both shapes here because\n * `AgentStats.output` is a structured-output payload (`Record<string,\n * unknown>`), not a token count, so the field name `output` is ambiguous.\n */\nexport interface TokenUsageLike {\n  totalIn?: number\n  totalOut?: number\n  totalCacheRead?: number\n  totalCacheCreation?: number\n}\n\n/**\n * Clamp to a non-negative finite integer. Used to defend display logic\n *  against providers that report `NaN`, `Infinity`, or negatives in their\n *  usage payloads — the rendered string stays readable instead of leaking\n *  `NaN`s into the footer / spawn-end markers.\n */\nfunction safeNumber(n: number | undefined): number {\n  if (typeof n !== 'number' || !Number.isFinite(n) || n < 0)\n    return 0\n  return n\n}\n\nfunction normalize(stats: TokenUsageLike): {\n  input: number\n  output: number\n  cacheRead: number\n  cacheCreation: number\n} {\n  return {\n    input: safeNumber(stats.totalIn),\n    output: safeNumber(stats.totalOut),\n    cacheRead: safeNumber(stats.totalCacheRead),\n    cacheCreation: safeNumber(stats.totalCacheCreation),\n  }\n}\n\n/**\n * Sum of `input + cacheRead + cacheCreation` — i.e. the number of tokens the\n * model actually saw, regardless of how they were billed.\n *\n * With provider prompt caching (Anthropic, OpenRouter→Anthropic, Gemini),\n * `AgentStats.totalIn` only counts **new uncached** tokens per turn; the\n * bulk of an N-turn run's context lives in `totalCacheRead`, plus a smaller\n * `totalCacheCreation` chunk for whichever turns added new breakpoints.\n * Showing only `totalIn` in a per-run summary makes long subagent runs look\n * suspiciously cheap (e.g. \"13 in\" for 8 turns over a large repo).\n *\n * `TurnUsage` / `SessionRun.totalUsage` callers map their fields to the\n * `total*` names at the call site (see {@link TokenUsageLike}).\n */\nexport function effectiveInputTokens(stats: TokenUsageLike): number {\n  const { input, cacheRead, cacheCreation } = normalize(stats)\n  return input + cacheRead + cacheCreation\n}\n\n/**\n * Render a one-line token summary suitable for spawn-end markers, child\n * tool-result text, and any other per-run \"what did this cost?\" surface.\n *\n *   `in 52413 (cache 50000) / 4075 out`\n *\n * The `in` total includes cached reads and cache-creation tokens (see\n * {@link effectiveInputTokens}); the `(cache N)` parenthetical breaks out\n * the cached portion so the user can tell at a glance how much was reused\n * vs new. The parenthetical is omitted when its value is zero, so\n * non-caching providers and brand-new runs read simply as `in N / M out`.\n *\n * Output-side caching is not a concept any current provider exposes —\n * Anthropic's `cacheRead` / `cacheCreation` are both input-billed. If a\n * future provider ships an output cache, extend `TokenUsageLike` with\n * output-cache fields and add a parallel `(cache N)` slot on the `out`\n * side here; today the right side is always plain `${N} out`.\n */\nexport function formatTokenUsage(stats: TokenUsageLike): string {\n  const { input, output, cacheRead, cacheCreation } = normalize(stats)\n  const inputTotal = input + cacheRead + cacheCreation\n  const inputCache = cacheRead + cacheCreation\n  const inPart = inputCache > 0\n    ? `in ${inputTotal} (cache ${inputCache})`\n    : `in ${inputTotal}`\n  return `${inPart} / ${output} out`\n}\n\n/**\n * Depth-first walk over the stats tree, returning every `TurnUsage` entry\n * — parent loop first, then each child subtree in completion order.\n *\n * Closes the cache-token aggregation gap: `TurnUsage.cacheRead` /\n * `cacheCreation` live only on per-turn entries, and the top-level\n * `AgentStats` deliberately doesn't carry cumulative forms (one source of\n * truth, no risk of drift). Anything that needs a tree-wide sum walks\n * through this.\n */\nexport function flattenTurns(stats: AgentStats): TurnUsage[] {\n  const out: TurnUsage[] = []\n  collectTurns(stats, out)\n  return out\n}\n\nfunction collectTurns(stats: AgentStats, out: TurnUsage[]): void {\n  if (stats.turnUsage)\n    out.push(...stats.turnUsage)\n  if (stats.children) {\n    for (const child of stats.children)\n      collectTurns(child.stats, out)\n  }\n}\n\n/**\n * Group cumulative usage by `TurnUsage.modelId`. Each entry sums the input,\n * output, cache, cost, and turn-count across every turn the tree attributed\n * to that model — naturally handling cross-model runs (vision-fallback,\n * model-shifted subagents, mixed-provider workflows).\n *\n * Turns missing `modelId` (mock providers, providers that don't echo a model\n * id) are bucketed under the literal string `'(unknown)'`.\n */\nexport function statsByModel(stats: AgentStats): Map<string, ModelUsage> {\n  const out = new Map<string, ModelUsage>()\n  for (const turn of flattenTurns(stats)) {\n    const key = turn.modelId ?? '(unknown)'\n    let entry = out.get(key)\n    if (!entry) {\n      entry = { input: 0, output: 0, cost: 0, cacheRead: 0, cacheCreation: 0, turns: 0 }\n      out.set(key, entry)\n    }\n    entry.input += turn.input\n    entry.output += turn.output\n    entry.cost += turn.cost ?? 0\n    entry.cacheRead += turn.cacheRead ?? 0\n    entry.cacheCreation += turn.cacheCreation ?? 0\n    entry.turns += 1\n  }\n  return out\n}\n"],"mappings":";;;;;;;AA+CA,SAAS,WAAW,GAA+B;CACjD,IAAI,OAAO,MAAM,YAAY,CAAC,OAAO,SAAS,EAAE,IAAI,IAAI,GACtD,OAAO;CACT,OAAO;;AAGT,SAAS,UAAU,OAKjB;CACA,OAAO;EACL,OAAO,WAAW,MAAM,QAAQ;EAChC,QAAQ,WAAW,MAAM,SAAS;EAClC,WAAW,WAAW,MAAM,eAAe;EAC3C,eAAe,WAAW,MAAM,mBAAmB;EACpD;;;;;;;;;;;;;;;;;;;;AAwCH,SAAgB,iBAAiB,OAA+B;CAC9D,MAAM,EAAE,OAAO,QAAQ,WAAW,kBAAkB,UAAU,MAAM;CACpE,MAAM,aAAa,QAAQ,YAAY;CACvC,MAAM,aAAa,YAAY;CAI/B,OAAO,GAHQ,aAAa,IACxB,MAAM,WAAW,UAAU,WAAW,KACtC,MAAM,aACO,KAAK,OAAO;;;;;;;;;;;;AAa/B,SAAgB,aAAa,OAAgC;CAC3D,MAAM,MAAmB,EAAE;CAC3B,aAAa,OAAO,IAAI;CACxB,OAAO;;AAGT,SAAS,aAAa,OAAmB,KAAwB;CAC/D,IAAI,MAAM,WACR,IAAI,KAAK,GAAG,MAAM,UAAU;CAC9B,IAAI,MAAM,UACR,KAAK,MAAM,SAAS,MAAM,UACxB,aAAa,MAAM,OAAO,IAAI;;;;;;;;;;;AAapC,SAAgB,aAAa,OAA4C;CACvE,MAAM,sBAAM,IAAI,KAAyB;CACzC,KAAK,MAAM,QAAQ,aAAa,MAAM,EAAE;EACtC,MAAM,MAAM,KAAK,WAAW;EAC5B,IAAI,QAAQ,IAAI,IAAI,IAAI;EACxB,IAAI,CAAC,OAAO;GACV,QAAQ;IAAE,OAAO;IAAG,QAAQ;IAAG,MAAM;IAAG,WAAW;IAAG,eAAe;IAAG,OAAO;IAAG;GAClF,IAAI,IAAI,KAAK,MAAM;;EAErB,MAAM,SAAS,KAAK;EACpB,MAAM,UAAU,KAAK;EACrB,MAAM,QAAQ,KAAK,QAAQ;EAC3B,MAAM,aAAa,KAAK,aAAa;EACrC,MAAM,iBAAiB,KAAK,iBAAiB;EAC7C,MAAM,SAAS;;CAEjB,OAAO"}
+{"version":3,"file":"stats-Lc3zL3RM.js","names":[],"sources":["../src/stats.ts"],"sourcesContent":["/**\n * Pure derivations over `AgentStats`.\n *\n * Both helpers are tree-shakeable — import only what you need. They never\n * touch agent state, never do I/O, and always operate on the recursive\n * `AgentStats` tree returned by `agent.run()`.\n */\n\nimport type { AgentStats, TurnUsage } from './types'\n\n/**\n * Per-model usage rollup produced by {@link statsByModel}.\n *\n * `turns` counts the number of `TurnUsage` entries attributed to the model\n * across the whole tree (parent loop + every recursively-spawned child).\n * Cache and cost numbers are summed from the same set of turns.\n */\nexport interface ModelUsage {\n  input: number\n  output: number\n  cost: number\n  cacheRead: number\n  cacheCreation: number\n  turns: number\n}\n\n/**\n * Common shape for token-usage helpers. Mirrors `AgentStats`'s cumulative\n * fields. Callers working with `TurnUsage` / `SessionRun.totalUsage`\n * (`input` / `output` / `cacheRead` / `cacheCreation`) map their fields in\n * at the call site — we don't accept both shapes here because\n * `AgentStats.output` is a structured-output payload (`Record<string,\n * unknown>`), not a token count, so the field name `output` is ambiguous.\n */\nexport interface TokenUsageLike {\n  totalIn?: number\n  totalOut?: number\n  totalCacheRead?: number\n  totalCacheCreation?: number\n}\n\n/**\n * Clamp to a non-negative finite integer. Used to defend display logic\n *  against providers that report `NaN`, `Infinity`, or negatives in their\n *  usage payloads — the rendered string stays readable instead of leaking\n *  `NaN`s into the footer / spawn-end markers.\n */\nfunction safeNumber(n: number | undefined): number {\n  if (typeof n !== 'number' || !Number.isFinite(n) || n < 0)\n    return 0\n  return n\n}\n\nfunction normalize(stats: TokenUsageLike): {\n  input: number\n  output: number\n  cacheRead: number\n  cacheCreation: number\n} {\n  return {\n    input: safeNumber(stats.totalIn),\n    output: safeNumber(stats.totalOut),\n    cacheRead: safeNumber(stats.totalCacheRead),\n    cacheCreation: safeNumber(stats.totalCacheCreation),\n  }\n}\n\n/**\n * Sum of `input + cacheRead + cacheCreation` — i.e. the number of tokens the\n * model actually saw, regardless of how they were billed.\n *\n * With provider prompt caching (Anthropic, OpenRouter→Anthropic, Gemini),\n * `AgentStats.totalIn` only counts **new uncached** tokens per turn; the\n * bulk of an N-turn run's context lives in `totalCacheRead`, plus a smaller\n * `totalCacheCreation` chunk for whichever turns added new breakpoints.\n * Showing only `totalIn` in a per-run summary makes long subagent runs look\n * suspiciously cheap (e.g. \"13 in\" for 8 turns over a large repo).\n *\n * `TurnUsage` / `SessionRun.totalUsage` callers map their fields to the\n * `total*` names at the call site (see {@link TokenUsageLike}).\n */\nexport function effectiveInputTokens(stats: TokenUsageLike): number {\n  const { input, cacheRead, cacheCreation } = normalize(stats)\n  return input + cacheRead + cacheCreation\n}\n\n/**\n * Render a one-line token summary suitable for spawn-end markers, child\n * tool-result text, and any other per-run \"what did this cost?\" surface.\n *\n *   `in 52413 (cache 50000) / 4075 out`\n *\n * The `in` total includes cached reads and cache-creation tokens (see\n * {@link effectiveInputTokens}); the `(cache N)` parenthetical breaks out\n * the cached portion so the user can tell at a glance how much was reused\n * vs new. The parenthetical is omitted when its value is zero, so\n * non-caching providers and brand-new runs read simply as `in N / M out`.\n *\n * Output-side caching is not a concept any current provider exposes —\n * Anthropic's `cacheRead` / `cacheCreation` are both input-billed. If a\n * future provider ships an output cache, extend `TokenUsageLike` with\n * output-cache fields and add a parallel `(cache N)` slot on the `out`\n * side here; today the right side is always plain `${N} out`.\n */\nexport function formatTokenUsage(stats: TokenUsageLike): string {\n  const { input, output, cacheRead, cacheCreation } = normalize(stats)\n  const inputTotal = input + cacheRead + cacheCreation\n  const inputCache = cacheRead + cacheCreation\n  const inPart = inputCache > 0\n    ? `in ${inputTotal} (cache ${inputCache})`\n    : `in ${inputTotal}`\n  return `${inPart} / ${output} out`\n}\n\n/**\n * Depth-first walk over the stats tree, returning every `TurnUsage` entry\n * — parent loop first, then each child subtree in completion order.\n *\n * Closes the cache-token aggregation gap: `TurnUsage.cacheRead` /\n * `cacheCreation` live only on per-turn entries, and the top-level\n * `AgentStats` deliberately doesn't carry cumulative forms (one source of\n * truth, no risk of drift). Anything that needs a tree-wide sum walks\n * through this.\n */\nexport function flattenTurns(stats: AgentStats): TurnUsage[] {\n  const out: TurnUsage[] = []\n  collectTurns(stats, out)\n  return out\n}\n\nfunction collectTurns(stats: AgentStats, out: TurnUsage[]): void {\n  if (stats.turnUsage)\n    out.push(...stats.turnUsage)\n  if (stats.children) {\n    for (const child of stats.children)\n      collectTurns(child.stats, out)\n  }\n}\n\n/**\n * Group cumulative usage by `TurnUsage.modelId`. Each entry sums the input,\n * output, cache, cost, and turn-count across every turn the tree attributed\n * to that model — naturally handling cross-model runs (vision-fallback,\n * model-shifted subagents, mixed-provider workflows).\n *\n * Turns missing `modelId` (mock providers, providers that don't echo a model\n * id) are bucketed under the literal string `'(unknown)'`.\n */\nexport function statsByModel(stats: AgentStats): Map<string, ModelUsage> {\n  const out = new Map<string, ModelUsage>()\n  for (const turn of flattenTurns(stats)) {\n    const key = turn.modelId ?? '(unknown)'\n    let entry = out.get(key)\n    if (!entry) {\n      entry = { input: 0, output: 0, cost: 0, cacheRead: 0, cacheCreation: 0, turns: 0 }\n      out.set(key, entry)\n    }\n    entry.input += turn.input\n    entry.output += turn.output\n    entry.cost += turn.cost ?? 0\n    entry.cacheRead += turn.cacheRead ?? 0\n    entry.cacheCreation += turn.cacheCreation ?? 0\n    entry.turns += 1\n  }\n  return out\n}\n"],"mappings":";;;;;;;AA+CA,SAAS,WAAW,GAA+B;CACjD,IAAI,OAAO,MAAM,YAAY,CAAC,OAAO,SAAS,EAAE,IAAI,IAAI,GACtD,OAAO;CACT,OAAO;;AAGT,SAAS,UAAU,OAKjB;CACA,OAAO;EACL,OAAO,WAAW,MAAM,QAAQ;EAChC,QAAQ,WAAW,MAAM,SAAS;EAClC,WAAW,WAAW,MAAM,eAAe;EAC3C,eAAe,WAAW,MAAM,mBAAmB;EACpD;;;;;;;;;;;;;;;;;;;;AAwCH,SAAgB,iBAAiB,OAA+B;CAC9D,MAAM,EAAE,OAAO,QAAQ,WAAW,kBAAkB,UAAU,MAAM;CACpE,MAAM,aAAa,QAAQ,YAAY;CACvC,MAAM,aAAa,YAAY;CAI/B,OAAO,GAHQ,aAAa,IACxB,MAAM,WAAW,UAAU,WAAW,KACtC,MAAM,aACO,KAAK,OAAO;;;;;;;;;;;;AAa/B,SAAgB,aAAa,OAAgC;CAC3D,MAAM,MAAmB,EAAE;CAC3B,aAAa,OAAO,IAAI;CACxB,OAAO;;AAGT,SAAS,aAAa,OAAmB,KAAwB;CAC/D,IAAI,MAAM,WACR,IAAI,KAAK,GAAG,MAAM,UAAU;CAC9B,IAAI,MAAM,UACR,KAAK,MAAM,SAAS,MAAM,UACxB,aAAa,MAAM,OAAO,IAAI;;;;;;;;;;;AAapC,SAAgB,aAAa,OAA4C;CACvE,MAAM,sBAAM,IAAI,KAAyB;CACzC,KAAK,MAAM,QAAQ,aAAa,MAAM,EAAE;EACtC,MAAM,MAAM,KAAK,WAAW;EAC5B,IAAI,QAAQ,IAAI,IAAI,IAAI;EACxB,IAAI,CAAC,OAAO;GACV,QAAQ;IAAE,OAAO;IAAG,QAAQ;IAAG,MAAM;IAAG,WAAW;IAAG,eAAe;IAAG,OAAO;IAAG;GAClF,IAAI,IAAI,KAAK,MAAM;;EAErB,MAAM,SAAS,KAAK;EACpB,MAAM,UAAU,KAAK;EACrB,MAAM,QAAQ,KAAK,QAAQ;EAC3B,MAAM,aAAa,KAAK,aAAa;EACrC,MAAM,iBAAiB,KAAK,iBAAiB;EAC7C,MAAM,SAAS;;CAEjB,OAAO"}

package/dist/{tools-D_icxa-V.js → tools-Bbd0Ivwn.js}

@@ -1,10 +1,10 @@
-import { n as createProcessContext } from "./contexts-DhmMlT2W.js";
-import { a as AgentToolPairingError, l as toTypedError, r as AgentProviderError, s as errorMessage, t as AgentAbortedError } from "./errors-CDwtPIMX.js";
-import { t as toolOutputByteLength } from "./types-IcokUOyC.js";
-import { a as detectTurnInterruption, n as SYNTHETIC_TOOL_RESULT_PLACEHOLDER, o as ensureToolResultPairing, s as filterUnresolvedToolUses } from "./messages-fTR19Ga6.js";
-import { t as connectMcpServers } from "./mcp-CNUbvbsy.js";
-import { _ as validateResourcePath, b as createSkillActivationState, d as escapeXml, n as resolveSkills, p as installAllowedToolsGate, t as interpolateShellCommands, u as buildCatalog } from "./interpolate-BaaKaKzN.js";
-import { n as formatTokenUsage, t as flattenTurns } from "./stats-DgOvY7wd.js";
+import { n as createProcessContext } from "./contexts-BOtMvzli.js";
+import { a as AgentToolPairingError, l as toTypedError, r as AgentProviderError, s as errorMessage, t as AgentAbortedError } from "./errors-C5VSakmT.js";
+import { n as toolOutputByteLength, t as DEFAULT_AGENT_CLOCK } from "./types-oKPBdCmL.js";
+import { a as detectTurnInterruption, n as SYNTHETIC_TOOL_RESULT_PLACEHOLDER, o as ensureToolResultPairing, s as filterUnresolvedToolUses } from "./messages-BBWakTN6.js";
+import { t as connectMcpServers } from "./mcp-BE43Viwi.js";
+import { _ as validateResourcePath, b as createSkillActivationState, d as escapeXml, n as resolveSkills, p as installAllowedToolsGate, t as interpolateShellCommands, u as buildCatalog } from "./interpolate-Cvjy8gpk.js";
+import { n as formatTokenUsage, t as flattenTurns } from "./stats-Lc3zL3RM.js";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { createHooks } from "hookable";
 import { homedir } from "node:os";
@@ -1376,7 +1376,7 @@ async function runLoop(ctx) {
 					runId: ctx.runId,
 					role: steerUserMsg.role,
 					content: steerUserMsg.content,
-					createdAt: Date.now()
+					createdAt: await ctx.clock.now()
 				});
 				continue;
 			}
@@ -1390,7 +1390,7 @@ async function runLoop(ctx) {
 						runId: ctx.runId,
 						role: followUpMsg.role,
 						content: followUpMsg.content,
-						createdAt: Date.now()
+						createdAt: await ctx.clock.now()
 					});
 					continue;
 				}
@@ -1604,7 +1604,7 @@ async function executeTurn(ctx, turn, priorUsage) {
 			role: "assistant",
 			content: errorContent,
 			usage: errorUsage,
-			createdAt: Date.now()
+			createdAt: await ctx.clock.now()
 		};
 		ctx.turns.push(errorTurn);
 		if (!wasAborted) {
@@ -1648,7 +1648,7 @@ async function executeTurn(ctx, turn, priorUsage) {
 			text: currentText
 		}] : canonicalContent,
 		usage: result.usage,
-		createdAt: Date.now()
+		createdAt: await ctx.clock.now()
 	};
 	ctx.turns.push(assistantTurn);
 	const turnCounts = {};
@@ -1705,7 +1705,7 @@ async function executeTurn(ctx, turn, priorUsage) {
 				role: "assistant",
 				content: schemaResult.assistantMessage.content,
 				usage: schemaResult.usage,
-				createdAt: Date.now()
+				createdAt: await ctx.clock.now()
 			};
 			ctx.turns.push(schemaTurn);
 			return {
@@ -1731,7 +1731,7 @@ async function executeTurn(ctx, turn, priorUsage) {
 			runId: ctx.runId,
 			role: continueMsg.role,
 			content: continueMsg.content,
-			createdAt: Date.now()
+			createdAt: await ctx.clock.now()
 		});
 		return {
 			ended: false,
@@ -1746,7 +1746,7 @@ async function executeTurn(ctx, turn, priorUsage) {
 		runId: ctx.runId,
 		role: toolResultMsg.role,
 		content: toolResultMsg.content,
-		createdAt: Date.now()
+		createdAt: await ctx.clock.now()
 	};
 	ctx.turns.push(toolResultsTurn);
 	await ctx.hooks.callHook("tool-results:after", {
@@ -1756,7 +1756,15 @@ async function executeTurn(ctx, turn, priorUsage) {
 		results: toolResults
 	});
 	if (typeof ctx.toolOutputBudget === "number" && ctx.toolOutputBudget > 0) {
-		const totalBytes = toolResults.reduce((sum, r) => sum + toolOutputByteLength(r.content), 0);
+		const excludeSet = ctx.toolOutputBudgetExcludeTools && ctx.toolOutputBudgetExcludeTools.length > 0 ? new Set(ctx.toolOutputBudgetExcludeTools) : void 0;
+		const nameById = excludeSet ? new Map(canonicalToolCalls.map((c) => [c.id, c.name])) : void 0;
+		const totalBytes = toolResults.reduce((sum, r) => {
+			if (excludeSet && nameById) {
+				const name = nameById.get(r.id);
+				if (name !== void 0 && excludeSet.has(name)) return sum;
+			}
+			return sum + toolOutputByteLength(r.content);
+		}, 0);
 		if (totalBytes > ctx.toolOutputBudget) {
 			const warning = `[Tool output budget exceeded: ${totalBytes} bytes returned in this turn (cap: ${ctx.toolOutputBudget}). Summarize the salient findings before calling more tools.]`;
 			const userMsg = ctx.provider.userMessage(warning);
@@ -1765,7 +1773,7 @@ async function executeTurn(ctx, turn, priorUsage) {
 				runId: ctx.runId,
 				role: userMsg.role,
 				content: userMsg.content,
-				createdAt: Date.now()
+				createdAt: await ctx.clock.now()
 			});
 			await ctx.hooks.callHook("budget:exceeded", {
 				turn,
@@ -2000,7 +2008,8 @@ async function runSingleToolDispatch(ctx, call, turnId, fixed) {
 			...ctx.parentRunId !== void 0 ? { parentRunId: ctx.parentRunId } : {},
 			...ctx.session ? { session: ctx.session } : {},
 			...ctx.readState ? { readState: ctx.readState } : {},
-			...typeof ctx.depth === "number" ? { depth: ctx.depth } : {}
+			...typeof ctx.depth === "number" ? { depth: ctx.depth } : {},
+			clock: ctx.clock
 		};
 		const bodyPromise = toolDef.execute(effectiveInput, toolCtx);
 		bodyPromise.catch(() => {});
@@ -3161,21 +3170,95 @@ function formatMatch(entry) {
 	].join("\n");
 }
 /**
-* Factory for `tool_search`. Auto-injected by the agent when
-* `behavior.toolDisclosure === 'lazy'` and at least one MCP tool is in the
-* registry. Opt out via `behavior.toolSearch.tool === false`.
+* Pure resolver for a `tool_search` invocation. Mirrors the matching the
+* execute path performs (`names` → `server` → `query` → unconstrained fallback,
+* then cap by `limit`). Extracted so the unlock side-effect can be replayed
+* deterministically when a session is resumed — `run()` walks the persisted
+* `tool_search` tool_calls and feeds each historical input through here to
+* rebuild the `unlocked` set seeded by prior runs.
+*
+* Returns the entries the original call would have shown (post-limit), not the
+* full pre-cap match set — the cap is part of what the model actually saw.
 */
-function createToolSearchTool(options) {
-	const defaultLimit = options.defaultLimit ?? DEFAULT_LIMIT$1;
-	const byName = new Map(options.catalog.map((e) => [e.name, e]));
+function selectToolSearchMatches(catalog, input, defaultLimit = DEFAULT_LIMIT$1) {
+	const byName = new Map(catalog.map((e) => [e.name, e]));
 	const byServer = /* @__PURE__ */ new Map();
-	for (const entry of options.catalog) {
+	for (const entry of catalog) {
 		if (!entry.server) continue;
 		const list = byServer.get(entry.server) ?? [];
 		list.push(entry);
 		byServer.set(entry.server, list);
 	}
-	const maxLimit = Math.max(options.catalog.length, 1);
+	const maxLimit = Math.max(catalog.length, 1);
+	const query = (typeof input.query === "string" ? input.query.trim() : void 0) || void 0;
+	const namesIn = Array.isArray(input.names) ? input.names.filter((n) => typeof n === "string" && n.length > 0) : void 0;
+	const server = typeof input.server === "string" && input.server.length > 0 ? input.server : void 0;
+	const limitIn = typeof input.limit === "number" && Number.isFinite(input.limit) && input.limit > 0 ? Math.floor(input.limit) : defaultLimit;
+	const limit = Math.min(limitIn, maxLimit);
+	const matches = [];
+	const seen = /* @__PURE__ */ new Set();
+	const misses = [];
+	if (namesIn && namesIn.length > 0) for (const n of namesIn) {
+		if (seen.has(n)) continue;
+		const entry = byName.get(n);
+		if (entry) {
+			matches.push(entry);
+			seen.add(n);
+		} else misses.push(n);
+	}
+	if (server) {
+		const list = byServer.get(server) ?? [];
+		for (const entry of list) {
+			if (seen.has(entry.name)) continue;
+			matches.push(entry);
+			seen.add(entry.name);
+		}
+	}
+	if (query !== void 0) for (const entry of rankByQuery(catalog, query)) {
+		if (seen.has(entry.name)) continue;
+		matches.push(entry);
+		seen.add(entry.name);
+	}
+	if (!namesIn?.length && !server && query === void 0) for (const entry of catalog) {
+		matches.push(entry);
+		seen.add(entry.name);
+	}
+	const truncated = matches.length > limit;
+	return {
+		shown: truncated ? matches.slice(0, limit) : matches,
+		total: matches.length,
+		truncated,
+		misses,
+		query,
+		server
+	};
+}
+/**
+* Replay the unlock side-effect of a single historical `tool_search` call.
+*
+* Used on session resume: every run starts with a fresh `unlocked` set
+* (seeded with eager tools only), but the resumed conversation already
+* shows the model that some lazy tools are callable. Without this replay
+* the model emits a `tool_use` for a tool the gate then refuses with
+* "load via tool_search first" — the failure the bug report named.
+*
+* Safe to call repeatedly with the same input; the `Set` add is idempotent.
+* Lookups missing from the current catalog (host changed `mcpServers` or
+* `disclosure` between runs) are silently dropped — the model will get a
+* normal "tool not callable" error on its next attempt, which is the
+* correct response when a tool genuinely no longer exists.
+*/
+function applyToolSearchToUnlocked(catalog, input, unlocked, defaultLimit) {
+	const { shown } = selectToolSearchMatches(catalog, input, defaultLimit ?? DEFAULT_LIMIT$1);
+	for (const entry of shown) unlocked.add(entry.canonicalName);
+}
+/**
+* Factory for `tool_search`. Auto-injected by the agent when
+* `behavior.toolDisclosure === 'lazy'` and at least one MCP tool is in the
+* registry. Opt out via `behavior.toolSearch.tool === false`.
+*/
+function createToolSearchTool(options) {
+	const defaultLimit = options.defaultLimit ?? DEFAULT_LIMIT$1;
 	return {
 		isConcurrencySafe: true,
 		spec: {
@@ -3208,53 +3291,19 @@ function createToolSearchTool(options) {
 		},
 		async execute(input, ctx) {
 			if (ctx.signal?.aborted) return "<tool_search_results matches=\"0\" aborted=\"true\">Run aborted.</tool_search_results>";
-			const query = (typeof input.query === "string" ? input.query.trim() : void 0) || void 0;
-			const namesIn = Array.isArray(input.names) ? input.names.filter((n) => typeof n === "string" && n.length > 0) : void 0;
-			const server = typeof input.server === "string" && input.server.length > 0 ? input.server : void 0;
-			const limitIn = typeof input.limit === "number" && Number.isFinite(input.limit) && input.limit > 0 ? Math.floor(input.limit) : defaultLimit;
-			const limit = Math.min(limitIn, maxLimit);
 			if (options.catalog.length === 0) return "<tool_search_results matches=\"0\">No lazy tools registered for this run.</tool_search_results>";
-			const matches = [];
-			const seen = /* @__PURE__ */ new Set();
-			const misses = [];
-			if (namesIn && namesIn.length > 0) for (const n of namesIn) {
-				if (seen.has(n)) continue;
-				const entry = byName.get(n);
-				if (entry) {
-					matches.push(entry);
-					seen.add(n);
-				} else misses.push(n);
-			}
-			if (server) {
-				const list = byServer.get(server) ?? [];
-				for (const entry of list) {
-					if (seen.has(entry.name)) continue;
-					matches.push(entry);
-					seen.add(entry.name);
-				}
-			}
-			if (query !== void 0) for (const entry of rankByQuery(options.catalog, query)) {
-				if (seen.has(entry.name)) continue;
-				matches.push(entry);
-				seen.add(entry.name);
-			}
-			if (!namesIn?.length && !server && query === void 0) for (const entry of options.catalog) {
-				matches.push(entry);
-				seen.add(entry.name);
-			}
-			const truncated = matches.length > limit;
-			const shown = truncated ? matches.slice(0, limit) : matches;
+			const { shown, total, truncated, misses, query, server } = selectToolSearchMatches(options.catalog, input, defaultLimit);
 			for (const entry of shown) options.unlocked.add(entry.canonicalName);
 			const parts = [];
 			const queryAttr = query ? ` query="${escapeXml(query)}"` : "";
 			const serverAttr = server ? ` server="${escapeXml(server)}"` : "";
-			parts.push(`<tool_search_results matches="${shown.length}" total="${matches.length}"${queryAttr}${serverAttr}>`);
+			parts.push(`<tool_search_results matches="${shown.length}" total="${total}"${queryAttr}${serverAttr}>`);
 			if (shown.length === 0) parts.push("  No matches. Try a broader query, or omit all parameters to list everything.");
 			else {
 				for (const entry of shown) parts.push(formatMatch(entry));
 				parts.push("");
 				parts.push("  These tools are now callable. Invoke them by name in subsequent turns.");
-				if (truncated) parts.push(`  ${matches.length - shown.length} additional matches were truncated — refine the query or raise \`limit\`.`);
+				if (truncated) parts.push(`  ${total - shown.length} additional matches were truncated — refine the query or raise \`limit\`.`);
 			}
 			if (misses.length > 0) parts.push(`  <misses>${misses.map(escapeXml).join(", ")}</misses>`);
 			parts.push("</tool_search_results>");
@@ -3405,7 +3454,7 @@ function isKnownHookEvent(event) {
 * - All tool_use ids are already answered by a tool_result somewhere later
 *   in the conversation (defensive — shouldn't happen but cheap to check).
 */
-async function synthesizeMissingToolResults(turns, syntheticTurnId, runId, provider, hooks) {
+async function synthesizeMissingToolResults(turns, syntheticTurnId, runId, provider, hooks, clock) {
 	if (turns.length === 0) return;
 	const last = turns[turns.length - 1];
 	if (last.role !== "assistant") return;
@@ -3427,7 +3476,7 @@ async function synthesizeMissingToolResults(turns, syntheticTurnId, runId, provi
 		runId,
 		role: msg.role,
 		content: msg.content,
-		createdAt: Date.now()
+		createdAt: await clock.now()
 	});
 	for (const callId of dangling) await hooks.callHook("pairing:repair", {
 		mode: "orphan-tool-use-append",
@@ -3444,6 +3493,7 @@ function resolveBehavior(agentBehavior, runBehavior) {
 		schema: runBehavior?.schema ?? agentBehavior?.schema,
 		cache: runBehavior?.cache ?? agentBehavior?.cache ?? true,
 		toolOutputBudget: runBehavior?.toolOutputBudget ?? agentBehavior?.toolOutputBudget,
+		toolOutputBudgetExcludeTools: runBehavior?.toolOutputBudgetExcludeTools ?? agentBehavior?.toolOutputBudgetExcludeTools,
 		compactStrategy: runBehavior?.compactStrategy ?? agentBehavior?.compactStrategy ?? "off",
 		compactThreshold: runBehavior?.compactThreshold ?? agentBehavior?.compactThreshold,
 		compactKeepTurns: runBehavior?.compactKeepTurns ?? agentBehavior?.compactKeepTurns,
@@ -3608,7 +3658,7 @@ function initialRunCounter(session) {
 	for (const t of session.turns) consider(t.runId);
 	return max;
 }
-function createAgent({ provider, name: agentName, system: agentSystem, tools: agentTools, toolAliases, behavior: agentBehavior, execution, mcpServers, session, readState: agentReadState, skills: agentSkills, mcpConnector, eager, hooks: initialHooks }) {
+function createAgent({ provider, name: agentName, system: agentSystem, tools: agentTools, toolAliases, behavior: agentBehavior, execution, mcpServers, session, readState: agentReadState, skills: agentSkills, mcpConnector, eager, hooks: initialHooks, clock: agentClock }) {
 	const hooks = createHooks();
 	const executionContext = execution ?? createProcessContext();
 	const sourceTools = agentTools ?? {};
@@ -3688,6 +3738,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 				throw new Error(`cannot resume without prompt: ${detail}. Pass a prompt to agent.run({ prompt: … }).`);
 			}
 		}
+		const clock = options.clock ?? agentClock ?? DEFAULT_AGENT_CLOCK;
 		let externalAbortListener;
 		const externalSignal = options.signal;
 		running = true;
@@ -3708,7 +3759,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 					prompt: promptLabel
 				});
 			}
-			const runStartedAt = Date.now();
+			const runStartedAt = await clock.now();
 			await hooks.callHook("agent:start", {
 				runId,
 				...options.parentRunId ? { parentRunId: options.parentRunId } : {},
@@ -3769,7 +3820,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 			const thinking = options.thinking ?? "off";
 			const model = options.model ?? provider.meta.defaultModel;
 			const resolvedBehavior = resolveBehavior(agentBehavior, options.behavior);
-			const { maxConcurrentTools, maxTurns, maxTokens, thinkingBudget, schema, cache, toolOutputBudget, compactStrategy, compactThreshold, compactKeepTurns, thinkingDecay, dedupTools, toolBudgets, elideStaleReads, toolDisclosure, toolSearch, persistThreshold, persistExcludeTools, persistDir, strictToolPairing } = resolvedBehavior;
+			const { maxConcurrentTools, maxTurns, maxTokens, thinkingBudget, schema, cache, toolOutputBudget, toolOutputBudgetExcludeTools, compactStrategy, compactThreshold, compactKeepTurns, thinkingDecay, dedupTools, toolBudgets, elideStaleReads, toolDisclosure, toolSearch, persistThreshold, persistExcludeTools, persistDir, strictToolPairing } = resolvedBehavior;
 			let system = options.system || agentSystem || "You are a helpful assistant.";
 			if (skillsCatalog) system = `${system}\n\n${skillsCatalog}`;
 			const runBaseTools = options.tools !== void 0 ? options.tools : mcpConnection ? {
@@ -3838,6 +3889,16 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 				const resumed = childRunIds.size === 0 ? session.turns : session.turns.filter((t) => !t.runId || !childRunIds.has(t.runId));
 				const filteredForRuntime = resumeFilteredTurns && resumed === session.turns ? resumeFilteredTurns : filterUnresolvedToolUses(resumed);
 				turns.push(...filteredForRuntime);
+				if (shouldInjectToolSearch && disclosure.lazyEntries.length > 0) {
+					const resolvedCallIds = /* @__PURE__ */ new Set();
+					for (const turn of filteredForRuntime) for (const block of turn.content) if (block.type === "tool_result" && !block.isError) resolvedCallIds.add(block.callId);
+					for (const turn of filteredForRuntime) for (const block of turn.content) {
+						if (block.type !== "tool_call") continue;
+						if (block.name !== "tool_search") continue;
+						if (!resolvedCallIds.has(block.id)) continue;
+						applyToolSearchToUnlocked(disclosure.lazyEntries, block.input, unlocked, toolSearch?.limit);
+					}
+				}
 			}
 			const runTurnStart = turns.length;
 			if (options.system) await hooks.callHook("system:before", { system: options.system });
@@ -3855,11 +3916,11 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 				const promptMsg = promptParts ? buildPromptMessage(provider, promptParts) : null;
 				const content = [...drainedNotifications, ...promptMsg ? promptMsg.content : []];
 				turns.push({
-					id: crypto.randomUUID(),
+					id: clock.randomUUID(),
 					runId,
 					role: promptMsg ? promptMsg.role : "user",
 					content,
-					createdAt: Date.now()
+					createdAt: await clock.now()
 				});
 			}
 			conversationTurns = turns;
@@ -3889,7 +3950,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 			const unregisterToolResultsSync = session ? hooks.hook("tool-results:after", persistPendingTurns) : void 0;
 			async function flushTurns(opts = {}) {
 				if (!session) return;
-				if (opts.failureFallback) await synthesizeMissingToolResults(turns, await session.generateTurnId?.() ?? crypto.randomUUID(), runId, provider, hooks);
+				if (opts.failureFallback) await synthesizeMissingToolResults(turns, await session.generateTurnId?.() ?? clock.randomUUID(), runId, provider, hooks, clock);
 				const remaining = turns.slice(lastPersistedTurnCount);
 				if (remaining.length > 0) {
 					await session.appendTurns(remaining);
@@ -3923,7 +3984,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 			const uninstallToolBudgets = installToolBudgetsGate(hooks, () => toolBudgets, (msg) => steeringQueue.push(msg));
 			const uninstallDedupTools = installDedupToolsGate(hooks, () => dedupTools, () => session ?? void 0);
 			const uninstallLazyDisclosureGate = installLazyDisclosureGate(hooks, disclosure.lazyCanonicalNames, unlocked, discoveryToolName);
-			const runStartMs = Date.now();
+			const runStartMs = await clock.now();
 			const runDepth = typeof options.depth === "number" ? options.depth : 0;
 			try {
 				const stats = await runLoop({
@@ -3951,7 +4012,8 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 					followUpQueue,
 					turns,
 					runId,
-					generateTurnId: () => session?.generateTurnId() ?? crypto.randomUUID(),
+					generateTurnId: () => session?.generateTurnId() ?? clock.randomUUID(),
+					clock,
 					maxTurns,
 					maxTokens,
 					...session ? { session } : {},
@@ -3962,6 +4024,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 					schema,
 					cache,
 					toolOutputBudget,
+					...toolOutputBudgetExcludeTools !== void 0 ? { toolOutputBudgetExcludeTools } : {},
 					compactStrategy,
 					compactThreshold,
 					compactKeepTurns,
@@ -5852,4 +5915,4 @@ const writeFile$1 = {
 //#endregion
 export { resolvePersistDir as A, formatTaskStatus as B, TOOL_USE_SKIPPED_MESSAGE as C, buildPersistedStub as D, PERSISTENCE_PREVIEW_BYTES as E, resolveReadStateMap as F, previewLine as H, ageString as I, compactPath as L, getReadState as M, hashContent as N, cleanupPersistedSession as O, readStateKey as P, fmtTokens as R, TOOL_USE_CANCELLED_MESSAGE as S, PERSISTED_STUB_PREFIX as T, shortId as U, formatTaskSummary as V, createSkillsReadTool as _, multiEdit as a, INTERRUPT_MESSAGE_FOR_TOOL_USE as b, grep as c, resolveOldString as d, styleReplacementForVia as f, createSkillsRunScriptTool as g, createSkillsUseTool as h, readFile$1 as i, resolveTasksDir as j, maybePersistToolResult as k, glob as l, createToolSearchTool as m, createSpawnTool as n, listFiles as o, createAgent as p, shellKill as r, createInteractionTool as s, writeFile$1 as t, edit as u, createShellTool as v, validateToolArgs as w, SHELL_CASCADE_CANCEL_MESSAGE as x, shell as y, formatDuration as z };
 
-//# sourceMappingURL=tools-D_icxa-V.js.map
+//# sourceMappingURL=tools-Bbd0Ivwn.js.map