@wrongstack/core 0.264.0 → 0.267.0

package/dist/types/index.js

@@ -1,8 +1,8 @@
 import { randomBytes, createCipheriv, createDecipheriv, randomUUID } from 'crypto';
 import * as fs from 'fs/promises';
-import * as path4 from 'path';
-import * as fs2 from 'fs';
+import * as path6 from 'path';
 import * as os from 'os';
+import * as fs2 from 'fs';
 
 // src/types/blocks.ts
 function isTextBlock(b) {
@@ -30,9 +30,9 @@ function asText(content) {
   return content.filter((b) => b.type === "text").map((b) => b.text).join("");
 }
 async function atomicWrite(targetPath, content, opts = {}) {
-  const dir = path4.dirname(targetPath);
+  const dir = path6.dirname(targetPath);
   await fs.mkdir(dir, { recursive: true });
-  const tmp = path4.join(dir, `.${path4.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
+  const tmp = path6.join(dir, `.${path6.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
   try {
     if (typeof content === "string") {
       await fs.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
@@ -85,17 +85,12 @@ async function renameWithRetry(from, to) {
       if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
         throw err;
       }
-      await new Promise((resolve4) => setTimeout(resolve4, delays[i]));
+      await new Promise((resolve6) => setTimeout(resolve6, delays[i]));
     }
   }
   throw lastErr;
 }
 
-// src/utils/error.ts
-function toErrorMessage(err) {
-  return err instanceof Error ? err.message : String(err);
-}
-
 // src/utils/term.ts
 var hasStdout = () => typeof process !== "undefined" && !!process.stdout;
 function isStdoutTTY() {
@@ -143,20 +138,75 @@ var color = {
   bgRed: wrap("41", "49"),
   bgGreen: wrap("42", "49")
 };
-
-// src/utils/string.ts
-function truncate(s, max) {
-  return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
+var MAX_DIGEST_CHARS = 4e3;
+function createContextEvidenceState() {
+  return {
+    sessionGoals: [],
+    implicitFacts: [],
+    activeErrors: [],
+    toolCalls: [],
+    fileGraph: {},
+    repeatedReads: [],
+    updatedAt: Date.now()
+  };
 }
-
-// src/utils/expect-defined.ts
-function expectDefined(value, label) {
-  if (value === null || value === void 0) {
-    const err = new Error("Expected value to be defined");
-    err.name = "ExpectDefinedError";
-    throw err;
+function buildContextEvidenceDigest(ctx) {
+  const state = ensureEvidence(ctx);
+  const lines = [];
+  if (state.currentIntent?.text) {
+    lines.push(`intent: ${state.currentIntent.text}`);
+  }
+  const goals = state.sessionGoals.slice(-3);
+  if (goals.length > 0) {
+    lines.push("session_goals:");
+    for (const goal of goals) lines.push(`- ${goal}`);
+  }
+  const activeErrors = state.activeErrors.slice(-5);
+  if (activeErrors.length > 0) {
+    lines.push("active_errors:");
+    for (const err of activeErrors) lines.push(`- ${err}`);
+  }
+  const files = Object.values(state.fileGraph).sort((a, b) => b.writes - a.writes || b.reads - a.reads || a.path.localeCompare(b.path)).slice(0, 12);
+  if (files.length > 0) {
+    lines.push("dependency_graph:");
+    for (const file of files) {
+      const actions = [
+        file.reads > 0 ? `read ${file.reads}x` : "",
+        file.writes > 0 ? `write ${file.writes}x` : ""
+      ].filter(Boolean).join(", ");
+      const refs = file.referenced ? "; referenced by assistant" : "";
+      const via = file.lastToolUseId ? `; last via ${file.lastToolUseId}` : "";
+      lines.push(`- ${file.path} (${actions || "seen"}${refs}${via})`);
+    }
   }
-  return value;
+  const referenced = state.toolCalls.filter((tool) => tool.status === "referenced").slice(-10);
+  const recentSeen = state.toolCalls.filter((tool) => tool.status === "seen").slice(-5);
+  const trail = [...referenced, ...recentSeen];
+  if (trail.length > 0) {
+    lines.push("tool_trail:");
+    for (const tool of trail) {
+      const size = tool.outputTokens ? `; ~${tool.outputTokens} tokens` : "";
+      const filesText = tool.files.length > 0 ? `; files=${tool.files.slice(0, 4).join(", ")}` : "";
+      const symbolsText = tool.symbols.length > 0 ? `; symbols=${tool.symbols.slice(0, 4).join(", ")}` : "";
+      lines.push(
+        `- ${tool.toolUseId} ${tool.toolName} ${tool.status}: ${tool.summary}${filesText}${symbolsText}${size}`
+      );
+    }
+  }
+  const facts = state.implicitFacts.slice(-8);
+  if (facts.length > 0) {
+    lines.push("implicit_facts:");
+    for (const fact of facts) lines.push(`- ${fact}`);
+  }
+  const digest = lines.join("\n");
+  if (digest.length <= MAX_DIGEST_CHARS) return digest;
+  return `${digest.slice(0, MAX_DIGEST_CHARS)}... [+${digest.length - MAX_DIGEST_CHARS} chars]`;
+}
+function ensureEvidence(ctx) {
+  if (!ctx.contextEvidence) {
+    ctx.contextEvidence = createContextEvidenceState();
+  }
+  return ctx.contextEvidence;
 }
 
 // src/utils/deep-merge.ts
@@ -218,173 +268,179 @@ function deepMerge(base, patch, options = {}) {
   return out;
 }
 
-// src/utils/tool-output-serializer.ts
-function createToolOutputSerializer(opts = {}) {
-  const capBytes = opts.perIterationOutputCapBytes ?? 1e5;
-  function serialize(value) {
-    if (typeof value === "string") return value;
-    if (value === null || value === void 0) return "";
-    if (typeof value === "object") {
-      if (Array.isArray(value)) return value.map(serialize).join("\n");
-      if ("text" in value) {
-        const t = value.text;
-        return typeof t === "string" ? t : JSON.stringify(value, null, 2);
-      }
-      try {
-        return JSON.stringify(value, null, 2);
-      } catch {
-        return String(value);
-      }
+// src/utils/error.ts
+function toErrorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/utils/expect-defined.ts
+function expectDefined(value, label) {
+  if (value === null || value === void 0) {
+    const err = new Error("Expected value to be defined");
+    err.name = "ExpectDefinedError";
+    throw err;
+  }
+  return value;
+}
+
+// src/utils/json-schema-validate.ts
+function validateAgainstSchema(value, schema) {
+  const errors = [];
+  walk(value, schema, "", errors);
+  return { ok: errors.length === 0, errors };
+}
+function walk(value, schema, path10, errors) {
+  if (schema.enum !== void 0) {
+    if (!schema.enum.some((e) => deepEqual(e, value))) {
+      errors.push({
+        path: path10 || "<root>",
+        message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
+      });
+      return;
     }
-    return String(value);
   }
-  function enforceCap(text, remainingBudget) {
-    if (remainingBudget <= 0) {
-      return { text: "[truncated: iteration output cap exceeded]", newBudget: 0 };
+  if (typeof schema.type === "string") {
+    if (!checkType(value, schema.type)) {
+      errors.push({
+        path: path10 || "<root>",
+        message: `expected ${schema.type}, got ${describeType(value)}`
+      });
+      return;
     }
-    const textBytes = Buffer.byteLength(text, "utf8");
-    if (textBytes <= remainingBudget) {
-      return { text, newBudget: remainingBudget - textBytes };
+  }
+  if (schema.type === "object" && isPlainObject(value)) {
+    const obj = value;
+    for (const req of schema.required ?? []) {
+      if (!(req in obj)) {
+        errors.push({ path: joinPath(path10, req), message: "required property missing" });
+      }
     }
-    const marker = `
-\u2026[truncated ${textBytes - remainingBudget} bytes]\u2026
-`;
-    const markerBytes = Buffer.byteLength(marker, "utf8");
-    const available = remainingBudget - markerBytes;
-    if (available <= 0) {
-      return { text: "[truncated: iteration output cap exceeded]", newBudget: 0 };
+    if (schema.properties) {
+      for (const [key, subSchema] of Object.entries(schema.properties)) {
+        if (key in obj) {
+          walk(obj[key], subSchema, joinPath(path10, key), errors);
+        }
+      }
     }
-    const half = Math.floor(available / 2);
-    const first = text.slice(0, half);
-    const second = text.slice(text.length - half);
-    return { text: `${first}${marker}${second}`, newBudget: 0 };
-  }
-  return { serialize, enforceCap, capBytes };
-}
-
-// src/utils/token-estimate.ts
-var RoughTokenEstimate = (text, charsPerToken = 3.5) => Math.max(1, Math.ceil(text.length / charsPerToken));
-var CALIBRATION_GLOBAL_KEY = "__global__";
-var _cals = /* @__PURE__ */ new Map();
-function calState(key) {
-  let state = _cals.get(key);
-  if (!state) {
-    state = { ratio: 1, count: 0, prevEst: 0 };
-    _cals.set(key, state);
   }
-  return state;
-}
-var ESTIMATE_CACHE = /* @__PURE__ */ new Map();
-var ESTIMATE_CACHE_MAX_SIZE = 1e4;
-function getCachedEstimate(key, compute) {
-  const existing = ESTIMATE_CACHE.get(key);
-  if (existing !== void 0) return existing;
-  if (ESTIMATE_CACHE.size >= ESTIMATE_CACHE_MAX_SIZE) {
-    let evicted = 0;
-    const maxEvict = Math.floor(ESTIMATE_CACHE_MAX_SIZE / 4);
-    for (const k of ESTIMATE_CACHE.keys()) {
-      if (evicted >= maxEvict) break;
-      ESTIMATE_CACHE.delete(k);
-      evicted++;
+  if (schema.type === "array" && Array.isArray(value) && schema.items) {
+    for (let i = 0; i < value.length; i++) {
+      walk(value[i], schema.items, `${path10}[${i}]`, errors);
     }
   }
-  const estimate = compute(key);
-  ESTIMATE_CACHE.set(key, estimate);
-  return estimate;
 }
-function estimateToolInputTokens(input) {
-  if (typeof input === "string") return RoughTokenEstimate(input);
-  if (input === null || typeof input !== "object") {
-    return RoughTokenEstimate(String(input));
+function checkType(value, type) {
+  switch (type) {
+    case "string":
+      return typeof value === "string";
+    case "number":
+      return typeof value === "number" && !Number.isNaN(value);
+    case "integer":
+      return typeof value === "number" && Number.isInteger(value);
+    case "boolean":
+      return typeof value === "boolean";
+    case "null":
+      return value === null;
+    case "array":
+      return Array.isArray(value);
+    case "object":
+      return isPlainObject(value);
+    default:
+      return true;
   }
-  return getCachedEstimate(JSON.stringify(input), (key) => RoughTokenEstimate(key));
 }
-function estimateToolResultTokens(content) {
-  if (typeof content === "string") return RoughTokenEstimate(content);
-  return getCachedEstimate(JSON.stringify(content), (key) => RoughTokenEstimate(key));
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
 }
-function estimateTextTokens(text) {
-  return RoughTokenEstimate(text);
+function describeType(v) {
+  if (v === null) return "null";
+  if (Array.isArray(v)) return "array";
+  return typeof v;
 }
-function computeMessageTokens(msg) {
-  if (typeof msg.content === "string") return estimateTextTokens(msg.content);
-  let total = 0;
-  for (const b of msg.content) {
-    if (b.type === "text") total += estimateTextTokens(b.text);
-    else if (b.type === "tool_use") total += estimateToolInputTokens(b.input);
-    else if (b.type === "tool_result") total += estimateToolResultTokens(b.content);
-    else total += RoughTokenEstimate(JSON.stringify(b));
-  }
-  return total;
+function joinPath(parent, key) {
+  if (!parent) return key;
+  return `${parent}.${key}`;
 }
-function estimateMessageTokens(messages) {
-  let total = 0;
-  for (const m of messages) {
-    if (typeof m._estTokens === "number" && m._estTokens > 0) {
-      total += m._estTokens;
-      continue;
-    }
-    total += computeMessageTokens(m);
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (a === null || b === null) return a === b;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((v, i) => deepEqual(v, b[i]));
   }
-  return total;
-}
-function estimateToolDefTokens(tool) {
-  const cached = tool._estDefTokens;
-  if (typeof cached === "number" && cached > 0) return cached;
-  return RoughTokenEstimate(tool.name) + RoughTokenEstimate(tool.description ?? "") + RoughTokenEstimate(JSON.stringify(tool.inputSchema));
+  if (typeof a === "object" && typeof b === "object") {
+    const ak = Object.keys(a);
+    const bk = Object.keys(b);
+    if (ak.length !== bk.length) return false;
+    return ak.every(
+      (k) => deepEqual(a[k], b[k])
+    );
+  }
+  return false;
 }
-function estimateRequestTokens(messages, systemPrompt, tools, calibrationKey = CALIBRATION_GLOBAL_KEY) {
-  let messagesTokens = 0;
-  if (typeof messages === "string") {
-    messagesTokens = RoughTokenEstimate(messages);
-  } else if (Array.isArray(messages)) {
-    for (const m of messages) {
-      if (typeof m === "object" && m !== null && "content" in m) {
-        const cached = m._estTokens;
-        if (typeof cached === "number" && cached > 0) {
-          messagesTokens += cached;
-          continue;
-        }
-        const content = m.content;
-        if (typeof content === "string") {
-          messagesTokens += RoughTokenEstimate(content);
-        } else if (Array.isArray(content)) {
-          for (const b of content) {
-            if (typeof b === "object" && b !== null) {
-              if (b.type === "text") {
-                messagesTokens += RoughTokenEstimate(b.text);
-              } else {
-                messagesTokens += RoughTokenEstimate(JSON.stringify(b));
-              }
-            }
-          }
-        }
-      }
-    }
+
+// src/utils/merge-models-payload.ts
+function mergeModelsPayload(base, overlay) {
+  const out = {};
+  for (const [id, provider] of Object.entries(base)) {
+    out[id] = cloneProvider(provider);
   }
-  let systemTokens = 0;
-  if (typeof systemPrompt === "string") {
-    systemTokens = RoughTokenEstimate(systemPrompt);
-  } else if (Array.isArray(systemPrompt)) {
-    for (const b of systemPrompt) {
-      if (typeof b === "object" && b !== null && b.type === "text") {
-        systemTokens += RoughTokenEstimate(b.text);
-      }
-    }
+  for (const [id, ovProvider] of Object.entries(overlay)) {
+    const existing = out[id];
+    out[id] = existing ? mergeProvider(existing, ovProvider) : cloneProvider(ovProvider);
   }
-  let toolsTokens = 0;
-  for (const t of tools) {
-    toolsTokens += estimateToolDefTokens(t);
+  return out;
+}
+function mergeProvider(base, overlay) {
+  const models = {};
+  for (const [mid, m] of Object.entries(base.models ?? {})) {
+    models[mid] = { ...m };
+  }
+  for (const [mid, ovModel] of Object.entries(overlay.models ?? {})) {
+    const existing = models[mid];
+    models[mid] = existing ? mergeModel(existing, ovModel) : { ...ovModel };
   }
-  const total = messagesTokens + systemTokens + toolsTokens;
-  calState(calibrationKey).prevEst = total;
   return {
-    messages: messagesTokens,
-    systemPrompt: systemTokens,
-    tools: toolsTokens,
-    total
+    ...base,
+    // Overlay scalar fields win when explicitly provided; otherwise keep base.
+    ...stripUndefined({
+      id: overlay.id,
+      name: overlay.name,
+      npm: overlay.npm,
+      api: overlay.api,
+      env: overlay.env,
+      doc: overlay.doc
+    }),
+    models
   };
 }
+function mergeModel(base, overlay) {
+  const merged = { ...base, ...overlay };
+  if (base.limit || overlay.limit) {
+    merged.limit = { ...base.limit, ...overlay.limit };
+  }
+  if (base.cost || overlay.cost) {
+    merged.cost = { ...base.cost, ...overlay.cost };
+  }
+  if (base.modalities || overlay.modalities) {
+    merged.modalities = { ...base.modalities, ...overlay.modalities };
+  }
+  return merged;
+}
+function cloneProvider(p) {
+  const models = {};
+  for (const [mid, m] of Object.entries(p.models ?? {})) {
+    models[mid] = { ...m };
+  }
+  return { ...p, models };
+}
+function stripUndefined(obj) {
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v !== void 0) out[k] = v;
+  }
+  return out;
+}
 
 // src/utils/message-invariants.ts
 function repairToolUseAdjacency(messages) {
@@ -478,102 +534,6 @@ function isEmptyMessage(msg) {
   return msg.content.length === 0;
 }
 
-// src/utils/json-schema-validate.ts
-function validateAgainstSchema(value, schema) {
-  const errors = [];
-  walk(value, schema, "", errors);
-  return { ok: errors.length === 0, errors };
-}
-function walk(value, schema, path7, errors) {
-  if (schema.enum !== void 0) {
-    if (!schema.enum.some((e) => deepEqual(e, value))) {
-      errors.push({
-        path: path7 || "<root>",
-        message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
-      });
-      return;
-    }
-  }
-  if (typeof schema.type === "string") {
-    if (!checkType(value, schema.type)) {
-      errors.push({
-        path: path7 || "<root>",
-        message: `expected ${schema.type}, got ${describeType(value)}`
-      });
-      return;
-    }
-  }
-  if (schema.type === "object" && isPlainObject(value)) {
-    const obj = value;
-    for (const req of schema.required ?? []) {
-      if (!(req in obj)) {
-        errors.push({ path: joinPath(path7, req), message: "required property missing" });
-      }
-    }
-    if (schema.properties) {
-      for (const [key, subSchema] of Object.entries(schema.properties)) {
-        if (key in obj) {
-          walk(obj[key], subSchema, joinPath(path7, key), errors);
-        }
-      }
-    }
-  }
-  if (schema.type === "array" && Array.isArray(value) && schema.items) {
-    for (let i = 0; i < value.length; i++) {
-      walk(value[i], schema.items, `${path7}[${i}]`, errors);
-    }
-  }
-}
-function checkType(value, type) {
-  switch (type) {
-    case "string":
-      return typeof value === "string";
-    case "number":
-      return typeof value === "number" && !Number.isNaN(value);
-    case "integer":
-      return typeof value === "number" && Number.isInteger(value);
-    case "boolean":
-      return typeof value === "boolean";
-    case "null":
-      return value === null;
-    case "array":
-      return Array.isArray(value);
-    case "object":
-      return isPlainObject(value);
-    default:
-      return true;
-  }
-}
-function isPlainObject(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function describeType(v) {
-  if (v === null) return "null";
-  if (Array.isArray(v)) return "array";
-  return typeof v;
-}
-function joinPath(parent, key) {
-  if (!parent) return key;
-  return `${parent}.${key}`;
-}
-function deepEqual(a, b) {
-  if (a === b) return true;
-  if (typeof a !== typeof b) return false;
-  if (a === null || b === null) return a === b;
-  if (Array.isArray(a) && Array.isArray(b)) {
-    return a.length === b.length && a.every((v, i) => deepEqual(v, b[i]));
-  }
-  if (typeof a === "object" && typeof b === "object") {
-    const ak = Object.keys(a);
-    const bk = Object.keys(b);
-    if (ak.length !== bk.length) return false;
-    return ak.every(
-      (k) => deepEqual(a[k], b[k])
-    );
-  }
-  return false;
-}
-
 // src/utils/regex-guard.ts
 var MAX_PATTERN_LEN = 512;
 var DANGEROUS_PATTERNS = [
@@ -599,78 +559,858 @@ function compileUserRegex(pattern, flags) {
         reason: "pattern looks vulnerable to catastrophic backtracking \u2014 rewrite without nested quantifiers"
       };
     }
-  }
-  try {
-    return { ok: true, regex: new RegExp(pattern, flags) };
-  } catch (err) {
-    return {
-      ok: false,
-      reason: err instanceof Error ? err.message : "invalid regex"
-    };
-  }
+  }
+  try {
+    return { ok: true, regex: new RegExp(pattern, flags) };
+  } catch (err) {
+    return {
+      ok: false,
+      reason: err instanceof Error ? err.message : "invalid regex"
+    };
+  }
+}
+
+// src/utils/string.ts
+function truncate(s, max) {
+  return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
+}
+
+// src/utils/tool-wire-compact.ts
+var TOOL_DESCRIPTION_MAX_CHARS = 640;
+var SCHEMA_DESCRIPTION_MAX_CHARS = 180;
+var compactCache = /* @__PURE__ */ new WeakMap();
+function compactToolDefinitionForWire(tool, opts = {}) {
+  const useDefaultOptions = opts.descriptionMaxChars === void 0 && opts.schemaDescriptionMaxChars === void 0;
+  if (useDefaultOptions && typeof tool === "object" && tool !== null) {
+    const cached = compactCache.get(tool);
+    if (cached) return cached;
+  }
+  const compact = {
+    name: tool.name,
+    description: compactDescription(
+      tool.description ?? "",
+      opts.descriptionMaxChars ?? TOOL_DESCRIPTION_MAX_CHARS
+    ),
+    inputSchema: compactSchemaDescriptions(
+      tool.inputSchema,
+      opts.schemaDescriptionMaxChars ?? SCHEMA_DESCRIPTION_MAX_CHARS
+    )
+  };
+  if (useDefaultOptions && typeof tool === "object" && tool !== null) {
+    compactCache.set(tool, compact);
+  }
+  return compact;
+}
+function compactSchemaDescriptions(schema, maxDescriptionChars = SCHEMA_DESCRIPTION_MAX_CHARS) {
+  const compact = compactSchemaNode(schema, maxDescriptionChars);
+  return isRecord(compact) ? compact : { type: "object", properties: {} };
+}
+function compactSchemaNode(node, maxDescriptionChars) {
+  if (Array.isArray(node)) {
+    return node.map((item) => compactSchemaNode(item, maxDescriptionChars));
+  }
+  if (!isRecord(node)) return node;
+  const out = {};
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "description" && typeof value === "string") {
+      out[key] = compactDescription(value, maxDescriptionChars);
+    } else {
+      out[key] = compactSchemaNode(value, maxDescriptionChars);
+    }
+  }
+  return out;
+}
+function compactDescription(text, maxChars) {
+  const normalized = text.replace(/\s+/g, " ").trim();
+  if (normalized.length <= maxChars) return normalized;
+  if (maxChars <= 20) return normalized.slice(0, maxChars);
+  const hardLimit = maxChars - 12;
+  const boundary = findSemanticBoundary(normalized, hardLimit);
+  const head = normalized.slice(0, boundary > 0 ? boundary : hardLimit).trimEnd();
+  return `${head} ...`;
+}
+function findSemanticBoundary(text, limit) {
+  const punctuation = Math.max(
+    text.lastIndexOf(". ", limit),
+    text.lastIndexOf("; ", limit),
+    text.lastIndexOf(": ", limit)
+  );
+  if (punctuation >= Math.floor(limit * 0.45)) return punctuation + 1;
+  const comma = text.lastIndexOf(", ", limit);
+  if (comma >= Math.floor(limit * 0.6)) return comma + 1;
+  const space = text.lastIndexOf(" ", limit);
+  return space >= Math.floor(limit * 0.6) ? space : limit;
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/utils/token-estimate.ts
+var RoughTokenEstimate = (text, charsPerToken = 3.5) => Math.max(1, Math.ceil(text.length / charsPerToken));
+var CALIBRATION_GLOBAL_KEY = "__global__";
+var _cals = /* @__PURE__ */ new Map();
+function calState(key) {
+  let state = _cals.get(key);
+  if (!state) {
+    state = { ratio: 1, count: 0, prevEst: 0 };
+    _cals.set(key, state);
+  }
+  return state;
+}
+var ESTIMATE_CACHE = /* @__PURE__ */ new Map();
+var ESTIMATE_CACHE_MAX_SIZE = 1e4;
+function getCachedEstimate(key, compute) {
+  const existing = ESTIMATE_CACHE.get(key);
+  if (existing !== void 0) return existing;
+  if (ESTIMATE_CACHE.size >= ESTIMATE_CACHE_MAX_SIZE) {
+    for (const k of ESTIMATE_CACHE.keys()) {
+      if (ESTIMATE_CACHE.size <= Math.floor(ESTIMATE_CACHE_MAX_SIZE / 2)) break;
+      ESTIMATE_CACHE.delete(k);
+    }
+  }
+  const estimate = compute(key);
+  ESTIMATE_CACHE.set(key, estimate);
+  return estimate;
+}
+function estimateToolInputTokens(input) {
+  if (typeof input === "string") return RoughTokenEstimate(input);
+  if (input === null || typeof input !== "object") {
+    return RoughTokenEstimate(String(input));
+  }
+  return getCachedEstimate(JSON.stringify(input), (key) => RoughTokenEstimate(key));
+}
+function estimateToolResultTokens(content) {
+  if (typeof content === "string") return RoughTokenEstimate(content);
+  return getCachedEstimate(JSON.stringify(content), (key) => RoughTokenEstimate(key));
+}
+function estimateTextTokens(text) {
+  return RoughTokenEstimate(text);
+}
+function computeMessageTokens(msg) {
+  if (typeof msg.content === "string") return estimateTextTokens(msg.content);
+  let total = 0;
+  for (const b of msg.content) {
+    if (b.type === "text") total += estimateTextTokens(b.text);
+    else if (b.type === "tool_use") total += estimateToolInputTokens(b.input);
+    else if (b.type === "tool_result") total += estimateToolResultTokens(b.content);
+    else total += RoughTokenEstimate(JSON.stringify(b));
+  }
+  return total;
+}
+function estimateMessageTokens(messages) {
+  let total = 0;
+  for (const m of messages) {
+    if (typeof m._estTokens === "number" && m._estTokens > 0) {
+      total += m._estTokens;
+      continue;
+    }
+    total += computeMessageTokens(m);
+  }
+  return total;
+}
+function estimateToolDefTokens(tool) {
+  const cached = tool._estDefTokens;
+  if (typeof cached === "number" && cached > 0) return cached;
+  const compact = compactToolDefinitionForWire(tool);
+  return RoughTokenEstimate(tool.name) + RoughTokenEstimate(compact.description) + RoughTokenEstimate(JSON.stringify(compact.inputSchema));
+}
+function estimateRequestTokens(messages, systemPrompt, tools, calibrationKey = CALIBRATION_GLOBAL_KEY) {
+  let messagesTokens = 0;
+  if (typeof messages === "string") {
+    messagesTokens = RoughTokenEstimate(messages);
+  } else if (Array.isArray(messages)) {
+    for (const m of messages) {
+      if (typeof m === "object" && m !== null && "content" in m) {
+        const cached = m._estTokens;
+        if (typeof cached === "number" && cached > 0) {
+          messagesTokens += cached;
+          continue;
+        }
+        const content = m.content;
+        if (typeof content === "string") {
+          messagesTokens += RoughTokenEstimate(content);
+        } else if (Array.isArray(content)) {
+          for (const b of content) {
+            if (typeof b === "object" && b !== null) {
+              if (b.type === "text") {
+                messagesTokens += RoughTokenEstimate(b.text);
+              } else {
+                messagesTokens += RoughTokenEstimate(JSON.stringify(b));
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  let systemTokens = 0;
+  if (typeof systemPrompt === "string") {
+    systemTokens = RoughTokenEstimate(systemPrompt);
+  } else if (Array.isArray(systemPrompt)) {
+    for (const b of systemPrompt) {
+      if (typeof b === "object" && b !== null && b.type === "text") {
+        systemTokens += RoughTokenEstimate(b.text);
+      }
+    }
+  }
+  let toolsTokens = 0;
+  for (const t of tools) {
+    toolsTokens += estimateToolDefTokens(t);
+  }
+  const total = messagesTokens + systemTokens + toolsTokens;
+  calState(calibrationKey).prevEst = total;
+  return {
+    messages: messagesTokens,
+    systemPrompt: systemTokens,
+    tools: toolsTokens,
+    total
+  };
+}
+
+// src/utils/tool-output-serializer.ts
+var DEFAULT_LIST_LIMIT = 500;
+var LOG_ENTRY_LIMIT = 200;
+var INLINE_LIMIT = 240;
+var GREP_FILE_LIMIT = 80;
+var GREP_MATCHES_PER_FILE = 3;
+var DIFF_INLINE_LINE_LIMIT = 260;
+var DIFF_HUNK_LIMIT = 8;
+var DIFF_HUNK_CONTEXT = 14;
+function createToolOutputSerializer(opts = {}) {
+  const capBytes = opts.perIterationOutputCapBytes ?? 1e5;
+  function serialize(value, context = {}) {
+    if (typeof value === "string") return value;
+    if (value === null || value === void 0) return "";
+    if (typeof value === "object") {
+      if (Array.isArray(value)) return value.map((item) => serialize(item)).join("\n");
+      if (context.toolName) {
+        const compact = renderToolObject(context.toolName, value, context.input);
+        if (compact !== void 0) return compact;
+        return renderGenericToolObject(context.toolName, value);
+      }
+      if ("text" in value) {
+        const t = value.text;
+        return typeof t === "string" ? t : JSON.stringify(value, null, 2);
+      }
+      try {
+        return JSON.stringify(value, null, 2);
+      } catch {
+        return String(value);
+      }
+    }
+    return String(value);
+  }
+  function enforceCap(text, remainingBudget) {
+    if (remainingBudget <= 0) {
+      return { text: "[truncated: iteration output cap exceeded]", newBudget: 0 };
+    }
+    const textBytes = Buffer.byteLength(text, "utf8");
+    if (textBytes <= remainingBudget) {
+      return { text, newBudget: remainingBudget - textBytes };
+    }
+    const marker = `
+\u2026[truncated ${textBytes - remainingBudget} bytes]\u2026
+`;
+    const markerBytes = Buffer.byteLength(marker, "utf8");
+    const available = remainingBudget - markerBytes;
+    if (available <= 0) {
+      return { text: "[truncated: iteration output cap exceeded]", newBudget: 0 };
+    }
+    const half = Math.floor(available / 2);
+    const first = text.slice(0, half);
+    const second = text.slice(text.length - half);
+    return { text: `${first}${marker}${second}`, newBudget: 0 };
+  }
+  return { serialize, enforceCap, capBytes };
+}
+function renderToolObject(toolName, obj, input) {
+  if (toolName === "read" && typeof obj["text"] === "string") {
+    return joinSections([
+      renderHeader(
+        `read: ${stringFromInput(input, "path") ?? stringField(obj, "path") ?? "<unknown>"}`,
+        {
+          offset: numberFromInput(input, "offset"),
+          limit: numberFromInput(input, "limit"),
+          total_lines: obj["total_lines"],
+          encoding: obj["encoding"],
+          truncated: obj["truncated"],
+          cached: obj["cached"],
+          note: obj["note"]
+        }
+      ),
+      obj["text"]
+    ]);
+  }
+  if (toolName === "grep" && Array.isArray(obj["matches"])) {
+    const matches = stringArrayField(obj, "matches");
+    return joinSections([
+      renderHeader(`grep: ${stringFromInput(input, "pattern") ?? "<pattern>"}`, {
+        path: stringFromInput(input, "path"),
+        glob: stringFromInput(input, "glob"),
+        mode: stringFromInput(input, "output_mode"),
+        count: obj["count"],
+        shown: matches.length,
+        truncated: obj["truncated"],
+        used: obj["used"]
+      }),
+      renderGrepMatches(matches, stringFromInput(input, "output_mode"))
+    ]);
+  }
+  if (toolName === "patch" && Array.isArray(obj["files"])) {
+    const files = stringArrayField(obj, "files");
+    return joinSections([
+      renderHeader("patch", {
+        applied: obj["applied"],
+        rejected: obj["rejected"],
+        files: files.length,
+        dry_run: obj["dry_run"]
+      }),
+      typeof obj["message"] === "string" ? `message:
+${obj["message"]}` : void 0,
+      files.length > 0 ? `files:
+${renderStringList(files)}` : void 0
+    ]);
+  }
+  if (toolName === "glob" && Array.isArray(obj["files"])) {
+    const files = stringArrayField(obj, "files");
+    return joinSections([
+      renderHeader(
+        `${toolName}: ${stringFromInput(input, "pattern") ?? stringFromInput(input, "files") ?? stringFromInput(input, "path") ?? ""}`.trim(),
+        {
+          path: stringFromInput(input, "path"),
+          files: files.length,
+          truncated: obj["truncated"]
+        }
+      ),
+      renderStringList(files, "(no files)")
+    ]);
+  }
+  if (toolName === "tree" && typeof obj["tree"] === "string") {
+    return joinSections([
+      renderHeader(
+        `tree: ${stringField(obj, "path") ?? stringFromInput(input, "path") ?? "<cwd>"}`,
+        {
+          total_files: obj["total_files"],
+          total_dirs: obj["total_dirs"],
+          truncated: obj["truncated"]
+        }
+      ),
+      obj["tree"]
+    ]);
+  }
+  if (toolName === "fetch" && typeof obj["content"] === "string") {
+    return joinSections([
+      renderHeader(
+        `fetch: ${stringField(obj, "url") ?? stringFromInput(input, "url") ?? "<url>"}`,
+        {
+          status: obj["status"],
+          content_type: obj["content_type"]
+        }
+      ),
+      obj["content"]
+    ]);
+  }
+  if (toolName === "replace" && Array.isArray(obj["results"])) {
+    const results = obj["results"].filter(isRecord2);
+    const sections = [
+      renderHeader("replace", {
+        files_modified: obj["files_modified"],
+        total_replacements: obj["total_replacements"],
+        dry_run: obj["dry_run"]
+      })
+    ];
+    for (const r of results.slice(0, DEFAULT_LIST_LIMIT)) {
+      sections.push(
+        joinSections([
+          renderHeader(`file: ${stringField(r, "path") ?? "<unknown>"}`, {
+            replacements: r["replacements"]
+          }),
+          typeof r["diff"] === "string" ? r["diff"] : void 0
+        ])
+      );
+    }
+    if (results.length > DEFAULT_LIST_LIMIT) {
+      sections.push(`[serializer omitted ${results.length - DEFAULT_LIST_LIMIT} result item(s)]`);
+    }
+    return joinSections(sections);
+  }
+  if (typeof obj["diff"] === "string") {
+    const diff = obj["diff"];
+    return joinSections([
+      renderHeader(toolName, {
+        path: obj["path"],
+        replacements: obj["replacements"],
+        bytes_written: obj["bytes_written"],
+        created: obj["created"],
+        note: obj["note"],
+        files: Array.isArray(obj["files"]) ? obj["files"].length : void 0,
+        truncated: obj["truncated"],
+        mode: obj["mode"]
+      }),
+      compactDiff(diff)
+    ]);
+  }
+  if (toolName === "test" && typeof obj["output"] === "string") {
+    return renderTestOutput(obj, input);
+  }
+  if ((toolName === "typecheck" || toolName === "lint" || toolName === "format") && typeof obj["output"] === "string") {
+    return renderVerifierOutput(toolName, obj, input);
+  }
+  if (hasCommandOutputShape(obj)) {
+    return renderCommandOutput(toolName, obj, input);
+  }
+  if (toolName === "json" && typeof obj["formatted"] === "string") {
+    return joinSections([
+      renderHeader("json", {
+        type: obj["type"],
+        keys: Array.isArray(obj["keys"]) ? obj["keys"].length : void 0,
+        query: stringFromInput(input, "query"),
+        error: obj["error"]
+      }),
+      obj["formatted"]
+    ]);
+  }
+  if (toolName === "logs" && Array.isArray(obj["entries"])) {
+    const entries = obj["entries"].filter(isRecord2);
+    const lines = entries.slice(0, LOG_ENTRY_LIMIT).map((entry) => {
+      const ts = stringField(entry, "timestamp") ?? "";
+      const level = stringField(entry, "level") ?? "info";
+      const message = stringField(entry, "message") ?? "";
+      const source = stringField(entry, "source");
+      return [ts, level, source, message].filter(Boolean).join(" ");
+    });
+    if (entries.length > LOG_ENTRY_LIMIT) {
+      lines.push(`[serializer omitted ${entries.length - LOG_ENTRY_LIMIT} log entry item(s)]`);
+    }
+    return joinSections([
+      renderHeader(`logs: ${stringField(obj, "source") ?? "<source>"}`, {
+        total: obj["total"],
+        shown: Math.min(entries.length, LOG_ENTRY_LIMIT),
+        truncated: obj["truncated"],
+        stream_mode: obj["stream_mode"]
+      }),
+      lines.length > 0 ? lines.join("\n") : "(no log entries)"
+    ]);
+  }
+  if (toolName === "audit" && Array.isArray(obj["vulnerabilities"])) {
+    const vulns = obj["vulnerabilities"].filter(isRecord2);
+    const lines = vulns.slice(0, DEFAULT_LIST_LIMIT).map((v) => {
+      const severity = stringField(v, "severity") ?? "unknown";
+      const pkg = stringField(v, "package") ?? "<package>";
+      const title = stringField(v, "title") ?? "";
+      const url = stringField(v, "url");
+      return [severity, pkg, title, url].filter(Boolean).join(" | ");
+    });
+    if (vulns.length > DEFAULT_LIST_LIMIT) {
+      lines.push(`[serializer omitted ${vulns.length - DEFAULT_LIST_LIMIT} vulnerability item(s)]`);
+    }
+    return joinSections([
+      renderHeader("audit", {
+        exit_code: obj["exit_code"],
+        total: obj["total"],
+        summary: obj["summary"],
+        truncated: obj["truncated"]
+      }),
+      lines.length > 0 ? lines.join("\n") : stringField(obj, "output")
+    ]);
+  }
+  if (toolName === "outdated" && Array.isArray(obj["packages"])) {
+    const packages = obj["packages"].filter(isRecord2);
+    const lines = packages.slice(0, DEFAULT_LIST_LIMIT).map(
+      (p) => [
+        stringField(p, "name") ?? "<package>",
+        `current=${stringField(p, "current") ?? "unknown"}`,
+        `wanted=${stringField(p, "wanted") ?? "unknown"}`,
+        `latest=${stringField(p, "latest") ?? "unknown"}`,
+        stringField(p, "type")
+      ].filter(Boolean).join(" | ")
+    );
+    if (packages.length > DEFAULT_LIST_LIMIT) {
+      lines.push(`[serializer omitted ${packages.length - DEFAULT_LIST_LIMIT} package item(s)]`);
+    }
+    return joinSections([
+      renderHeader("outdated", {
+        exit_code: obj["exit_code"],
+        total: obj["total"],
+        truncated: obj["truncated"]
+      }),
+      lines.length > 0 ? lines.join("\n") : stringField(obj, "output")
+    ]);
+  }
+  return void 0;
 }
-
-// src/utils/merge-models-payload.ts
-function mergeModelsPayload(base, overlay) {
-  const out = {};
-  for (const [id, provider] of Object.entries(base)) {
-    out[id] = cloneProvider(provider);
+function renderTestOutput(obj, input) {
+  const exitCode = numberField(obj, "exit_code") ?? 0;
+  const failed = numberField(obj, "failed") ?? 0;
+  const output = stringField(obj, "output") ?? "";
+  const header = renderHeader(`test: ${stringField(obj, "runner") ?? "runner"}`, {
+    exit_code: obj["exit_code"],
+    tests_run: obj["tests_run"],
+    passed: obj["passed"],
+    failed: obj["failed"],
+    duration_ms: obj["duration_ms"],
+    truncated: obj["truncated"],
+    files: inputListSummary(input, "files"),
+    grep: stringFromInput(input, "grep")
+  });
+  if (exitCode === 0 && failed === 0) {
+    return joinSections([
+      header,
+      joinSections([
+        "report:",
+        `status=passed`,
+        `tests_run=${obj["tests_run"] ?? 0}`,
+        `passed=${obj["passed"] ?? 0}`,
+        `failed=${obj["failed"] ?? 0}`,
+        `duration_ms=${obj["duration_ms"] ?? 0}`,
+        extractSpoolNote(output)
+      ])
+    ]);
+  }
+  return joinSections([
+    header,
+    `error_context:
+${compactFailureOutput(output || "(no runner output)")}`
+  ]);
+}
+function renderVerifierOutput(toolName, obj, input) {
+  const exitCode = numberField(obj, "exit_code") ?? 0;
+  const errors = numberField(obj, "errors") ?? 0;
+  const warnings = numberField(obj, "warnings") ?? 0;
+  const output = stringField(obj, "output") ?? "";
+  const changed = numberField(obj, "files_changed") ?? 0;
+  const header = renderHeader(toolName, {
+    exit_code: obj["exit_code"],
+    errors: obj["errors"],
+    warnings: obj["warnings"],
+    files_checked: obj["files_checked"],
+    files_changed: obj["files_changed"],
+    fix_applied: obj["fix_applied"],
+    fixer: obj["fixer"],
+    linter: obj["linter"],
+    project: obj["project"],
+    truncated: obj["truncated"],
+    files: inputListSummary(input, "files"),
+    cwd: stringFromInput(input, "cwd")
+  });
+  if (exitCode === 0 && errors === 0 && (toolName !== "format" || changed === 0)) {
+    return joinSections([
+      header,
+      joinSections([
+        "report:",
+        "status=passed",
+        `errors=${errors}`,
+        `warnings=${warnings}`,
+        toolName === "format" ? `files_changed=${changed}` : void 0,
+        extractSpoolNote(output)
+      ])
+    ]);
+  }
+  if (exitCode === 0 && toolName === "format") {
+    return joinSections([
+      header,
+      joinSections([
+        "report:",
+        "status=changed",
+        `files_changed=${changed}`,
+        extractSpoolNote(output)
+      ])
+    ]);
+  }
+  return joinSections([
+    header,
+    `error_context:
+${compactFailureOutput(output || "(no verifier output)")}`
+  ]);
+}
+function renderGrepMatches(matches, mode) {
+  if (matches.length === 0) return "(no matches)";
+  if (mode === "files_with_matches") return renderStringList(matches, "(no files)");
+  if (mode === "count") return renderStringList(matches, "(no counts)");
+  const groups = /* @__PURE__ */ new Map();
+  const passthrough = [];
+  for (const match of matches) {
+    const parsed = parseGrepContentLine(match);
+    if (!parsed) {
+      passthrough.push(match);
+      continue;
+    }
+    const list = groups.get(parsed.file) ?? [];
+    list.push(`${parsed.line}:${parsed.text}`);
+    groups.set(parsed.file, list);
+  }
+  if (groups.size === 0) return renderStringList(matches, "(no matches)");
+  const sections = [];
+  let fileIndex = 0;
+  for (const [file, lines] of groups) {
+    fileIndex++;
+    if (fileIndex > GREP_FILE_LIMIT) break;
+    const shown = lines.slice(0, GREP_MATCHES_PER_FILE);
+    sections.push(
+      `${file} (${lines.length} match(es), showing ${shown.length})
+${shown.join("\n")}`
+    );
   }
-  for (const [id, ovProvider] of Object.entries(overlay)) {
-    const existing = out[id];
-    out[id] = existing ? mergeProvider(existing, ovProvider) : cloneProvider(ovProvider);
+  if (groups.size > GREP_FILE_LIMIT) {
+    sections.push(`[serializer omitted ${groups.size - GREP_FILE_LIMIT} file group(s)]`);
   }
-  return out;
-}
-function mergeProvider(base, overlay) {
-  const models = {};
-  for (const [mid, m] of Object.entries(base.models ?? {})) {
-    models[mid] = { ...m };
+  if (passthrough.length > 0) {
+    sections.push(`ungrouped:
+${renderStringList(passthrough, "", 50)}`);
   }
-  for (const [mid, ovModel] of Object.entries(overlay.models ?? {})) {
-    const existing = models[mid];
-    models[mid] = existing ? mergeModel(existing, ovModel) : { ...ovModel };
+  return sections.join("\n");
+}
+function parseGrepContentLine(line) {
+  const match = /^(.+?):(\d+):(.*)$/.exec(line);
+  if (!match?.[1] || !match[2]) return void 0;
+  return { file: match[1], line: match[2], text: match[3] ?? "" };
+}
+function compactDiff(diff) {
+  const lines = diff.split(/\r?\n/);
+  if (lines.length <= DIFF_INLINE_LINE_LIMIT) return diff;
+  const fileCount = Math.max(
+    new Set(
+      lines.map(
+        (line) => /^diff --git\s+a\/(.+?)\s+b\//.exec(line)?.[1] ?? /^---\s+(.+)/.exec(line)?.[1]
+      ).filter(Boolean)
+    ).size,
+    0
+  );
+  const hunks = lines.filter((line) => line.startsWith("@@")).length;
+  const added = lines.filter((line) => line.startsWith("+") && !line.startsWith("+++")).length;
+  const removed = lines.filter((line) => line.startsWith("-") && !line.startsWith("---")).length;
+  const selected = /* @__PURE__ */ new Set();
+  let hunkCount = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (line.startsWith("diff --git") || line.startsWith("--- ") || line.startsWith("+++ ")) {
+      selected.add(i);
+      continue;
+    }
+    if (!line.startsWith("@@")) continue;
+    if (hunkCount >= DIFF_HUNK_LIMIT) continue;
+    hunkCount++;
+    for (let j = i; j <= Math.min(lines.length - 1, i + DIFF_HUNK_CONTEXT); j++) {
+      selected.add(j);
+    }
   }
-  return {
-    ...base,
-    // Overlay scalar fields win when explicitly provided; otherwise keep base.
-    ...stripUndefined({
-      id: overlay.id,
-      name: overlay.name,
-      npm: overlay.npm,
-      api: overlay.api,
-      env: overlay.env,
-      doc: overlay.doc
+  if (selected.size === 0) {
+    return joinSections([
+      renderHeader("diff_summary", {
+        files: fileCount,
+        hunks,
+        added,
+        removed,
+        lines: lines.length
+      }),
+      lines.slice(0, DIFF_INLINE_LINE_LIMIT).join("\n"),
+      `[serializer omitted ${Math.max(0, lines.length - DIFF_INLINE_LINE_LIMIT)} diff line(s)]`
+    ]);
+  }
+  const excerpt = [];
+  let previous = -1;
+  for (const index of [...selected].sort((a, b) => a - b)) {
+    if (index > previous + 1) {
+      const omitted = previous === -1 ? index : index - previous - 1;
+      excerpt.push(`[serializer omitted ${omitted} diff line(s)]`);
+    }
+    excerpt.push(lines[index] ?? "");
+    previous = index;
+  }
+  const trailing = lines.length - previous - 1;
+  if (trailing > 0) excerpt.push(`[serializer omitted ${trailing} trailing diff line(s)]`);
+  return joinSections([
+    renderHeader("diff_summary", {
+      files: fileCount,
+      hunks,
+      shown_hunks: Math.min(hunks, DIFF_HUNK_LIMIT),
+      added,
+      removed,
+      lines: lines.length
     }),
-    models
-  };
+    excerpt.join("\n")
+  ]);
 }
-function mergeModel(base, overlay) {
-  const merged = { ...base, ...overlay };
-  if (base.limit || overlay.limit) {
-    merged.limit = { ...base.limit, ...overlay.limit };
+function compactFailureOutput(output) {
+  const lines = output.split(/\r?\n/);
+  if (lines.length <= 260) return output.trimEnd();
+  const selected = /* @__PURE__ */ new Set();
+  const marker = /\b(fail|failed|failure|error|exception|assertionerror|expected|received|actual|timeout|stack)\b/i;
+  let markerHits = 0;
+  for (let i = 0; i < lines.length; i++) {
+    if (!marker.test(lines[i] ?? "")) continue;
+    markerHits++;
+    for (let j = Math.max(0, i - 4); j <= Math.min(lines.length - 1, i + 10); j++) {
+      selected.add(j);
+    }
   }
-  if (base.cost || overlay.cost) {
-    merged.cost = { ...base.cost, ...overlay.cost };
+  if (markerHits === 0) {
+    return lines.slice(-220).join("\n").trimEnd();
   }
-  if (base.modalities || overlay.modalities) {
-    merged.modalities = { ...base.modalities, ...overlay.modalities };
+  const ordered = [...selected].sort((a, b) => a - b);
+  const out = [];
+  let previous = -1;
+  for (const index of ordered) {
+    if (index > previous + 1) {
+      const omitted = previous === -1 ? index : index - previous - 1;
+      out.push(`[serializer omitted ${omitted} line(s)]`);
+    }
+    out.push(lines[index] ?? "");
+    previous = index;
   }
-  return merged;
+  return out.join("\n").trimEnd();
 }
-function cloneProvider(p) {
-  const models = {};
-  for (const [mid, m] of Object.entries(p.models ?? {})) {
-    models[mid] = { ...m };
+function extractSpoolNote(output) {
+  return output.split(/\r?\n/).find((line) => line.startsWith("[output truncated") && line.includes("full"));
+}
+function hasCommandOutputShape(obj) {
+  return typeof obj["stdout"] === "string" || typeof obj["stderr"] === "string" || typeof obj["output"] === "string" || typeof obj["exitCode"] === "number" || typeof obj["exit_code"] === "number";
+}
+function renderCommandOutput(toolName, obj, input) {
+  const command = stringField(obj, "command") ?? stringFromInput(input, "command");
+  const args = stringArrayField(obj, "args");
+  const commandLine = command ? [command, ...args].join(" ") : void 0;
+  const output = stringField(obj, "output");
+  const stdout = stringField(obj, "stdout");
+  const stderr = stringField(obj, "stderr");
+  return joinSections([
+    renderHeader(commandLine ? `${toolName}: ${commandLine}` : toolName, {
+      exit_code: obj["exit_code"] ?? obj["exitCode"],
+      timed_out: obj["timed_out"],
+      pid: obj["pid"],
+      allowed: obj["allowed"],
+      truncated: obj["truncated"],
+      runner: obj["runner"],
+      linter: obj["linter"],
+      fixer: obj["fixer"],
+      project: obj["project"],
+      tests_run: obj["tests_run"],
+      passed: obj["passed"],
+      failed: obj["failed"],
+      duration_ms: obj["duration_ms"],
+      errors: obj["errors"],
+      warnings: obj["warnings"],
+      files_checked: obj["files_checked"],
+      files_changed: obj["files_changed"],
+      fix_applied: obj["fix_applied"]
+    }),
+    stringField(obj, "error") ? `error:
+${stringField(obj, "error")}` : void 0,
+    output ? `output:
+${output}` : void 0,
+    stdout ? `stdout:
+${stdout}` : void 0,
+    stderr ? `stderr:
+${stderr}` : void 0
+  ]);
+}
+function renderGenericToolObject(toolName, obj) {
+  const scalars = {};
+  const blocks = [];
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === void 0) continue;
+    if (isScalar(value)) {
+      const inline = String(value);
+      if (inline.length <= INLINE_LIMIT && !inline.includes("\n")) {
+        scalars[key] = value;
+      } else {
+        blocks.push(`${key}:
+${inline}`);
+      }
+      continue;
+    }
+    if (Array.isArray(value)) {
+      if (value.every((item) => typeof item === "string")) {
+        blocks.push(`${key}:
+${renderStringList(value)}`);
+      } else {
+        blocks.push(`${key}:
+${renderUnknownList(value)}`);
+      }
+      continue;
+    }
+    blocks.push(`${key}: ${clipInline(oneLineJson(value))}`);
   }
-  return { ...p, models };
+  return joinSections([renderHeader(toolName, scalars), ...blocks]);
 }
-function stripUndefined(obj) {
-  const out = {};
-  for (const [k, v] of Object.entries(obj)) {
-    if (v !== void 0) out[k] = v;
+function renderHeader(label, fields) {
+  const parts = Object.entries(fields).filter(([, value]) => value !== void 0 && value !== null && value !== "").map(([key, value]) => `${key}=${clipInline(formatInlineValue(value))}`);
+  return parts.length > 0 ? `${label} (${parts.join(" ")})` : label;
+}
+function renderStringList(items, empty = "", limit = DEFAULT_LIST_LIMIT) {
+  if (items.length === 0) return empty;
+  const shown = items.slice(0, limit);
+  const omitted = items.length - shown.length;
+  return [
+    ...shown,
+    ...omitted > 0 ? [`[serializer omitted ${omitted} item(s); narrow the request for more]`] : []
+  ].join("\n");
+}
+function renderUnknownList(items, limit = DEFAULT_LIST_LIMIT) {
+  const shown = items.slice(0, limit).map((item) => clipInline(oneLineJson(item), 1e3));
+  const omitted = items.length - shown.length;
+  if (omitted > 0)
+    shown.push(`[serializer omitted ${omitted} item(s); narrow the request for more]`);
+  return shown.join("\n");
+}
+function joinSections(sections) {
+  return sections.map((section) => typeof section === "string" ? section.trimEnd() : void 0).filter((section) => !!section).join("\n");
+}
+function formatInlineValue(value) {
+  if (Array.isArray(value)) return `[${value.map(formatInlineValue).join(",")}]`;
+  if (isScalar(value)) return String(value);
+  return oneLineJson(value);
+}
+function clipInline(value, max = INLINE_LIMIT) {
+  const compact = value.replace(/\s+/g, " ").trim();
+  return compact.length <= max ? compact : `${compact.slice(0, max - 15)}...(${compact.length} chars)`;
+}
+function oneLineJson(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
   }
-  return out;
+}
+function stringField(obj, key) {
+  const value = obj[key];
+  return typeof value === "string" ? value : void 0;
+}
+function numberField(obj, key) {
+  const value = obj[key];
+  return typeof value === "number" ? value : void 0;
+}
+function stringArrayField(obj, key) {
+  const value = obj[key];
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function stringFromInput(input, key) {
+  if (!isRecord2(input)) return void 0;
+  const value = input[key];
+  return typeof value === "string" ? value : void 0;
+}
+function numberFromInput(input, key) {
+  if (!isRecord2(input)) return void 0;
+  const value = input[key];
+  return typeof value === "number" ? value : void 0;
+}
+function inputListSummary(input, key) {
+  if (!isRecord2(input)) return void 0;
+  const value = input[key];
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) return value.filter((item) => typeof item === "string").join(",");
+  return void 0;
+}
+function isRecord2(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isScalar(value) {
+  return value === null || ["string", "number", "boolean"].includes(typeof value);
+}
+function wstackGlobalRoot() {
+  const fromEnv = process.env["WRONGSTACK_HOME"];
+  if (fromEnv && fromEnv.trim().length > 0) return path6.resolve(fromEnv);
+  return path6.join(os.homedir(), ".wrongstack");
 }
 
 // src/types/errors.ts
@@ -998,6 +1738,20 @@ function providerStatusToCode(status, type) {
   return ERROR_CODES.PROVIDER_INVALID_REQUEST;
 }
 
+// src/types/config.ts
+function normalizeTokenSavingTier(val) {
+  if (val === void 0) return "off";
+  if (typeof val === "boolean") return val ? "medium" : "off";
+  const validTiers = /* @__PURE__ */ new Set([
+    "off",
+    "minimal",
+    "light",
+    "medium",
+    "aggressive"
+  ]);
+  return validTiers.has(val) ? val : "off";
+}
+
 // src/types/default-config.ts
 var DEFAULT_TOOLS_CONFIG = Object.freeze({
   defaultExecutionStrategy: "smart",
@@ -1005,7 +1759,8 @@ var DEFAULT_TOOLS_CONFIG = Object.freeze({
   iterationTimeoutMs: 3e5,
   sessionTimeoutMs: 18e5,
   perIterationOutputCapBytes: 1e5,
-  autoExtendLimit: true
+  autoExtendLimit: true,
+  restrictToProjectRoot: false
 });
 var DEFAULT_CONTEXT_CONFIG = Object.freeze({
   preserveK: 10,
@@ -1014,6 +1769,10 @@ var DEFAULT_CONTEXT_CONFIG = Object.freeze({
 var DEFAULT_AUTONOMY_CONFIG = Object.freeze({
   autoProceedDelayMs: 45e3
 });
+var DEFAULT_CIRCUIT_BREAKER_CONFIG = Object.freeze({
+  enabled: false,
+  autoKillResetMs: 6e4
+});
 var DEFAULT_SESSION_LOGGING_CONFIG = Object.freeze({
   auditLevel: "standard",
   sampling: {
@@ -1025,7 +1784,10 @@ var DEFAULT_SESSION_LOGGING_CONFIG = Object.freeze({
 var DEFAULT_SESSION_PRUNE_DAYS = 30;
 
 // src/types/secret-vault.ts
-var ENCRYPTED_PREFIX = "enc:v1:";
+var ENCRYPTED_PREFIX_PATTERN = /^enc:v(\d+):/;
+function encryptedPrefixForVersion(version) {
+  return `enc:v${version}:`;
+}
 
 // src/security/secret-vault.ts
 var KEY_BYTES = 32;
@@ -1033,6 +1795,8 @@ var IV_BYTES = 12;
 var TAG_BYTES = 16;
 var ALGO = "aes-256-gcm";
 var KEY_FILE_MODE = 384;
+var KEY_FILE_MAGIC = Buffer.from("WSKV", "ascii");
+var VERSIONED_KEY_FILE_SIZE = KEY_FILE_MAGIC.length + 1 + KEY_BYTES;
 function checkKeyFilePermissions(keyFile) {
   if (process.platform === "win32") return;
   try {
@@ -1055,11 +1819,17 @@ function checkKeyFilePermissions(keyFile) {
 var DefaultSecretVault = class {
   keyFile;
   key;
+  _keyVersion = 1;
   constructor(opts) {
     this.keyFile = opts.keyFile;
   }
+  /** Current key version. Starts at 1; incremented by rotateKey(). */
+  get keyVersion() {
+    if (!this.key) this.loadOrCreateKey();
+    return this._keyVersion;
+  }
   isEncrypted(value) {
-    return typeof value === "string" && value.startsWith(ENCRYPTED_PREFIX);
+    return typeof value === "string" && ENCRYPTED_PREFIX_PATTERN.test(value);
   }
   encrypt(plaintext) {
     if (this.isEncrypted(plaintext)) return plaintext;
@@ -1068,11 +1838,20 @@ var DefaultSecretVault = class {
     const cipher = createCipheriv(ALGO, key, iv);
     const ct = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
     const tag = cipher.getAuthTag();
-    return `${ENCRYPTED_PREFIX}${iv.toString("base64")}:${tag.toString("base64")}:${ct.toString("base64")}`;
+    const prefix = encryptedPrefixForVersion(this._keyVersion);
+    return `${prefix}${iv.toString("base64")}:${tag.toString("base64")}:${ct.toString("base64")}`;
   }
   decrypt(value) {
     if (!this.isEncrypted(value)) return value;
-    const rest = value.slice(ENCRYPTED_PREFIX.length);
+    const prefixMatch = value.match(ENCRYPTED_PREFIX_PATTERN);
+    if (!prefixMatch) {
+      throw new ConfigError({
+        message: "SecretVault: malformed encrypted value",
+        code: ERROR_CODES.CONFIG_PARSE_FAILED,
+        context: { field: "encrypted_value" }
+      });
+    }
+    const rest = value.slice(prefixMatch[0].length);
     const parts = rest.split(":");
     if (parts.length !== 3) {
       throw new ConfigError({
@@ -1101,42 +1880,104 @@ var DefaultSecretVault = class {
     const pt = Buffer.concat([decipher.update(ct), decipher.final()]);
     return pt.toString("utf8");
   }
+  /**
+   * Generate a new encryption key, write it to disk, and increment the key version.
+   * After rotation, encrypt() emits the new version prefix (e.g. enc:v2:).
+   * The caller must re-encrypt existing config values (see rotateConfigKeys()).
+   */
+  rotateKey() {
+    const oldVersion = this._keyVersion;
+    const newKey = randomBytes(KEY_BYTES);
+    const newVersion = oldVersion + 1;
+    const keyFileBuf = Buffer.alloc(VERSIONED_KEY_FILE_SIZE);
+    KEY_FILE_MAGIC.copy(keyFileBuf, 0);
+    keyFileBuf[KEY_FILE_MAGIC.length] = newVersion;
+    newKey.copy(keyFileBuf, KEY_FILE_MAGIC.length + 1);
+    fs2.mkdirSync(path6.dirname(this.keyFile), { recursive: true });
+    fs2.writeFileSync(this.keyFile, keyFileBuf, { mode: 384 });
+    checkKeyFilePermissions(this.keyFile);
+    this.key = newKey;
+    this._keyVersion = newVersion;
+    return { oldVersion, newVersion };
+  }
   loadOrCreateKey() {
     if (this.key) return this.key;
     try {
       const buf = fs2.readFileSync(this.keyFile);
-      if (buf.length !== KEY_BYTES) {
-        throw new ConfigError({
-          message: `SecretVault: key file ${this.keyFile} is ${buf.length} bytes (expected ${KEY_BYTES}). Remove it manually to generate a new key.`,
-          code: ERROR_CODES.CONFIG_INVALID,
-          context: { keyFile: this.keyFile, expectedBytes: KEY_BYTES, actualBytes: buf.length }
-        });
+      if (buf.length === KEY_BYTES) {
+        this.key = buf;
+        this._keyVersion = 1;
+        checkKeyFilePermissions(this.keyFile);
+        return this.key;
+      }
+      if (buf.length === VERSIONED_KEY_FILE_SIZE) {
+        const magic = buf.subarray(0, KEY_FILE_MAGIC.length);
+        if (!magic.equals(KEY_FILE_MAGIC)) {
+          throw new ConfigError({
+            message: `SecretVault: key file ${this.keyFile} has invalid magic header`,
+            code: ERROR_CODES.CONFIG_INVALID,
+            context: { keyFile: this.keyFile }
+          });
+        }
+        const version = buf[KEY_FILE_MAGIC.length];
+        const key2 = buf.subarray(KEY_FILE_MAGIC.length + 1);
+        if (key2.length !== KEY_BYTES) {
+          throw new ConfigError({
+            message: `SecretVault: key file ${this.keyFile} has wrong key size (${key2.length} bytes, expected ${KEY_BYTES})`,
+            code: ERROR_CODES.CONFIG_INVALID,
+            context: { keyFile: this.keyFile, expectedBytes: KEY_BYTES, actualBytes: key2.length }
+          });
+        }
+        this.key = Buffer.from(key2);
+        this._keyVersion = version;
+        checkKeyFilePermissions(this.keyFile);
+        return this.key;
       }
-      this.key = buf;
-      checkKeyFilePermissions(this.keyFile);
-      return this.key;
+      throw new ConfigError({
+        message: `SecretVault: key file ${this.keyFile} is ${buf.length} bytes (expected ${KEY_BYTES} for v1 or ${VERSIONED_KEY_FILE_SIZE} for v2+). Remove it manually to generate a new key.`,
+        code: ERROR_CODES.CONFIG_INVALID,
+        context: { keyFile: this.keyFile, expectedBytes: KEY_BYTES, actualBytes: buf.length }
+      });
     } catch (err) {
       if (err.code !== "ENOENT") throw err;
     }
-    fs2.mkdirSync(path4.dirname(this.keyFile), { recursive: true });
+    fs2.mkdirSync(path6.dirname(this.keyFile), { recursive: true });
     const key = randomBytes(KEY_BYTES);
     try {
       fs2.writeFileSync(this.keyFile, key, { mode: 384, flag: "wx" });
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
       const buf = fs2.readFileSync(this.keyFile);
-      if (buf.length !== KEY_BYTES) {
-        throw new ConfigError({
-          message: `SecretVault: key file ${this.keyFile} is ${buf.length} bytes (expected ${KEY_BYTES}). Remove it manually to generate a new key.`,
-          code: ERROR_CODES.CONFIG_INVALID,
-          context: { keyFile: this.keyFile, expectedBytes: KEY_BYTES, actualBytes: buf.length }
-        });
+      if (buf.length === KEY_BYTES) {
+        this.key = buf;
+        this._keyVersion = 1;
+        checkKeyFilePermissions(this.keyFile);
+        return this.key;
+      }
+      if (buf.length === VERSIONED_KEY_FILE_SIZE) {
+        const magic = buf.subarray(0, KEY_FILE_MAGIC.length);
+        if (!magic.equals(KEY_FILE_MAGIC)) {
+          throw new ConfigError({
+            message: `SecretVault: key file ${this.keyFile} has invalid magic header`,
+            code: ERROR_CODES.CONFIG_INVALID,
+            context: { keyFile: this.keyFile }
+          });
+        }
+        const version = buf[KEY_FILE_MAGIC.length];
+        const winnerKey = buf.subarray(KEY_FILE_MAGIC.length + 1);
+        this.key = Buffer.from(winnerKey);
+        this._keyVersion = version;
+        checkKeyFilePermissions(this.keyFile);
+        return this.key;
       }
-      this.key = buf;
-      checkKeyFilePermissions(this.keyFile);
-      return this.key;
+      throw new ConfigError({
+        message: `SecretVault: key file ${this.keyFile} is ${buf.length} bytes (expected ${KEY_BYTES} for v1 or ${VERSIONED_KEY_FILE_SIZE} for v2+). Remove it manually to generate a new key.`,
+        code: ERROR_CODES.CONFIG_INVALID,
+        context: { keyFile: this.keyFile, expectedBytes: KEY_BYTES, actualBytes: buf.length }
+      });
     }
     this.key = key;
+    this._keyVersion = 1;
     return key;
   }
 };
@@ -1190,7 +2031,7 @@ async function rewriteConfigEncrypted(configPath, vault, patch) {
   }
   const merged = deepMerge(current, patch ?? {});
   const encrypted = encryptConfigSecrets(merged, vault);
-  await fs.mkdir(path4.dirname(configPath), { recursive: true });
+  await fs.mkdir(path6.dirname(configPath), { recursive: true });
   await atomicWrite(configPath, JSON.stringify(encrypted, null, 2), { mode: 384 });
   await restrictFilePermissions(configPath);
 }
@@ -1217,6 +2058,89 @@ async function migratePlaintextSecrets(configPath, vault, logger) {
   );
   return { migrated: counter.n, file: configPath };
 }
+async function rotateConfigKeys(configPath, vault, logger) {
+  const log = logger?.info ?? (() => {
+  });
+  const warn = logger?.warn ?? ((msg) => console.warn(msg));
+  let raw;
+  try {
+    raw = await fs.readFile(configPath, "utf8");
+  } catch {
+    const { oldVersion: oldVersion2, newVersion: newVersion2 } = vault.rotateKey();
+    log(`[secret-vault] Key rotated (v${oldVersion2} \u2192 v${newVersion2}) \u2014 no config file to re-encrypt`);
+    return { rotated: 0, oldVersion: oldVersion2, newVersion: newVersion2, file: configPath };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    warn(`[secret-vault] Config file ${configPath} is not valid JSON \u2014 skipping rotation`);
+    return { rotated: 0, oldVersion: vault.keyVersion, newVersion: vault.keyVersion, file: configPath };
+  }
+  const counter = { n: 0, failed: [] };
+  const decrypted = walkDecryptCount(parsed, vault, counter);
+  if (counter.failed.length > 0) {
+    throw new Error(
+      `[secret-vault] Aborting key rotation: ${counter.failed.length} field(s) could not be decrypted with the current key and would be permanently lost on rotation: ${counter.failed.join(", ")}. Restore or remove these fields before rotating.`
+    );
+  }
+  if (counter.n === 0) {
+    const { oldVersion: oldVersion2, newVersion: newVersion2 } = vault.rotateKey();
+    log(`[secret-vault] Key rotated (v${oldVersion2} \u2192 v${newVersion2}) \u2014 no encrypted fields to re-encrypt`);
+    return { rotated: 0, oldVersion: oldVersion2, newVersion: newVersion2, file: configPath };
+  }
+  const { oldVersion, newVersion } = vault.rotateKey();
+  const reencrypted = walkReencrypt(decrypted, vault);
+  await atomicWrite(configPath, JSON.stringify(reencrypted, null, 2), { mode: 384 });
+  await restrictFilePermissions(configPath, { warn });
+  log(`[secret-vault] Key rotated (v${oldVersion} \u2192 v${newVersion}) \u2014 re-encrypted ${counter.n} field(s)`);
+  return { rotated: counter.n, oldVersion, newVersion, file: configPath };
+}
+function walkDecryptCount(node, vault, counter, pathPrefix = "") {
+  if (node === null || node === void 0) return node;
+  if (typeof node !== "object") return node;
+  if (Array.isArray(node)) {
+    return node.map(
+      (item, i) => walkDecryptCount(item, vault, counter, `${pathPrefix}[${i}]`)
+    );
+  }
+  const out = /* @__PURE__ */ Object.create(null);
+  for (const [k, v] of Object.entries(node)) {
+    const keyPath = pathPrefix ? `${pathPrefix}.${k}` : k;
+    if (typeof v === "string" && vault.isEncrypted(v)) {
+      try {
+        out[k] = vault.decrypt(v);
+        counter.n++;
+      } catch {
+        counter.failed.push(keyPath);
+        out[k] = v;
+      }
+    } else if (typeof v === "object" && v !== null) {
+      out[k] = walkDecryptCount(v, vault, counter, keyPath);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+function walkReencrypt(node, vault) {
+  if (node === null || node === void 0) return node;
+  if (typeof node !== "object") return node;
+  if (Array.isArray(node)) {
+    return node.map((item) => walkReencrypt(item, vault));
+  }
+  const out = /* @__PURE__ */ Object.create(null);
+  for (const [k, v] of Object.entries(node)) {
+    if (typeof v === "string" && isSecretField(k) && v.length > 0 && !vault.isEncrypted(v)) {
+      out[k] = vault.encrypt(v);
+    } else if (typeof v === "object" && v !== null) {
+      out[k] = walkReencrypt(v, vault);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
 async function restrictFilePermissions(filePath, opts) {
   const warn = opts?.warn ?? ((msg) => console.warn(msg));
   if (process.platform === "win32") {
@@ -1305,7 +2229,7 @@ var DefaultLogger = class _DefaultLogger {
     this.maxFileBytes = opts.maxFileBytes ?? 10 * 1024 * 1024;
     if (this.file) {
       try {
-        fs2.mkdirSync(path4.dirname(this.file), { recursive: true });
+        fs2.mkdirSync(path6.dirname(this.file), { recursive: true });
       } catch {
       }
     }
@@ -1567,7 +2491,11 @@ var MEMORY_TYPE_LABELS = {
 };
 
 // src/execution/compaction-core.ts
+function compactionDebugEnabled() {
+  return process.env["NODE_ENV"] === "development" || process.env["WRONGSTACK_DEBUG"] === "1";
+}
 function emitCompactionMetrics(event, metrics) {
+  if (!compactionDebugEnabled()) return;
   console.log(
     JSON.stringify({
       level: "debug",
@@ -1602,38 +2530,41 @@ function findPreserveStart(messages, preserveK) {
       preserveStart = i;
     }
   }
-  let forwardWalkIterations = 0;
-  let forwardWalkInnerIterations = 0;
-  for (let i = preserveStart; i < messages.length; i++) {
-    forwardWalkIterations++;
-    const m = messages[i];
-    if (!m || typeof m.content === "string" || !Array.isArray(m.content)) continue;
-    const hasToolUse3 = m.content.some((b) => {
-      forwardWalkInnerIterations++;
-      return b.type === "tool_use";
-    });
-    if (hasToolUse3 && i + 1 < messages.length) {
-      const next = messages[i + 1];
-      if (next && next.role === "user" && typeof next.content !== "string" && Array.isArray(next.content) && next.content.some((b) => {
-        forwardWalkInnerIterations++;
-        return b.type === "tool_result";
-      })) {
-        preserveStart = i + 1;
-      }
+  let pairRepairIterations = 0;
+  let pairRepairInnerIterations = 0;
+  while (preserveStart > 0) {
+    pairRepairIterations++;
+    const first = messages[preserveStart];
+    const prev = messages[preserveStart - 1];
+    if (!first || !prev || first.role !== "user" || prev.role !== "assistant") break;
+    if (typeof first.content === "string" || typeof prev.content === "string") break;
+    const resultIds = /* @__PURE__ */ new Set();
+    for (const block of first.content) {
+      pairRepairInnerIterations++;
+      if (block.type === "tool_result") resultIds.add(block.tool_use_id);
     }
+    if (resultIds.size === 0) break;
+    const hasMatchingUse = prev.content.some((block) => {
+      pairRepairInnerIterations++;
+      return block.type === "tool_use" && resultIds.has(block.id);
+    });
+    if (!hasMatchingUse) break;
+    preserveStart--;
+  }
+  if (compactionDebugEnabled()) {
+    console.log(
+      JSON.stringify({
+        level: "debug",
+        event: "compaction.find_preserve_start.ended",
+        messageCount: messages.length,
+        preserveK,
+        preserveStart,
+        pairRepairIterations,
+        pairRepairInnerIterations,
+        pairRepairInnerPerOuter: pairRepairIterations > 0 ? pairRepairInnerIterations / pairRepairIterations : 0
+      })
+    );
   }
-  console.log(
-    JSON.stringify({
-      level: "debug",
-      event: "compaction.find_preserve_start.ended",
-      messageCount: messages.length,
-      preserveK,
-      preserveStart,
-      forwardWalkIterations,
-      forwardWalkInnerIterations,
-      forwardWalkInnerPerOuter: forwardWalkIterations > 0 ? forwardWalkInnerIterations / forwardWalkIterations : 0
-    })
-  );
   return preserveStart;
 }
 function eliseOldToolResults(messages, opts) {
@@ -1647,7 +2578,8 @@ function eliseOldToolResults(messages, opts) {
     if (!msg || !Array.isArray(msg.content)) continue;
     for (const b of msg.content) {
       fastPathInnerIterations++;
-      if (b.type === "tool_result" && estimateToolResultTokens(b.content) >= opts.eliseThreshold) {
+      const oversized = b.type === "tool_result" && estimateToolResultTokens(b.content) >= opts.eliseThreshold || b.type === "tool_use" && estimateToolInputTokens(b.input) >= opts.eliseThreshold;
+      if (oversized) {
         hasOversized = true;
         break;
       }
@@ -1681,6 +2613,13 @@ function eliseOldToolResults(messages, opts) {
     }
     const original = msg.content;
     const newContent = original.map((b) => {
+      if (b.type === "tool_use") {
+        const tokens2 = estimateToolInputTokens(b.input);
+        if (tokens2 < opts.eliseThreshold) return b;
+        const elidedInput = summarizeToolUseInputElision(b, tokens2);
+        saved += Math.max(0, tokens2 - estimateToolInputTokens(elidedInput));
+        return { ...b, input: elidedInput };
+      }
       if (b.type !== "tool_result") return b;
       const tokens = estimateToolResultTokens(b.content);
       if (tokens < opts.eliseThreshold) return b;
@@ -1688,7 +2627,7 @@ function eliseOldToolResults(messages, opts) {
       const elided = {
         type: "tool_result",
         tool_use_id: b.tool_use_id,
-        content: `[elided: ~${tokens} tokens]`,
+        content: summarizeToolResultElision(b, tokens),
         is_error: b.is_error
       };
       return elided;
@@ -1700,7 +2639,7 @@ function eliseOldToolResults(messages, opts) {
       changed = true;
     }
     fullPassInnerIterations += original.length;
-    if (process.env["NODE_ENV"] === "development" || process.env["WRONGSTACK_DEBUG"] === "1") {
+    if (compactionDebugEnabled()) {
       const ratio = fullPassInnerIterations / fullPassIterations;
       if (ratio > 10) {
         console.error(
@@ -1728,6 +2667,65 @@ function eliseOldToolResults(messages, opts) {
   });
   return { messages: changed ? next : messages, saved, changed };
 }
+function summarizeToolUseInputElision(block, tokens) {
+  const fields = {};
+  for (const [key, value] of Object.entries(block.input ?? {})) {
+    fields[key] = summarizeToolUseInputValue(value);
+  }
+  return {
+    __elided_tool_input: `~${tokens} tokens; original arguments are in the session log`,
+    tool: block.name,
+    fields
+  };
+}
+function summarizeToolUseInputValue(value) {
+  if (value === null || value === void 0) return value;
+  if (typeof value === "number" || typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    const oneLine = value.replace(/\s+/g, " ").trim();
+    return oneLine.length <= 160 ? oneLine : `${oneLine.slice(0, 120)}...(${oneLine.length} chars)`;
+  }
+  if (Array.isArray(value)) {
+    return `[array:${value.length}]`;
+  }
+  if (typeof value === "object") {
+    const keys = Object.keys(value);
+    return `[object:${keys.slice(0, 8).join(",")}${keys.length > 8 ? ",..." : ""}]`;
+  }
+  return String(value);
+}
+function summarizeToolResultElision(block, tokens) {
+  const parts = [`elided: ~${tokens} tokens`];
+  if (block.name) parts.push(`tool=${block.name}`);
+  const files = extractPathHints(block.content).slice(0, 5);
+  if (files.length > 0) parts.push(`files=${files.join(", ")}`);
+  const error = firstErrorLine(block.content);
+  if (error) parts.push(`error=${error}`);
+  return `[${parts.join("; ")}]`;
+}
+function extractPathHints(content) {
+  const text = typeof content === "string" ? content : JSON.stringify(content);
+  const out = /* @__PURE__ */ new Set();
+  const re = /(?:(?:[A-Za-z]:)?[./\\]?[\w@.-]+(?:[\\/][\w@(). -]+)+\.[A-Za-z0-9]{1,12})/g;
+  for (const match of text.matchAll(re)) {
+    const clean = match[0]?.replace(/\\/g, "/").replace(/^["'`]+|["'`),;:]+$/g, "");
+    if (clean && clean.length <= 220) out.add(clean);
+    if (out.size >= 5) break;
+  }
+  return [...out];
+}
+function firstErrorLine(content) {
+  const text = typeof content === "string" ? content : JSON.stringify(content);
+  for (const line of text.split(/\r?\n/)) {
+    if (!/\b(error|exception|failed|failure|fatal|panic|timeout|denied|enoent|eacces|eperm)\b/i.test(
+      line
+    ))
+      continue;
+    const trimmed = line.replace(/\s+/g, " ").trim();
+    if (trimmed) return trimmed.slice(0, 180);
+  }
+  return void 0;
+}
 function buildLosslessDigest(messages) {
   const lines = [];
   for (const m of messages) {
@@ -1838,15 +2836,15 @@ function buildSmartDigest(messages) {
     lines.push(`[${m.role}]: ${display}${marker}`);
   }
   if (noiseCount > 0) {
-    lines.push(`[system]: ${noiseCount} low-importance turn(s) collapsed (repeated failures / pure tool I/O)`);
+    lines.push(
+      `[system]: ${noiseCount} low-importance turn(s) collapsed (repeated failures / pure tool I/O)`
+    );
   }
   return lines.join("\n");
 }
 function countToolBlocks(m) {
   if (typeof m.content === "string") return 0;
-  return m.content.filter(
-    (b) => b.type === "tool_use" || b.type === "tool_result"
-  ).length;
+  return m.content.filter((b) => b.type === "tool_use" || b.type === "tool_result").length;
 }
 function firstSentence(text) {
   const trimmed = text.trim();
@@ -1892,10 +2890,12 @@ var HybridCompactor = class {
     if (elide.changed) ctx.state.replaceMessages(elide.messages);
     if (elide.saved > 0) reductions.push({ phase: "elision", saved: elide.saved });
     let collapsedDigest;
+    let evidenceDigest;
     if (opts.aggressive) {
       const phase2 = this.collapseAncientTurns(ctx, preserveK);
       if (phase2.saved > 0) reductions.push({ phase: "summary", saved: phase2.saved });
       collapsedDigest = phase2.digest;
+      evidenceDigest = phase2.evidenceDigest;
     }
     const repaired = repairToolUseAdjacency(ctx.messages);
     if (repaired.report.changed) {
@@ -1903,6 +2903,11 @@ var HybridCompactor = class {
     }
     const afterTokens = estimateMessages(ctx.messages);
     const afterFull = this.estimateFullRequest(ctx);
+    const quality = checkCompactionQuality(ctx, {
+      collapsedDigest,
+      evidenceDigest,
+      reduced: beforeTokens > afterTokens || beforeFull > afterFull
+    });
     return {
       before: beforeTokens,
       after: afterTokens,
@@ -1910,6 +2915,8 @@ var HybridCompactor = class {
       fullRequestTokensAfter: afterFull,
       reductions,
       collapsedDigest,
+      evidenceDigest,
+      quality,
       repaired: repaired.report.changed ? {
         removedToolUses: repaired.report.removedToolUses,
         removedToolResults: repaired.report.removedToolResults,
@@ -1951,7 +2958,13 @@ var HybridCompactor = class {
     if (boundary <= 0) return { saved: 0 };
     const removed = messages.slice(0, boundary);
     const removedTokens = estimateMessages(removed);
-    const digest = this.smart ? buildSmartDigest(removed) || `${removed.length} earlier turns (no textual content; tool I/O omitted \u2014 see session log)` : buildLosslessDigest(removed) || `${removed.length} earlier turns (no textual content; tool I/O omitted \u2014 see session log)`;
+    const historyDigest = this.smart ? buildSmartDigest(removed) || `${removed.length} earlier turns (no textual content; tool I/O omitted; see session log)` : buildLosslessDigest(removed) || `${removed.length} earlier turns (no textual content; tool I/O omitted; see session log)`;
+    const evidenceDigest = buildContextEvidenceDigest(ctx);
+    const digest = evidenceDigest ? `[context_state]
+${evidenceDigest}
+
+[prior_history]
+${historyDigest}` : historyDigest;
     const summaryMsg = {
       role: "system",
       content: `[prior_turns_digest: ${digest}]`
@@ -1960,10 +2973,29 @@ var HybridCompactor = class {
     ctx.state.replaceMessages([summaryMsg, ...tail]);
     return {
       saved: Math.max(0, removedTokens - estimateMessages([summaryMsg])),
-      digest
+      digest,
+      evidenceDigest: evidenceDigest || void 0
     };
   }
 };
+function checkCompactionQuality(ctx, opts) {
+  const evidence = ctx.contextEvidence;
+  const digest = `${opts.collapsedDigest ?? ""}
+${opts.evidenceDigest ?? ""}`;
+  const hasIntent = Boolean(evidence?.currentIntent?.text || /\b(intent|goal|session_goals)\b/i.test(digest));
+  const hasPathTrail = Boolean(
+    Object.keys(evidence?.fileGraph ?? {}).length > 0 || (evidence?.toolCalls.length ?? 0) > 0 || /\b(dependency_graph|tool_trail|files=)\b/i.test(digest)
+  );
+  const issues = [];
+  if (opts.reduced && !hasIntent) issues.push("missing intent anchor");
+  if (opts.reduced && !hasPathTrail) issues.push("missing tool/path trail");
+  return {
+    ok: issues.length === 0,
+    hasIntent,
+    hasPathTrail,
+    issues
+  };
+}
 function readContextWindowPolicy(ctx) {
   const policy = ctx.meta?.["contextWindowPolicy"];
   if (!policy || typeof policy !== "object") return null;
@@ -1990,52 +3022,52 @@ var DefaultPathResolver = class {
   projectRoot;
   cwd;
   constructor(cwd = process.cwd()) {
-    this.cwd = path4.resolve(cwd);
+    this.cwd = path6.resolve(cwd);
     this.projectRoot = this.detectProjectRoot(this.cwd);
   }
   detectProjectRoot(start) {
-    let dir = path4.resolve(start);
-    const root = path4.parse(dir).root;
-    const home = path4.resolve(os.homedir());
-    const startPath = path4.resolve(start);
+    let dir = path6.resolve(start);
+    const root = path6.parse(dir).root;
+    const home = path6.resolve(os.homedir());
+    const startPath = path6.resolve(start);
     while (dir !== root) {
       if (dir === home && dir !== startPath) {
         break;
       }
       for (const marker of PROJECT_MARKERS) {
         try {
-          fs2.accessSync(path4.join(dir, marker));
+          fs2.accessSync(path6.join(dir, marker));
           return dir;
         } catch {
         }
       }
-      const parent = path4.dirname(dir);
+      const parent = path6.dirname(dir);
       if (parent === dir) break;
       dir = parent;
     }
     return startPath;
   }
   resolve(input) {
-    const abs = path4.isAbsolute(input) ? input : path4.resolve(this.cwd, input);
+    const abs = path6.isAbsolute(input) ? input : path6.resolve(this.cwd, input);
     let real;
     try {
       real = fs2.realpathSync(abs);
     } catch {
-      real = path4.normalize(abs);
+      real = path6.normalize(abs);
     }
     return real;
   }
   isInsideRoot(absPath) {
-    const normalized = path4.normalize(absPath);
-    const root = path4.normalize(this.projectRoot);
+    const normalized = path6.normalize(absPath);
+    const root = path6.normalize(this.projectRoot);
     if (normalized === root) return true;
-    const rel = path4.relative(root, normalized);
-    return !rel.startsWith("..") && !path4.isAbsolute(rel);
+    const rel = path6.relative(root, normalized);
+    return !rel.startsWith("..") && !path6.isAbsolute(rel);
   }
   ensureInsideRoot(absPath) {
     const resolved = this.resolve(absPath);
     if (!this.isInsideRoot(resolved)) {
-      const display = path4.isAbsolute(absPath) ? path4.basename(absPath) : absPath;
+      const display = path6.isAbsolute(absPath) ? path6.basename(absPath) : absPath;
       const err = new Error(`Path "${display}" resolves outside the project root`);
       err.fullPath = absPath;
       err.projectRoot = this.projectRoot;
@@ -2234,6 +3266,27 @@ var PATTERNS = [
   { type: "postgres_uri", regex: /postgres(?:ql)?:\/\/[^\s"'`]+/g },
   { type: "mysql_uri", regex: /mysql:\/\/[^\s"'`]+/g },
   { type: "redis_uri", regex: /redis:\/\/[^\s"'`]+/g },
+  // AI/ML provider keys — modern LLM services with well-known prefixes
+  {
+    type: "huggingface_token",
+    // HuggingFace tokens: hf_ followed by 34 alphanumeric chars
+    regex: /(?<![A-Za-z0-9])hf_[A-Za-z0-9]{34}(?![A-Za-z0-9])/g
+  },
+  {
+    type: "replicate_token",
+    // Replicate tokens: r8_ followed by 40+ alphanumeric chars
+    regex: /(?<![A-Za-z0-9])r8_[A-Za-z0-9]{40,}(?![A-Za-z0-9])/g
+  },
+  {
+    type: "perplexity_key",
+    // Perplexity API keys: pplx- followed by 40+ alphanumeric chars
+    regex: /(?<![A-Za-z0-9])pplx-[A-Za-z0-9]{40,}(?![A-Za-z0-9])/g
+  },
+  {
+    type: "groq_key",
+    // Groq API keys: gsk_ followed by 40+ alphanumeric chars
+    regex: /(?<![A-Za-z0-9])gsk_[A-Za-z0-9]{40,}(?![A-Za-z0-9])/g
+  },
   {
     type: "bearer_token",
     // Anchored with alternation instead of negative lookahead — avoids V8
@@ -2267,6 +3320,10 @@ function hasCredentialAnchors(text) {
   text.includes("xox") || // Slack token (xoxa/xoxb/xoxp/xoxo/xoxs)
   text.includes("Bearer ") || // Bearer token (space suffix reduces false positives)
   text.includes("/bot") || // Telegram bot token (URL path pattern)
+  text.includes("hf_") || // HuggingFace token
+  text.includes("r8_") || // Replicate token
+  text.includes("pplx-") || // Perplexity API key
+  text.includes("gsk_") || // Groq API key
   text.includes("_KEY=") || // High-entropy env vars: API_KEY=, SECRET_KEY=, ...
   text.includes("_TOKEN=") || // ACCESS_TOKEN=, AUTH_TOKEN=, ...
   text.includes("_SECRET=") || // API_SECRET=, CLIENT_SECRET=, ...
@@ -2389,7 +3446,7 @@ var DefaultModelsRegistry = class {
     this.overlay = opts.overlay;
     this.overlayUrl = opts.overlayUrl;
     this.overlayFile = opts.overlayFile;
-    this.overlayCacheFile = opts.overlayCacheFile ?? (opts.overlayUrl ? path4.join(path4.dirname(opts.cacheFile), "models-overlay-cache.json") : void 0);
+    this.overlayCacheFile = opts.overlayCacheFile ?? (opts.overlayUrl ? path6.join(path6.dirname(opts.cacheFile), "models-overlay-cache.json") : void 0);
   }
   async load(opts = {}) {
     if (this.payload && !opts.force) return this.payload;
@@ -2602,7 +3659,7 @@ var DefaultModelsRegistry = class {
   }
   /** Used by `wstack models refresh` to expose where the cache lives. */
   cacheLocation() {
-    return path4.resolve(this.cacheFile);
+    return path6.resolve(this.cacheFile);
   }
 };
 function hasEntries(payload) {
@@ -3100,7 +4157,7 @@ var InMemoryAgentBridge = class {
       });
     }
     this.inflightGuards.add(correlationId);
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve6, reject) => {
       const timer = setTimeout(() => {
         this.inflightGuards.delete(correlationId);
         this.pendingRequests.delete(correlationId);
@@ -3119,7 +4176,7 @@ var InMemoryAgentBridge = class {
         return;
       }
       this.pendingRequests.set(correlationId, {
-        resolve: resolve4,
+        resolve: resolve6,
         reject,
         timer
       });
@@ -3409,7 +4466,8 @@ ${errorDetails}`,
       let effectivePermission = decision.permission;
       const policy = this.opts.permissionPolicy;
       const yolo = policy.getYolo?.() === true || policy.getYoloDestructive?.() === true;
-      if (toolDangerousCaps.length > 0 && effectivePermission === "auto" && !yolo) {
+      const authoritativeAuto = decision.source === "yolo";
+      if (toolDangerousCaps.length > 0 && effectivePermission === "auto" && !yolo && !authoritativeAuto) {
         effectivePermission = "confirm";
       }
       if (effectivePermission === "deny") {
@@ -3551,9 +4609,10 @@ ${post.additionalContext}`;
     });
     this.opts.renderer?.writeToolCall(tool.name, use.input);
     const output = await this.runWithTimeout(tool, use.input, ctx.signal, ctx, use.id);
-    const text = this.serializer.serialize(output);
+    const text = this.serializer.serialize(output, { toolName: tool.name, input: use.input });
     const scrubbed = this.opts.secretScrubber.scrub(text);
-    const { text: capped, newBudget } = this.serializer.enforceCap(scrubbed, budget);
+    const withArtifact = await maybePersistLargeToolOutput(tool.name, scrubbed, budget);
+    const { text: capped, newBudget } = this.serializer.enforceCap(withArtifact, budget);
     this.opts.renderer?.writeToolResult(tool.name, capped, false);
     return {
       block: {
@@ -3578,38 +4637,27 @@ ${post.additionalContext}`;
       tool.timeoutMs ?? this.iterationTimeoutMs,
       this.maxToolTimeoutMs
     );
-    const ctrl = new AbortController();
-    const timer = setTimeout(() => ctrl.abort(new Error("tool timeout")), timeoutMs);
-    const combined = AbortSignal.any([parentSignal, ctrl.signal]);
-    let cleanupCalled = false;
-    let caught = false;
+    const timeoutSignal = AbortSignal.timeout(timeoutMs);
+    const combined = AbortSignal.any([parentSignal, timeoutSignal]);
+    let output;
     try {
-      if (typeof tool.executeStream === "function") {
-        return await this.runStreamedTool(tool, input, ctx, combined, toolUseId);
-      }
-      return await tool.execute(input, ctx, { signal: combined });
+      output = typeof tool.executeStream === "function" ? await this.runStreamedTool(tool, input, ctx, combined, toolUseId) : await tool.execute(input, ctx, { signal: combined });
     } catch (err) {
-      caught = true;
-      if (combined.aborted && typeof tool.cleanup === "function") {
-        cleanupCalled = true;
-        try {
-          await tool.cleanup(input, ctx);
-        } catch {
-        }
-      }
+      if (combined.aborted) await this.runToolCleanup(tool, input, ctx);
       throw err;
-    } finally {
-      clearTimeout(timer);
-      if (combined.aborted && !caught) {
-        if (!cleanupCalled && typeof tool.cleanup === "function") {
-          try {
-            await tool.cleanup(input, ctx);
-          } catch {
-          }
-        }
-        const reason = combined.reason instanceof Error ? combined.reason : new Error(typeof combined.reason === "string" ? combined.reason : "aborted");
-        throw reason;
-      }
+    }
+    if (combined.aborted) {
+      await this.runToolCleanup(tool, input, ctx);
+      throw combined.reason instanceof Error ? combined.reason : new Error(typeof combined.reason === "string" ? combined.reason : "tool timeout");
+    }
+    return output;
+  }
+  /** Best-effort tool cleanup; never let it mask the original error. */
+  async runToolCleanup(tool, input, ctx) {
+    if (typeof tool.cleanup !== "function") return;
+    try {
+      await tool.cleanup(input, ctx);
+    } catch {
     }
   }
   async runStreamedTool(tool, input, ctx, signal, toolUseId) {
@@ -3778,6 +4826,25 @@ function extractMalformedRaw(input) {
     return String(value);
   }
 }
+var TOOL_OUTPUT_ARTIFACT_THRESHOLD_BYTES = 64 * 1024;
+async function maybePersistLargeToolOutput(toolName, content, budget) {
+  const bytes = Buffer.byteLength(content, "utf8");
+  if (bytes <= Math.min(TOOL_OUTPUT_ARTIFACT_THRESHOLD_BYTES, Math.max(0, budget))) {
+    return content;
+  }
+  try {
+    const dir = path6.join(wstackGlobalRoot(), "tool-output");
+    await fs.mkdir(dir, { recursive: true });
+    const safeTool = toolName.replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 40) || "tool";
+    const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const filePath = path6.join(dir, `${stamp}-${safeTool}-${randomUUID()}.log`);
+    await fs.writeFile(filePath, content, "utf8");
+    return content + `
+[full tool output: ${bytes} bytes at ${filePath}; read/grep that file selectively instead of re-running or requesting more output]`;
+  } catch {
+    return content;
+  }
+}
 
 // src/core/conversation-state.ts
 var ConversationState = class {
@@ -3896,6 +4963,7 @@ var Context = class {
   todos = [];
   readFiles = /* @__PURE__ */ new Set();
   fileMtimes = /* @__PURE__ */ new Map();
+  contextEvidence = createContextEvidenceState();
   systemPrompt;
   provider;
   session;
@@ -3905,6 +4973,13 @@ var Context = class {
   projectRoot;
   /** Mutable working directory — starts as `cwd`. Change via `setWorkingDir()`. */
   workingDir;
+  /**
+   * When true, file tools (via `_util.ts`) and `setWorkingDir()` reject paths
+   * outside `projectRoot`. When false, those boundary checks are bypassed so
+   * tools may reach paths outside the project (still gated by permission
+   * tiers). Mutable so `/settings` can toggle it live on the running session.
+   */
+  allowOutsideProjectRoot;
   model;
   tools = [];
   meta = {};
@@ -3918,11 +4993,6 @@ var Context = class {
    * so storage operations can include it in `storage.*` events.
    */
   traceId;
-  /**
-   * When true, tools can access any path on the filesystem.
-   * When false or undefined, tools are restricted to the project root.
-   */
-  allowOutsideProjectRoot;
   /** Callbacks fired when `setWorkingDir()` changes the working directory. */
   _onWorkingDirChanged = [];
   /**
@@ -3954,12 +5024,13 @@ var Context = class {
     this.cwd = init.cwd;
     this.projectRoot = init.projectRoot;
     this.workingDir = init.workingDir ?? init.cwd;
+    this.allowOutsideProjectRoot = init.allowOutsideProjectRoot ?? false;
     this.model = init.model;
     this.tools = init.tools ?? [];
     this.agentId = init.agentId ?? "unknown";
     this.agentName = init.agentName ?? "Unknown Agent";
     this.traceId = init.traceId;
-    this.allowOutsideProjectRoot = init.allowOutsideProjectRoot ?? true;
+    this.allowOutsideProjectRoot = init.allowOutsideProjectRoot ?? false;
     this.session.traceId = init.traceId;
   }
   /**
@@ -4024,13 +5095,15 @@ var Context = class {
    * Returns the resolved absolute path.
    */
   setWorkingDir(dir) {
-    const resolved = path4.isAbsolute(dir) ? path4.resolve(dir) : path4.resolve(this.projectRoot, dir);
-    const root = path4.resolve(this.projectRoot);
-    const rel = path4.relative(root, resolved);
-    if (rel.startsWith("..") || path4.isAbsolute(rel)) {
-      throw new Error(
-        `Working directory "${resolved}" is outside project root "${root}"`
-      );
+    const resolved = path6.isAbsolute(dir) ? path6.resolve(dir) : path6.resolve(this.projectRoot, dir);
+    if (!this.allowOutsideProjectRoot) {
+      const root = path6.resolve(this.projectRoot);
+      const rel = path6.relative(root, resolved);
+      if (rel.startsWith("..") || path6.isAbsolute(rel)) {
+        throw new Error(
+          `Working directory "${resolved}" is outside project root "${root}"`
+        );
+      }
     }
     const old = this.workingDir;
     this.workingDir = resolved;
@@ -4336,6 +5409,6 @@ function renderPlainText(meta, events) {
   return lines.join("\n");
 }
 
-export { AgentError, CONTEXT_WINDOW_MODES, ConfigError, Context, DEFAULT_AUTONOMY_CONFIG, DEFAULT_CONTEXT_CONFIG, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SESSION_LOGGING_CONFIG, DEFAULT_SESSION_PRUNE_DAYS, DEFAULT_SPEC_TEMPLATE, DEFAULT_TOOLS_CONFIG, DefaultErrorHandler, DefaultLogger, DefaultModelsRegistry, DefaultPathResolver, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultTokenCounter, ERROR_CODES, FsError, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, MEMORY_TYPE_LABELS, PluginError, ProviderError, SddError, SessionError, StreamHangError, ToolError, ToolExecutor, WrongStackError, asBlocks, asText, buildRecoveryStrategies, classifyFamily, computeTaskProgress, createMessage, decryptConfigSecrets, encryptConfigSecrets, findCriticalPath, formatContextWindowModeList, getContextWindowMode, isAgentError, isConfigError, isContextWindowModeId, isFsError, isImageBlock, isPluginError, isSddError, isSecretField, isSessionError, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isWrongStackError, listContextWindowModes, migratePlaintextSecrets, noOpLogger, resolveContextWindowPolicy, rewriteConfigEncrypted, toWrongStackError, topologicalSort };
+export { AgentError, CONTEXT_WINDOW_MODES, ConfigError, Context, DEFAULT_AUTONOMY_CONFIG, DEFAULT_CIRCUIT_BREAKER_CONFIG, DEFAULT_CONTEXT_CONFIG, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SESSION_LOGGING_CONFIG, DEFAULT_SESSION_PRUNE_DAYS, DEFAULT_SPEC_TEMPLATE, DEFAULT_TOOLS_CONFIG, DefaultErrorHandler, DefaultLogger, DefaultModelsRegistry, DefaultPathResolver, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultTokenCounter, ERROR_CODES, FsError, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, MEMORY_TYPE_LABELS, PluginError, ProviderError, SddError, SessionError, StreamHangError, ToolError, ToolExecutor, WrongStackError, asBlocks, asText, buildRecoveryStrategies, classifyFamily, computeTaskProgress, createMessage, decryptConfigSecrets, encryptConfigSecrets, findCriticalPath, formatContextWindowModeList, getContextWindowMode, isAgentError, isConfigError, isContextWindowModeId, isFsError, isImageBlock, isPluginError, isSddError, isSecretField, isSessionError, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isWrongStackError, listContextWindowModes, migratePlaintextSecrets, noOpLogger, normalizeTokenSavingTier, resolveContextWindowPolicy, rewriteConfigEncrypted, rotateConfigKeys, toWrongStackError, topologicalSort };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map