zidane 3.1.0 → 3.1.2

package/dist/{chunk-PYLYK3K7.js → chunk-2AE3VM5O.js}

@@ -8,10 +8,10 @@ import {
 } from "./chunk-TPXPVEH6.js";
 import {
   createProcessContext
-} from "./chunk-2EQT4EHD.js";
+} from "./chunk-IUBBVF53.js";
 import {
   connectMcpServers
-} from "./chunk-R74LQKAM.js";
+} from "./chunk-7H34OFDA.js";
 import {
   toolOutputByteLength
 } from "./chunk-JH6IAAFA.js";
@@ -36,6 +36,154 @@ function countExactMatches(haystack, needle) {
   }
   return count;
 }
+var LEFT_SINGLE_CURLY_QUOTE = "\u2018";
+var RIGHT_SINGLE_CURLY_QUOTE = "\u2019";
+var LEFT_DOUBLE_CURLY_QUOTE = "\u201C";
+var RIGHT_DOUBLE_CURLY_QUOTE = "\u201D";
+function normalizeQuotes(str) {
+  return str.replaceAll(LEFT_SINGLE_CURLY_QUOTE, "'").replaceAll(RIGHT_SINGLE_CURLY_QUOTE, "'").replaceAll(LEFT_DOUBLE_CURLY_QUOTE, '"').replaceAll(RIGHT_DOUBLE_CURLY_QUOTE, '"');
+}
+var DESANITIZATIONS = [
+  ["<fnr>", "<function_results>"],
+  ["<n>", "<name>"],
+  ["</n>", "</name>"],
+  ["<o>", "<output>"],
+  ["</o>", "</output>"],
+  ["<e>", "<error>"],
+  ["</e>", "</error>"],
+  ["<s>", "<system>"],
+  ["</s>", "</system>"],
+  ["<r>", "<result>"],
+  ["</r>", "</result>"],
+  ["< META_START >", "<META_START>"],
+  ["< META_END >", "<META_END>"],
+  ["< EOT >", "<EOT>"],
+  ["< META >", "<META>"],
+  ["< SOS >", "<SOS>"],
+  ["\n\nH:", "\n\nHuman:"],
+  ["\n\nA:", "\n\nAssistant:"]
+];
+function desanitize(s) {
+  let out = s;
+  for (const [from, to] of DESANITIZATIONS)
+    out = out.replaceAll(from, to);
+  return out;
+}
+function resolveOldString(haystack, needle) {
+  const exact = countExactMatches(haystack, needle);
+  if (exact > 0)
+    return { actual: needle, occurrences: exact, via: "exact" };
+  const normNeedle = normalizeQuotes(needle);
+  const normFile = normalizeQuotes(haystack);
+  if (normNeedle !== needle || normFile !== haystack) {
+    const idx = normFile.indexOf(normNeedle);
+    if (idx !== -1) {
+      const actual = haystack.slice(idx, idx + normNeedle.length);
+      let occ = 0;
+      let cursor = 0;
+      while (true) {
+        const next = normFile.indexOf(normNeedle, cursor);
+        if (next === -1)
+          break;
+        occ++;
+        cursor = next + normNeedle.length;
+      }
+      return { actual, occurrences: occ, via: "quotes" };
+    }
+  }
+  const desan = desanitize(needle);
+  if (desan !== needle) {
+    const desanCount = countExactMatches(haystack, desan);
+    if (desanCount > 0)
+      return { actual: desan, occurrences: desanCount, via: "desanitize" };
+  }
+  const combo = desanitize(normNeedle);
+  if (combo !== needle) {
+    const idx = normFile.indexOf(combo);
+    if (idx !== -1) {
+      const actual = haystack.slice(idx, idx + combo.length);
+      let occ = 0;
+      let cursor = 0;
+      while (true) {
+        const next = normFile.indexOf(combo, cursor);
+        if (next === -1)
+          break;
+        occ++;
+        cursor = next + combo.length;
+      }
+      return { actual, occurrences: occ, via: "quotes+desanitize" };
+    }
+  }
+  return null;
+}
+function preserveQuoteStyle(actual, replacement) {
+  const hasDouble = actual.includes(LEFT_DOUBLE_CURLY_QUOTE) || actual.includes(RIGHT_DOUBLE_CURLY_QUOTE);
+  const hasSingle = actual.includes(LEFT_SINGLE_CURLY_QUOTE) || actual.includes(RIGHT_SINGLE_CURLY_QUOTE);
+  if (!hasDouble && !hasSingle)
+    return replacement;
+  let out = replacement;
+  if (hasDouble)
+    out = applyCurly(out, '"', LEFT_DOUBLE_CURLY_QUOTE, RIGHT_DOUBLE_CURLY_QUOTE, false);
+  if (hasSingle)
+    out = applyCurly(out, "'", LEFT_SINGLE_CURLY_QUOTE, RIGHT_SINGLE_CURLY_QUOTE, true);
+  return out;
+}
+function applyCurly(s, straight, left, right, contractionAware) {
+  const chars = [...s];
+  const result = [];
+  for (let i = 0; i < chars.length; i++) {
+    if (chars[i] !== straight) {
+      result.push(chars[i]);
+      continue;
+    }
+    if (contractionAware) {
+      const prev = i > 0 ? chars[i - 1] : "";
+      const next = i < chars.length - 1 ? chars[i + 1] : "";
+      if (/\p{L}/u.test(prev) && /\p{L}/u.test(next)) {
+        result.push(right);
+        continue;
+      }
+    }
+    result.push(isOpeningContext(chars, i) ? left : right);
+  }
+  return result.join("");
+}
+function isOpeningContext(chars, i) {
+  if (i === 0)
+    return true;
+  const prev = chars[i - 1];
+  return prev === " " || prev === "	" || prev === "\n" || prev === "\r" || prev === "(" || prev === "[" || prev === "{" || prev === "\u2014" || prev === "\u2013";
+}
+
+// src/tools/path-suggest.ts
+async function findSimilarFile(execution, handle, path) {
+  const slash = path.lastIndexOf("/");
+  const dir = slash === -1 ? "." : path.slice(0, slash) || "/";
+  const target = slash === -1 ? path : path.slice(slash + 1);
+  const dot = target.lastIndexOf(".");
+  const targetBase = dot === -1 ? target : target.slice(0, dot);
+  if (targetBase.length === 0)
+    return null;
+  let entries;
+  try {
+    entries = await execution.listFiles(handle, dir);
+  } catch {
+    return null;
+  }
+  for (const entry of entries) {
+    if (entry === target)
+      continue;
+    const entryDot = entry.lastIndexOf(".");
+    const entryBase = entryDot === -1 ? entry : entry.slice(0, entryDot);
+    if (entryBase === targetBase)
+      return entry;
+  }
+  return null;
+}
+async function suggestionFor(execution, handle, path) {
+  const sibling = await findSimilarFile(execution, handle, path);
+  return sibling ? ` Did you mean ${sibling}?` : "";
+}
 
 // src/tools/read-state.ts
 var STATE = /* @__PURE__ */ new WeakMap();
@@ -49,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++) {
@@ -87,7 +246,8 @@ var edit = {
     try {
       original = await ctx.execution.readFile(ctx.handle, target);
     } catch {
-      return `Edit error: file not found: ${target}`;
+      const hint = await suggestionFor(ctx.execution, ctx.handle, target);
+      return `Edit error: file not found: ${target}.${hint}`;
     }
     if (ctx.behavior?.requireReadBeforeEdit && ctx.session) {
       const readState = getReadState(ctx.session);
@@ -98,14 +258,18 @@ var edit = {
       if (prior.contentHash !== hashContent(original))
         return `Edit error: ${target} has changed on disk since the last read. Re-read the file before editing.`;
     }
-    const occurrences = countExactMatches(original, find);
-    if (occurrences === 0) {
+    const match = resolveOldString(original, find);
+    if (!match) {
       const preview = nearestMatchPreview(original, find);
       return preview ? `Edit error: old_string not found in ${target}. Closest match in the file: ${preview}` : `Edit error: old_string not found in ${target}.`;
     }
+    const { actual, occurrences, via } = match;
     if (occurrences > 1 && !replaceAll)
       return `Edit error: old_string appears ${occurrences} times in ${target}. Pass replace_all=true or expand old_string for uniqueness.`;
-    const updated = replaceAll ? original.split(find).join(replacement) : original.replace(find, replacement);
+    let styledReplacement = via === "desanitize" || via === "quotes+desanitize" ? desanitize(replacement) : replacement;
+    if (via === "quotes" || via === "quotes+desanitize")
+      styledReplacement = preserveQuoteStyle(actual, styledReplacement);
+    const updated = replaceAll ? original.split(actual).join(styledReplacement) : original.replace(actual, styledReplacement);
     if (updated === original)
       return `Edit error: replacement produced no change in ${target}.`;
     await ctx.execution.writeFile(ctx.handle, target, updated);
@@ -479,7 +643,8 @@ var multiEdit = {
     try {
       current = await ctx.execution.readFile(ctx.handle, target);
     } catch {
-      return `multi_edit error: file not found: ${target}`;
+      const hint = await suggestionFor(ctx.execution, ctx.handle, target);
+      return `multi_edit error: file not found: ${target}.${hint}`;
     }
     if (ctx.behavior?.requireReadBeforeEdit && ctx.session) {
       const readState = getReadState(ctx.session);
@@ -502,12 +667,16 @@ var multiEdit = {
         return `multi_edit error: edit #${i + 1} has empty old_string. Use write_file to fully replace a file.`;
       if (find === replacement)
         return `multi_edit error: edit #${i + 1} old_string and new_string are identical.`;
-      const occurrences = countExactMatches(current, find);
-      if (occurrences === 0)
+      const match = resolveOldString(current, find);
+      if (!match)
         return `multi_edit error: edit #${i + 1} old_string not found in ${target}.`;
+      const { actual, occurrences, via } = match;
       if (occurrences > 1 && !replaceAll)
         return `multi_edit error: edit #${i + 1} old_string appears ${occurrences} times. Pass replace_all=true on this edit or expand old_string for uniqueness.`;
-      current = replaceAll ? current.split(find).join(replacement) : current.replace(find, replacement);
+      let styledReplacement = via === "desanitize" || via === "quotes+desanitize" ? desanitize(replacement) : replacement;
+      if (via === "quotes" || via === "quotes+desanitize")
+        styledReplacement = preserveQuoteStyle(actual, styledReplacement);
+      current = replaceAll ? current.split(actual).join(styledReplacement) : current.replace(actual, styledReplacement);
       applied += occurrences;
     }
     await ctx.execution.writeFile(ctx.handle, target, current);
@@ -524,10 +693,51 @@ var multiEdit = {
 };
 
 // src/tools/read-file.ts
+import { Buffer as Buffer2 } from "buffer";
+
+// src/tools/binary-read.ts
 import { Buffer } from "buffer";
+function imageMediaTypeFor(path) {
+  const dot = path.lastIndexOf(".");
+  if (dot === -1)
+    return void 0;
+  const ext = path.slice(dot + 1).toLowerCase();
+  switch (ext) {
+    case "png":
+      return "image/png";
+    case "jpg":
+    case "jpeg":
+      return "image/jpeg";
+    case "gif":
+      return "image/gif";
+    case "webp":
+      return "image/webp";
+    default:
+      return void 0;
+  }
+}
+async function readFileAsBase64(execution, handle, path) {
+  if (execution.readFileBinary) {
+    const bytes = await execution.readFileBinary(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 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) };
+}
+function shellQuote2(s) {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+
+// 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: {
     name: "read_file",
@@ -544,13 +754,33 @@ var readFile = {
     }
   },
   async execute({ path, offset, limit, maxBytes }, ctx) {
+    const imgMedia = imageMediaTypeFor(path);
+    if (imgMedia) {
+      const sizeCap = maxBytes !== void 0 ? normalizeInteger(maxBytes, DEFAULT_IMAGE_BYTE_CAP) : DEFAULT_IMAGE_BYTE_CAP;
+      try {
+        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 content = [
+          { type: "text", text: `Image: ${path} (${byteLength} bytes, ${imgMedia})` },
+          { type: "image", mediaType: imgMedia, data: base64 }
+        ];
+        return content;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        const hint = await suggestionFor(ctx.execution, ctx.handle, path);
+        return `Image read failed: ${path} \u2014 ${msg}.${hint}`;
+      }
+    }
     let raw;
     try {
       raw = await ctx.execution.readFile(ctx.handle, path);
     } catch {
-      return `File not found: ${path}`;
+      const hint = await suggestionFor(ctx.execution, ctx.handle, path);
+      return `File not found: ${path}.${hint}`;
     }
-    const totalBytes = Buffer.byteLength(raw);
+    const totalBytes = Buffer2.byteLength(raw);
     const dedupEnabled = ctx.behavior?.dedupReads !== false;
     const readState = dedupEnabled ? getReadState(ctx.session) : void 0;
     const absKey = `${ctx.handle.cwd}::${path}`;
@@ -580,7 +810,7 @@ var readFile = {
     if (maxBytesN > 0) {
       const truncatedSlice = [];
       for (const line of slice) {
-        const lineBytes = Buffer.byteLength(line) + 1;
+        const lineBytes = Buffer2.byteLength(line) + 1;
         if (bytesUsed + lineBytes > maxBytesN && truncatedSlice.length > 0) {
           bytesCut = true;
           break;
@@ -597,14 +827,14 @@ var readFile = {
     }
     let midLineCut = false;
     if (maxBytesN > 0 && slice.length > 0) {
-      const bodyBytes = Buffer.byteLength(slice.join("\n"));
+      const bodyBytes = Buffer2.byteLength(slice.join("\n"));
       if (bodyBytes > maxBytesN) {
         const lastIdx = slice.length - 1;
         const lastLine = slice[lastIdx];
-        const otherBytes = lastIdx > 0 ? Buffer.byteLength(slice.slice(0, lastIdx).join("\n")) + 1 : 0;
+        const otherBytes = lastIdx > 0 ? Buffer2.byteLength(slice.slice(0, lastIdx).join("\n")) + 1 : 0;
         const budgetForLast = Math.max(0, maxBytesN - otherBytes);
         let cut = Math.min(lastLine.length, budgetForLast);
-        while (cut > 0 && Buffer.byteLength(lastLine.slice(0, cut)) > budgetForLast)
+        while (cut > 0 && Buffer2.byteLength(lastLine.slice(0, cut)) > budgetForLast)
           cut--;
         slice[lastIdx] = lastLine.slice(0, cut);
         midLineCut = true;
@@ -666,7 +896,38 @@ function looksBinary(text) {
 }
 
 // src/tools/shell.ts
-import { Buffer as Buffer2 } from "buffer";
+import { Buffer as Buffer3 } from "buffer";
+
+// src/tools/shell-semantics.ts
+var DEFAULT_SEMANTIC = (exitCode) => ({
+  isError: exitCode !== 0,
+  message: exitCode !== 0 ? `Command failed with exit code ${exitCode}` : void 0
+});
+var COMMAND_SEMANTICS = /* @__PURE__ */ new Map([
+  // grep / ripgrep: 0 = matches, 1 = no matches, ≥2 = error.
+  ["grep", (exit) => ({ isError: exit >= 2, message: exit === 1 ? "No matches found" : void 0 })],
+  ["rg", (exit) => ({ isError: exit >= 2, message: exit === 1 ? "No matches found" : void 0 })],
+  // diff: 0 = identical, 1 = differ, ≥2 = error.
+  ["diff", (exit) => ({ isError: exit >= 2, message: exit === 1 ? "Files differ" : void 0 })],
+  // find: 0 = ok, 1 = some dirs inaccessible (warning), ≥2 = error.
+  ["find", (exit) => ({ isError: exit >= 2, message: exit === 1 ? "Some directories were inaccessible" : void 0 })],
+  // test / [: 0 = condition true, 1 = condition false, ≥2 = error.
+  ["test", (exit) => ({ isError: exit >= 2, message: exit === 1 ? "Condition is false" : void 0 })],
+  ["[", (exit) => ({ isError: exit >= 2, message: exit === 1 ? "Condition is false" : void 0 })]
+]);
+function interpretShellResult(command, exitCode) {
+  const base = extractTrailingCommand(command);
+  const semantic = COMMAND_SEMANTICS.get(base) ?? DEFAULT_SEMANTIC;
+  return semantic(exitCode);
+}
+function extractTrailingCommand(command) {
+  const segments = command.split(/\|\||&&|[;|\n]/);
+  const last = segments[segments.length - 1]?.trim() ?? command;
+  const tokens = last.split(/\s+/).filter((t) => !/^[A-Z_]\w*=/i.test(t));
+  return tokens[0] ?? "";
+}
+
+// src/tools/shell.ts
 var DEFAULT_MAX_OUTPUT_BYTES = 8192;
 var shell = {
   spec: {
@@ -686,10 +947,19 @@ var shell = {
     const execOpts = {};
     if (typeof timeout === "number" && Number.isFinite(timeout) && timeout > 0)
       execOpts.timeout = Math.max(1, Math.ceil(timeout / 1e3));
-    const result = await ctx.execution.exec(ctx.handle, command, execOpts);
+    const cmd = command;
+    const result = await ctx.execution.exec(ctx.handle, cmd, execOpts);
     const cap = normalizeCap(maxOutputBytes);
+    const semantic = interpretShellResult(cmd, result.exitCode);
     if (result.exitCode === 0)
       return truncateTail(result.stdout || "(no output)", cap);
+    if (!semantic.isError) {
+      const body = (result.stdout || result.stderr || "").trim();
+      const tail = truncateTail(body, cap);
+      const footer = semantic.message ? `
+(${semantic.message})` : "";
+      return tail.length > 0 ? `${tail}${footer}` : semantic.message ?? "(no output)";
+    }
     const combined = `${result.stdout}
 ${result.stderr}`.trim();
     return `Exit code ${result.exitCode}
@@ -706,21 +976,21 @@ function normalizeCap(value) {
 function truncateTail(text, cap) {
   if (cap === 0)
     return text;
-  const totalBytes = Buffer2.byteLength(text);
+  const totalBytes = Buffer3.byteLength(text);
   if (totalBytes <= cap)
     return text;
   let bytes = 0;
   let charIdx = text.length;
   while (charIdx > 0) {
     const ch = text[charIdx - 1];
-    const chBytes = Buffer2.byteLength(ch);
+    const chBytes = Buffer3.byteLength(ch);
     if (bytes + chBytes > cap)
       break;
     bytes += chBytes;
     charIdx--;
   }
   const tail = text.slice(charIdx);
-  const droppedBytes = totalBytes - Buffer2.byteLength(tail);
+  const droppedBytes = totalBytes - Buffer3.byteLength(tail);
   return `\u2026(${droppedBytes} bytes truncated from head)\u2026
 ${tail}`;
 }
@@ -1020,6 +1290,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"]);
@@ -1175,6 +1498,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 }));
 }
@@ -1330,6 +1671,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,
@@ -1337,13 +1679,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 = "";
@@ -1376,7 +1727,13 @@ async function executeTurn(ctx, turn) {
       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) {
@@ -1399,7 +1756,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 = {
@@ -1456,6 +1822,17 @@ async function executeTurn(ctx, turn) {
     }
     return { ended: true, turnId, usage: result.usage };
   }
+  if (canonicalToolCalls.length === 0 && result.usage.finishReason === "pause") {
+    const continueMsg = ctx.provider.userMessage("Please continue.");
+    ctx.turns.push({
+      id: await ctx.generateTurnId(),
+      runId: ctx.runId,
+      role: continueMsg.role,
+      content: continueMsg.content,
+      createdAt: Date.now()
+    });
+    return { ended: false, turnId, usage: result.usage };
+  }
   const toolResults = ctx.toolExecution === "parallel" ? await executeToolsParallel(ctx, canonicalToolCalls, turnId) : await executeToolsSequential(ctx, canonicalToolCalls, turnId);
   const toolResultMsg = ctx.provider.toolResultsMessage(toolResults);
   ctx.turns.push({
@@ -1501,6 +1878,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,
@@ -1508,12 +1886,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 = {
@@ -1571,6 +1964,7 @@ async function executeSingleTool(ctx, call, turnId) {
     name: call.name,
     displayName,
     input: effectiveInput,
+    runToolCounts,
     ...coercions ? { coercions } : {}
   });
   let output;
@@ -1610,12 +2004,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),
@@ -1628,14 +2039,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 = [];
@@ -1744,6 +2156,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",
@@ -1762,6 +2249,7 @@ var HOOK_EVENT_NAMES = [
   "validation:reject",
   "validation:coerce",
   "context:transform",
+  "system:transform",
   "steer:inject",
   "spawn:before",
   "spawn:complete",
@@ -1790,6 +2278,7 @@ var HOOK_EVENT_NAMES = [
   "usage",
   "output",
   "budget:exceeded",
+  "tool-budget:exceeded",
   "agent:abort",
   "agent:done",
   "session:start",
@@ -1813,7 +2302,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 }) {
@@ -1936,7 +2430,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}
@@ -2036,6 +2531,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 {
@@ -2048,7 +2553,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,
@@ -2075,7 +2583,9 @@ ${skillsCatalog}`;
         compactStrategy,
         compactThreshold,
         compactKeepTurns,
-        runStartMs
+        ...thinkingDecay !== void 0 ? { thinkingDecay } : {},
+        runStartMs,
+        runToolCounts: {}
       });
       const finalStats = {
         ...stats,
@@ -2117,6 +2627,8 @@ ${skillsCatalog}`;
     } finally {
       await deactivateAllSkills();
       uninstallAllowedToolsGate();
+      uninstallDedupTools();
+      uninstallToolBudgets();
       unregisterSpawnHook();
       unregisterSessionSync?.();
       for (const unregister of perRunUnregisters)
@@ -2519,7 +3031,7 @@ function createSpawnTool(options = {}) {
 var spawn = createSpawnTool();
 
 // src/tools/write-file.ts
-import { Buffer as Buffer3 } from "buffer";
+import { Buffer as Buffer4 } from "buffer";
 var writeFile = {
   spec: {
     name: "write_file",
@@ -2541,7 +3053,7 @@ var writeFile = {
       existing = await ctx.execution.readFile(ctx.handle, targetPath);
     } catch {
     }
-    const bytes = Buffer3.byteLength(targetContent);
+    const bytes = Buffer4.byteLength(targetContent);
     if (existing === targetContent)
       return `No change needed: ${targetPath} already at target state (${bytes} bytes).`;
     await ctx.execution.writeFile(ctx.handle, targetPath, targetContent);