zidane 3.1.1 → 3.2.0

package/dist/{chunk-EBSFBIP3.js → chunk-6JIVVEQQ.js}

@@ -3,15 +3,15 @@ import {
   createSkillActivationState,
   installAllowedToolsGate,
   interpolateShellCommands,
-  resolveSkills,
+  resolveSkillsWithCleanup,
   validateResourcePath
-} from "./chunk-TPXPVEH6.js";
+} from "./chunk-J4ZOSNSH.js";
 import {
   createProcessContext
-} from "./chunk-IUBBVF53.js";
+} from "./chunk-UD25QF3H.js";
 import {
   connectMcpServers
-} from "./chunk-R74LQKAM.js";
+} from "./chunk-7H34OFDA.js";
 import {
   toolOutputByteLength
 } from "./chunk-JH6IAAFA.js";
@@ -197,6 +197,17 @@ function getReadState(session) {
   }
   return map;
 }
+var TOOL_DEDUP_STATE = /* @__PURE__ */ new WeakMap();
+function getToolDedupState(session) {
+  if (!session)
+    return void 0;
+  let map = TOOL_DEDUP_STATE.get(session);
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    TOOL_DEDUP_STATE.set(session, map);
+  }
+  return map;
+}
 function hashContent(text) {
   let h = 2166136261;
   for (let i = 0; i < text.length; i++) {
@@ -356,6 +367,18 @@ var glob = {
   }
 };
 
+// src/tools/shell-quote.ts
+var SAFE_TOKEN_RE = /^[\w@%+=:,./-]+$/;
+var SINGLE_QUOTE_RE = /'/g;
+function shellQuote(arg) {
+  if (SAFE_TOKEN_RE.test(arg))
+    return arg;
+  return `'${arg.replace(SINGLE_QUOTE_RE, "'\\''")}'`;
+}
+function alwaysQuote(arg) {
+  return `'${arg.replace(SINGLE_QUOTE_RE, "'\\''")}'`;
+}
+
 // src/tools/grep.ts
 var DEFAULT_HEAD_LIMIT = 250;
 var DEFAULT_OUTPUT_MODE = "files_with_matches";
@@ -431,11 +454,6 @@ async function runViaRipgrep(input, ctx) {
   }
   return formatPaginated(result.stdout, input);
 }
-function shellQuote(arg) {
-  if (/^[\w@%+=:,./-]+$/.test(arg))
-    return arg;
-  return `'${arg.replace(/'/g, "'\\''")}'`;
-}
 async function runInProcess(input, ctx) {
   const mode = input.output_mode ?? DEFAULT_OUTPUT_MODE;
   const flags = `${input["-i"] ? "i" : ""}${input.multiline ? "s" : ""}${mode !== "content" ? "" : "g"}`;
@@ -684,6 +702,33 @@ var multiEdit = {
 // src/tools/read-file.ts
 import { Buffer as Buffer2 } from "buffer";
 
+// src/tools/binary-detect.ts
+var SNIFF_BYTES = 8192;
+var REPLACEMENT_RATIO_THRESHOLD = 0.01;
+var REPLACEMENT_MIN_COUNT = 5;
+function containsNullByte(text, sniffBytes = SNIFF_BYTES) {
+  const sample = text.length > sniffBytes ? text.slice(0, sniffBytes) : text;
+  for (let i = 0; i < sample.length; i++) {
+    if (sample.charCodeAt(i) === 0)
+      return true;
+  }
+  return false;
+}
+function looksBinary(text, sniffBytes = SNIFF_BYTES) {
+  const sample = text.length > sniffBytes ? text.slice(0, sniffBytes) : text;
+  if (sample.length === 0)
+    return false;
+  let replacementCount = 0;
+  for (let i = 0; i < sample.length; i++) {
+    const code = sample.charCodeAt(i);
+    if (code === 0)
+      return true;
+    if (code === 65533)
+      replacementCount++;
+  }
+  return replacementCount >= REPLACEMENT_MIN_COUNT && replacementCount / sample.length > REPLACEMENT_RATIO_THRESHOLD;
+}
+
 // src/tools/binary-read.ts
 import { Buffer } from "buffer";
 function imageMediaTypeFor(path) {
@@ -711,21 +756,27 @@ async function readFileAsBase64(execution, handle, path) {
     const b642 = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64");
     return { base64: b642, byteLength: bytes.byteLength };
   }
-  const cmd = `base64 < ${shellQuote2(path)}`;
+  const cmd = `base64 < ${alwaysQuote(path)}`;
   const result = await execution.exec(handle, cmd);
   if (result.exitCode !== 0)
     throw new Error(`base64 read failed: ${result.stderr || `exit ${result.exitCode}`}`);
   const b64 = result.stdout.replace(/\s+/g, "");
-  return { base64: b64, byteLength: Math.floor(b64.length * 3 / 4) };
+  return { base64: b64, byteLength: decodedBase64ByteLength(b64) };
 }
-function shellQuote2(s) {
-  return `'${s.replace(/'/g, "'\\''")}'`;
+function decodedBase64ByteLength(b64) {
+  if (b64.length === 0)
+    return 0;
+  let pad = 0;
+  if (b64.endsWith("=="))
+    pad = 2;
+  else if (b64.endsWith("="))
+    pad = 1;
+  return Math.max(0, b64.length * 3 / 4 - pad);
 }
 
 // src/tools/read-file.ts
 var DEFAULT_LINE_LIMIT = 2e3;
 var DEFAULT_BYTE_CAP = 65536;
-var BINARY_PROBE_BYTES = 8e3;
 var DEFAULT_IMAGE_BYTE_CAP = 5 * 1024 * 1024;
 var readFile = {
   spec: {
@@ -868,21 +919,6 @@ function normalizeInteger(value, fallback) {
     return fallback;
   return Math.floor(value);
 }
-var REPLACEMENT_RATIO_THRESHOLD = 0.01;
-var REPLACEMENT_MIN_COUNT = 5;
-function looksBinary(text) {
-  const sample = text.length > BINARY_PROBE_BYTES ? text.slice(0, BINARY_PROBE_BYTES) : text;
-  if (sample.includes("\0"))
-    return true;
-  if (sample.length === 0)
-    return false;
-  let replacementCount = 0;
-  for (let i = 0; i < sample.length; i++) {
-    if (sample.charCodeAt(i) === 65533)
-      replacementCount++;
-  }
-  return replacementCount >= REPLACEMENT_MIN_COUNT && replacementCount / sample.length > REPLACEMENT_RATIO_THRESHOLD;
-}
 
 // src/tools/shell.ts
 import { Buffer as Buffer3 } from "buffer";
@@ -985,15 +1021,6 @@ ${tail}`;
 }
 
 // src/tools/skills-read.ts
-var SNIFF_BYTES = 8192;
-function looksBinary2(text) {
-  const len = Math.min(text.length, SNIFF_BYTES);
-  for (let i = 0; i < len; i++) {
-    if (text.charCodeAt(i) === 0)
-      return true;
-  }
-  return false;
-}
 function createSkillsReadTool(options) {
   const byName = new Map(options.catalog.map((s) => [s.name, s]));
   return {
@@ -1038,7 +1065,7 @@ function createSkillsReadTool(options) {
         const message = err instanceof Error ? err.message : String(err);
         return `Error reading "${relPath}" in skill "${skillName}": ${message}`;
       }
-      if (looksBinary2(content)) {
+      if (containsNullByte(content)) {
         return JSON.stringify({
           kind: "binary-unsupported",
           path: validated.absolutePath,
@@ -1051,12 +1078,8 @@ function createSkillsReadTool(options) {
 }
 
 // src/tools/skills-run-script.ts
-var SINGLE_QUOTE_RE = /'/g;
 var ABS_WINDOWS_RE = /^[a-z]:[\\/]/i;
 var COLLAPSE_SLASHES_RE = /\/+/g;
-function quoteShellArg(arg) {
-  return `'${arg.replace(SINGLE_QUOTE_RE, `'\\''`)}'`;
-}
 function createSkillsRunScriptTool(options) {
   const byName = new Map(options.catalog.map((s) => [s.name, s]));
   const timeoutMs = options.scriptTimeoutMs ?? 6e4;
@@ -1103,7 +1126,7 @@ function createSkillsRunScriptTool(options) {
       const validated = validateResourcePath(joinedPath, skill.baseDir);
       if (!validated.valid)
         return `Error: ${validated.error}`;
-      const cmd = [validated.absolutePath, ...args].map(quoteShellArg).join(" ");
+      const cmd = [validated.absolutePath, ...args].map(alwaysQuote).join(" ");
       try {
         const result = await ctx.execution.exec(ctx.handle, cmd, {
           timeout: Math.max(1, Math.round(timeoutMs / 1e3))
@@ -1279,6 +1302,59 @@ function rewriteMessagesToWire(messages, maps) {
   return messages.map((msg) => ({ ...msg, content: rewriteContentToWire(msg.content, maps) }));
 }
 
+// src/dedup-tools.ts
+function installDedupToolsGate(hooks, getDedupTools, getSession) {
+  const pending = /* @__PURE__ */ new Map();
+  function pendingKey(callId, name) {
+    return `${callId}::${name}`;
+  }
+  function gateHandler(ctx) {
+    if (ctx.block || ctx.result !== void 0)
+      return;
+    const dedupTools = getDedupTools();
+    const hasher = dedupTools?.[ctx.name];
+    if (!hasher)
+      return;
+    const session = getSession();
+    const state = getToolDedupState(session);
+    if (!state)
+      return;
+    let hash;
+    try {
+      hash = hasher(ctx.input);
+    } catch {
+      return;
+    }
+    if (typeof hash !== "string" || hash.length === 0)
+      return;
+    const prior = state.get(ctx.name);
+    if (prior && prior.hash === hash) {
+      ctx.result = prior.result;
+      return;
+    }
+    pending.set(pendingKey(ctx.callId, ctx.name), hash);
+  }
+  function afterHandler(ctx) {
+    const key = pendingKey(ctx.callId, ctx.name);
+    const hash = pending.get(key);
+    if (hash === void 0)
+      return;
+    pending.delete(key);
+    const session = getSession();
+    const state = getToolDedupState(session);
+    if (!state)
+      return;
+    state.set(ctx.name, { hash, result: ctx.result });
+  }
+  const unregisterGate = hooks.hook("tool:gate", gateHandler);
+  const unregisterAfter = hooks.hook("tool:after", afterHandler);
+  return function uninstall() {
+    unregisterGate();
+    unregisterAfter();
+    pending.clear();
+  };
+}
+
 // src/tools/validation.ts
 var TRUE_STRINGS = /* @__PURE__ */ new Set(["true", "True", "TRUE", "1", "yes", "Yes", "YES"]);
 var FALSE_STRINGS = /* @__PURE__ */ new Set(["false", "False", "FALSE", "0", "no", "No", "NO"]);
@@ -1434,6 +1510,24 @@ function formatValue(value) {
 
 // src/loop.ts
 var IMAGE_OMITTED_MARKER = "[image omitted \u2014 model does not support vision]";
+function applyThinkingDecay(baseBudget, decay, turn) {
+  if (typeof baseBudget !== "number" || baseBudget <= 0)
+    return baseBudget;
+  if (!decay)
+    return baseBudget;
+  let raw;
+  if (typeof decay === "function") {
+    raw = decay(turn, baseBudget);
+  } else {
+    if (turn <= decay.afterTurn)
+      return baseBudget;
+    const k = turn - decay.afterTurn;
+    raw = Math.max(decay.floor, baseBudget * decay.factor ** k);
+  }
+  if (Number.isNaN(raw) || raw <= 0)
+    return 0;
+  return Math.round(Math.min(baseBudget, raw));
+}
 function turnsToMessages(turns) {
   return turns.filter((t) => t.role !== "system").map((t) => ({ role: t.role, content: t.content }));
 }
@@ -1589,6 +1683,7 @@ async function executeTurn(ctx, turn) {
     const keep = typeof ctx.compactKeepTurns === "number" && ctx.compactKeepTurns >= 0 ? ctx.compactKeepTurns : 4;
     sanitizedMessages = applyTailCompaction(sanitizedMessages, threshold, keep);
   }
+  const effectiveThinkingBudget = applyThinkingDecay(ctx.thinkingBudget, ctx.thinkingDecay, turn);
   const streamOptions = {
     model: ctx.model,
     system: ctx.system,
@@ -1596,13 +1691,22 @@ async function executeTurn(ctx, turn) {
     messages: sanitizedMessages,
     maxTokens: ctx.maxTokens ?? 16384,
     thinking: ctx.thinking,
-    thinkingBudget: ctx.thinkingBudget,
+    thinkingBudget: effectiveThinkingBudget,
     cache: ctx.cache ?? true,
     signal: ctx.signal
   };
   const transformCtx = { messages: streamOptions.messages };
   await ctx.hooks.callHook("context:transform", transformCtx);
   streamOptions.messages = transformCtx.messages;
+  const systemCtx = {
+    system: streamOptions.system,
+    messages: streamOptions.messages,
+    turn,
+    turnId,
+    ...ctx.session ? { session: ctx.session } : {}
+  };
+  await ctx.hooks.callHook("system:transform", systemCtx);
+  streamOptions.system = systemCtx.system;
   await ctx.hooks.callHook("turn:before", { turn, turnId, options: streamOptions });
   let currentText = "";
   let currentThinking = "";
@@ -1626,16 +1730,23 @@ async function executeTurn(ctx, turn) {
     );
   } catch (err) {
     const errorUsage = { input: 0, output: 0 };
+    const errorContent = currentText ? [{ type: "text", text: currentText }] : [{ type: "text", text: "[provider error before any output]" }];
     const errorTurn = {
       id: turnId,
       runId: ctx.runId,
       role: "assistant",
-      content: currentText ? [{ type: "text", text: currentText }] : [],
+      content: errorContent,
       usage: errorUsage,
       createdAt: Date.now()
     };
     ctx.turns.push(errorTurn);
-    await ctx.hooks.callHook("turn:after", { turn, turnId, usage: errorUsage, message: errorTurn });
+    await ctx.hooks.callHook("turn:after", {
+      turn,
+      turnId,
+      usage: errorUsage,
+      message: errorTurn,
+      toolCounts: { turn: Object.freeze({}), run: Object.freeze({ ...ctx.runToolCounts }) }
+    });
     throw wrapProviderError(err, ctx);
   }
   if (currentText) {
@@ -1658,7 +1769,16 @@ async function executeTurn(ctx, turn) {
     createdAt: Date.now()
   };
   ctx.turns.push(assistantTurn);
-  await ctx.hooks.callHook("turn:after", { turn, turnId, usage: result.usage, message: assistantTurn });
+  const turnCounts = {};
+  for (const tc of canonicalToolCalls)
+    turnCounts[tc.name] = (turnCounts[tc.name] ?? 0) + 1;
+  await ctx.hooks.callHook("turn:after", {
+    turn,
+    turnId,
+    usage: result.usage,
+    message: assistantTurn,
+    toolCounts: { turn: Object.freeze(turnCounts), run: Object.freeze({ ...ctx.runToolCounts }) }
+  });
   if (result.done) {
     if (ctx.schema && !ctx.signal.aborted) {
       const outputSpec = {
@@ -1771,6 +1891,7 @@ async function executeSingleTool(ctx, call, turnId) {
   const toolDef = ctx.tools[call.name];
   const callId = call.id;
   const displayName = toWireName(call.name, ctx.aliasMaps);
+  const runToolCounts = Object.freeze({ ...ctx.runToolCounts });
   const gateCtx = {
     turnId,
     callId,
@@ -1778,12 +1899,27 @@ async function executeSingleTool(ctx, call, turnId) {
     displayName,
     input: call.input,
     block: false,
-    reason: "Tool execution was blocked"
+    reason: "Tool execution was blocked",
+    runToolCounts
   };
   await ctx.hooks.callHook("tool:gate", gateCtx);
   if (gateCtx.block) {
     return { result: { id: callId, content: `Blocked: ${gateCtx.reason}` } };
   }
+  ctx.runToolCounts[call.name] = (ctx.runToolCounts[call.name] ?? 0) + 1;
+  if (gateCtx.result !== void 0) {
+    const substitute = await emitToolResult(ctx, {
+      turnId,
+      callId,
+      name: call.name,
+      displayName,
+      input: gateCtx.input,
+      output: gateCtx.result,
+      isError: false,
+      runToolCounts
+    });
+    return { result: { id: callId, content: substitute } };
+  }
   let effectiveInput = gateCtx.input;
   if (!toolDef) {
     const unknownCtx = {
@@ -1841,6 +1977,7 @@ async function executeSingleTool(ctx, call, turnId) {
     name: call.name,
     displayName,
     input: effectiveInput,
+    runToolCounts,
     ...coercions ? { coercions } : {}
   });
   let output;
@@ -1880,12 +2017,29 @@ async function executeSingleTool(ctx, call, turnId) {
     output = errorCtx.result ?? `Tool error: ${error.message}`;
     isError = true;
   }
-  const transformCtx = {
+  const finalOutput = await emitToolResult(ctx, {
     turnId,
     callId,
     name: call.name,
     displayName,
     input: effectiveInput,
+    output,
+    isError,
+    runToolCounts,
+    ...coercions ? { coercions } : {}
+  });
+  return { result: { id: callId, content: finalOutput } };
+}
+async function emitToolResult(ctx, params) {
+  const { turnId, callId, name, displayName, input, runToolCounts, coercions } = params;
+  let output = params.output;
+  let isError = params.isError;
+  const transformCtx = {
+    turnId,
+    callId,
+    name,
+    displayName,
+    input,
     result: output,
     isError,
     outputBytes: toolOutputByteLength(output),
@@ -1898,14 +2052,15 @@ async function executeSingleTool(ctx, call, turnId) {
   await ctx.hooks.callHook("tool:after", {
     turnId,
     callId,
-    name: call.name,
+    name,
     displayName,
-    input: effectiveInput,
+    input,
     result: output,
     outputBytes: toolOutputByteLength(output),
+    runToolCounts,
     ...coercions ? { coercions } : {}
   });
-  return { result: { id: callId, content: output } };
+  return output;
 }
 async function executeToolsSequential(ctx, toolCalls, turnId) {
   const results = [];
@@ -1913,28 +2068,10 @@ async function executeToolsSequential(ctx, toolCalls, turnId) {
     if (ctx.signal.aborted)
       break;
     if (ctx.steeringQueue.length > 0) {
-      const steerMsg = ctx.steeringQueue.shift();
-      await ctx.hooks.callHook("steer:inject", { message: steerMsg });
-      for (const skipped of toolCalls.slice(toolCalls.indexOf(call))) {
-        results.push({ id: skipped.id, content: "Skipped: steering message received" });
-      }
-      const toolResultMsg = ctx.provider.toolResultsMessage(results);
-      ctx.turns.push({
-        id: await ctx.generateTurnId(),
-        runId: ctx.runId,
-        role: toolResultMsg.role,
-        content: toolResultMsg.content,
-        createdAt: Date.now()
-      });
-      const steerUserMsg = ctx.provider.userMessage(steerMsg);
-      ctx.turns.push({
-        id: await ctx.generateTurnId(),
-        runId: ctx.runId,
-        role: steerUserMsg.role,
-        content: steerUserMsg.content,
-        createdAt: Date.now()
-      });
-      return [];
+      const fromIdx = toolCalls.indexOf(call);
+      for (let i = fromIdx; i < toolCalls.length; i++)
+        results.push({ id: toolCalls[i].id, content: "Skipped: steering message received" });
+      return results;
     }
     const { result } = await executeSingleTool(ctx, call, turnId);
     results.push(result);
@@ -1978,6 +2115,15 @@ function canonicalizePrompt(prompt, legacyImages) {
   }
   if (prompt.length === 0)
     return void 0;
+  for (const part of prompt) {
+    if (!part || typeof part !== "object" || typeof part.type !== "string") {
+      throw new Error("Invalid PromptPart: each part must be an object with a `type` field.");
+    }
+    const type = part.type;
+    if (type !== "text" && type !== "image" && type !== "document") {
+      throw new Error(`Invalid PromptPart type "${type}". Expected "text" | "image" | "document".`);
+    }
+  }
   const hasMeaningfulPart = prompt.some((part) => part.type === "text" && part.text.length > 0 || part.type === "image" || part.type === "document");
   if (!hasMeaningfulPart)
     return void 0;
@@ -2014,6 +2160,81 @@ function buildPromptMessage(provider, parts) {
   return defaultPromptMessage(parts);
 }
 
+// src/tool-budgets.ts
+function installToolBudgetsGate(hooks, getToolBudgets, enqueueSteer) {
+  const steeredOnce = /* @__PURE__ */ new Set();
+  const approvedCounts = {};
+  async function gateHandler(ctx) {
+    if (ctx.block || ctx.result !== void 0)
+      return;
+    const toolBudgets = getToolBudgets();
+    const budget = toolBudgets?.[ctx.name];
+    if (!budget)
+      return;
+    const max = budget.max;
+    if (typeof max !== "number" || max <= 0)
+      return;
+    const count = approvedCounts[ctx.name] ?? 0;
+    if (count < max) {
+      approvedCounts[ctx.name] = count + 1;
+      return;
+    }
+    const onExceed = budget.onExceed ?? "steer";
+    let mode;
+    let message;
+    if (typeof onExceed === "function") {
+      try {
+        const out = onExceed({ tool: ctx.name, count, max });
+        mode = out.mode;
+        message = out.message;
+      } catch {
+        mode = "steer";
+        message = defaultSteerMessage(ctx.name, count, max);
+      }
+    } else if (onExceed === "block") {
+      mode = "block";
+      message = defaultBlockMessage(ctx.name, max);
+    } else {
+      mode = "steer";
+      message = defaultSteerMessage(ctx.name, count, max);
+    }
+    if (mode === "block") {
+      ctx.block = true;
+      ctx.reason = message;
+      await hooks.callHook("tool-budget:exceeded", {
+        tool: ctx.name,
+        count,
+        max,
+        turnId: ctx.turnId,
+        mode: "block"
+      });
+      return;
+    }
+    if (!steeredOnce.has(ctx.name)) {
+      steeredOnce.add(ctx.name);
+      enqueueSteer(message);
+      await hooks.callHook("tool-budget:exceeded", {
+        tool: ctx.name,
+        count,
+        max,
+        turnId: ctx.turnId,
+        mode: "steer"
+      });
+    }
+  }
+  const unregister = hooks.hook("tool:gate", gateHandler);
+  return function uninstall() {
+    unregister();
+    steeredOnce.clear();
+  };
+}
+function defaultSteerMessage(tool, count, max) {
+  return `[Tool budget reached: '${tool}' has been called ${count} times this run (cap: ${max}). Avoid calling it again unless strictly necessary; commit to a result and move on.]`;
+}
+function defaultBlockMessage(tool, max) {
+  return `Tool '${tool}' has reached its per-run budget of ${max} calls; further invocations are refused.`;
+}
+
 // src/agent.ts
 var HOOK_EVENT_NAMES = [
   "system:before",
@@ -2032,6 +2253,7 @@ var HOOK_EVENT_NAMES = [
   "validation:reject",
   "validation:coerce",
   "context:transform",
+  "system:transform",
   "steer:inject",
   "spawn:before",
   "spawn:complete",
@@ -2060,6 +2282,7 @@ var HOOK_EVENT_NAMES = [
   "usage",
   "output",
   "budget:exceeded",
+  "tool-budget:exceeded",
   "agent:abort",
   "agent:done",
   "session:start",
@@ -2083,7 +2306,12 @@ function resolveBehavior(agentBehavior, runBehavior) {
     toolOutputBudget: runBehavior?.toolOutputBudget ?? agentBehavior?.toolOutputBudget,
     compactStrategy: runBehavior?.compactStrategy ?? agentBehavior?.compactStrategy ?? "off",
     compactThreshold: runBehavior?.compactThreshold ?? agentBehavior?.compactThreshold,
-    compactKeepTurns: runBehavior?.compactKeepTurns ?? agentBehavior?.compactKeepTurns
+    compactKeepTurns: runBehavior?.compactKeepTurns ?? agentBehavior?.compactKeepTurns,
+    thinkingDecay: runBehavior?.thinkingDecay ?? agentBehavior?.thinkingDecay,
+    dedupReads: runBehavior?.dedupReads ?? agentBehavior?.dedupReads,
+    dedupTools: runBehavior?.dedupTools ?? agentBehavior?.dedupTools,
+    requireReadBeforeEdit: runBehavior?.requireReadBeforeEdit ?? agentBehavior?.requireReadBeforeEdit,
+    toolBudgets: runBehavior?.toolBudgets ?? agentBehavior?.toolBudgets
   };
 }
 function createAgent({ provider, name: agentName, system: agentSystem, tools: agentTools, toolAliases, behavior: agentBehavior, execution, mcpServers, session, skills: agentSkills, mcpConnector, eager }) {
@@ -2107,6 +2335,8 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
   const skillsDisabled = skillsEnabledValue === false || Array.isArray(skillsEnabledValue) && skillsEnabledValue.length === 0;
   let resolvedSkills = null;
   let skillsCatalog = null;
+  let skillsCleanup = () => {
+  };
   const skillActivationState = createSkillActivationState({
     maxActive: skillsConfig?.maxActive
   });
@@ -2174,7 +2404,9 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
       await warmup();
     }
     if (!skillsDisabled && skillsConfig && !resolvedSkills) {
-      resolvedSkills = await resolveSkills(skillsConfig);
+      const bundle = await resolveSkillsWithCleanup(skillsConfig);
+      resolvedSkills = bundle.skills;
+      skillsCleanup = bundle.cleanup;
       await hooks.callHook("skills:resolve", { skills: resolvedSkills });
       const skillsToolRegistered = skillsConfig?.tool !== false && resolvedSkills.length > 0;
       const catalogCtx = {
@@ -2206,7 +2438,8 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
     }
     const thinking = options.thinking ?? "off";
     const model = options.model ?? provider.meta.defaultModel;
-    const { toolExecution, maxTurns, maxTokens, thinkingBudget, schema, cache, toolOutputBudget, compactStrategy, compactThreshold, compactKeepTurns } = resolveBehavior(agentBehavior, options.behavior);
+    const resolvedBehavior = resolveBehavior(agentBehavior, options.behavior);
+    const { toolExecution, maxTurns, maxTokens, thinkingBudget, schema, cache, toolOutputBudget, compactStrategy, compactThreshold, compactKeepTurns, thinkingDecay, dedupTools, toolBudgets } = resolvedBehavior;
     let system = options.system || agentSystem || "You are a helpful assistant.";
     if (skillsCatalog) {
       system = `${system}
@@ -2306,6 +2539,16 @@ ${skillsCatalog}`;
       await hooks.callHook("session:end", { sessionId: session.id, runId, status, turnRange: [runTurnStart, turns.length - 1] });
     }
     const uninstallAllowedToolsGate = installAllowedToolsGate(hooks, skillActivationState);
+    const uninstallToolBudgets = installToolBudgetsGate(
+      hooks,
+      () => toolBudgets,
+      (msg) => steeringQueue.push(msg)
+    );
+    const uninstallDedupTools = installDedupToolsGate(
+      hooks,
+      () => dedupTools,
+      () => session ?? void 0
+    );
     const runStartMs = Date.now();
     const runDepth = typeof options.depth === "number" ? options.depth : 0;
     try {
@@ -2318,7 +2561,10 @@ ${skillsCatalog}`;
         agentToolAliases: toolAliases,
         agentMcpServers: mcpServers,
         agentSkills,
-        agentBehavior,
+        // Forward the resolved view (agent + run merged) so per-run overrides
+        // of `dedupReads` / `requireReadBeforeEdit` / etc. are visible to
+        // tools via `ToolContext.behavior`.
+        agentBehavior: resolvedBehavior,
         tools,
         formattedTools,
         aliasMaps,
@@ -2345,7 +2591,9 @@ ${skillsCatalog}`;
         compactStrategy,
         compactThreshold,
         compactKeepTurns,
-        runStartMs
+        ...thinkingDecay !== void 0 ? { thinkingDecay } : {},
+        runStartMs,
+        runToolCounts: {}
       });
       const finalStats = {
         ...stats,
@@ -2387,6 +2635,8 @@ ${skillsCatalog}`;
     } finally {
       await deactivateAllSkills();
       uninstallAllowedToolsGate();
+      uninstallDedupTools();
+      uninstallToolBudgets();
       unregisterSpawnHook();
       unregisterSessionSync?.();
       for (const unregister of perRunUnregisters)
@@ -2413,6 +2663,11 @@ ${skillsCatalog}`;
     return idlePromise ?? Promise.resolve();
   }
   async function reset() {
+    if (running) {
+      throw new Error(
+        "Cannot reset() while the agent is running. Call `agent.abort()` and `await agent.waitForIdle()` first."
+      );
+    }
     conversationTurns = [];
     steeringQueue.length = 0;
     followUpQueue.length = 0;
@@ -2501,6 +2756,9 @@ ${skillsCatalog}`;
       await executionContext.destroy(executionHandle);
       executionHandle = null;
     }
+    skillsCleanup();
+    skillsCleanup = () => {
+    };
   }
   if (eager && allMcpServers.length > 0) {
     void warmup().catch(() => {