@wrongstack/core 0.291.2 → 0.292.1

package/dist/utils/index.js

@@ -727,6 +727,50 @@ async function backupConfigFile(filePath, paths) {
   }
 }
 
+// src/utils/connectivity.ts
+var DEFAULT_PROBE_URL = "https://1.1.1.1";
+var DEFAULT_TIMEOUT_MS = 5e3;
+var DEFAULT_TTL_MS = 3e4;
+var cached;
+async function checkConnectivity(opts) {
+  const url = opts?.probeUrl ?? DEFAULT_PROBE_URL;
+  const timeout = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const ttl = opts?.ttlMs ?? DEFAULT_TTL_MS;
+  if (cached && ttl > 0 && Date.now() - cached.at < ttl) {
+    return cached.ok;
+  }
+  cached = { ok: await probe(url, timeout), at: Date.now() };
+  return cached.ok;
+}
+async function probe(url, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    await fetch(url, { method: "HEAD", signal: controller.signal });
+    return true;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function resetConnectivityCache() {
+  cached = void 0;
+}
+
+// src/utils/cache-key.ts
+import { createHash } from "node:crypto";
+var keyCache = /* @__PURE__ */ new WeakMap();
+function deriveCachePrefixKey(systemPrompt) {
+  const cached2 = keyCache.get(systemPrompt);
+  if (cached2 !== void 0) return cached2;
+  const h = createHash("sha256");
+  for (const block of systemPrompt) h.update(block.text).update("\0");
+  const key = `ws-${h.digest("hex").slice(0, 32)}`;
+  keyCache.set(systemPrompt, key);
+  return key;
+}
+
 // src/utils/config-json.ts
 import * as fs3 from "node:fs/promises";
 async function readJsonObjectFile(filePath) {
@@ -1209,217 +1253,6 @@ function metadataReferencedByText(metadata, haystack) {
   return false;
 }
 
-// src/utils/deep-merge.ts
-var FORBIDDEN_PROTO_KEYS = /* @__PURE__ */ new Set([
-  "__proto__",
-  "constructor",
-  "prototype",
-  "__defineGetter__",
-  "__defineSetter__",
-  "__lookupGetter__",
-  "__lookupSetter__"
-]);
-function isPrimitiveArray(a) {
-  return a.every((v) => v === null || typeof v !== "object" && typeof v !== "function");
-}
-function deepMerge(base, patch, options = {}) {
-  const {
-    conflictResolution = "prefer-patch",
-    arrayMode = "replace",
-    protectProto = true,
-    onNonPrimitiveArrayReplace
-  } = options;
-  if (typeof base !== "object" || base === null) {
-    return conflictResolution === "prefer-patch" ? patch : base;
-  }
-  if (typeof patch !== "object" || patch === null) {
-    return conflictResolution === "prefer-patch" ? patch : base;
-  }
-  if (Array.isArray(base) && Array.isArray(patch)) {
-    if (arrayMode === "concat-primitives" && isPrimitiveArray(base) && isPrimitiveArray(patch)) {
-      return [.../* @__PURE__ */ new Set([...base, ...patch])];
-    }
-    return conflictResolution === "prefer-patch" ? patch : base;
-  }
-  if (Array.isArray(base) || Array.isArray(patch)) {
-    return conflictResolution === "prefer-patch" ? patch : base;
-  }
-  const baseObj = base;
-  const patchObj = patch;
-  const out = { ...baseObj };
-  for (const [k, v] of Object.entries(patchObj)) {
-    if (protectProto && FORBIDDEN_PROTO_KEYS.has(k)) continue;
-    const existing = out[k];
-    if (v !== null && typeof v === "object" && !Array.isArray(v) && existing !== null && typeof existing === "object" && !Array.isArray(existing)) {
-      out[k] = deepMerge(existing, v, options);
-    } else if (Array.isArray(v) && Array.isArray(existing)) {
-      if (onNonPrimitiveArrayReplace && !isPrimitiveArray(v)) {
-        onNonPrimitiveArrayReplace(k, existing.length, v.length);
-      }
-      out[k] = deepMerge(existing, v, options);
-    } else if (v !== void 0) {
-      if (onNonPrimitiveArrayReplace && Array.isArray(v) && !isPrimitiveArray(v)) {
-        const existingLen = Array.isArray(existing) ? existing.length : 0;
-        onNonPrimitiveArrayReplace(k, existingLen, v.length);
-      }
-      out[k] = v;
-    }
-  }
-  return out;
-}
-
-// src/utils/diff.ts
-function myersDiff(a, b) {
-  const N = a.length;
-  const M = b.length;
-  const max = N + M;
-  if (max === 0) return [];
-  const v = /* @__PURE__ */ new Map();
-  v.set(1, 0);
-  const trace = [];
-  for (let d = 0; d <= max; d++) {
-    const snapshot = new Map(v);
-    trace.push(snapshot);
-    for (let k = -d; k <= d; k += 2) {
-      const left = v.get(k - 1) ?? -1;
-      const right = v.get(k + 1) ?? -1;
-      let x;
-      if (k === -d || k !== d && left < right) {
-        x = right;
-      } else {
-        x = left + 1;
-      }
-      let y = x - k;
-      while (x < N && y < M && a[x] === b[y]) {
-        x++;
-        y++;
-      }
-      v.set(k, x);
-      if (x >= N && y >= M) {
-        return backtrack(trace, a, b, N, M, d);
-      }
-    }
-  }
-  return [];
-}
-function backtrack(trace, a, b, N, M, finalD) {
-  const edits = [];
-  let x = N;
-  let y = M;
-  for (let d = finalD; d > 0; d--) {
-    const v = trace[d];
-    if (!v) break;
-    const k = x - y;
-    const left = v.get(k - 1) ?? -1;
-    const right = v.get(k + 1) ?? -1;
-    let prevK;
-    if (k === -d || k !== d && left < right) {
-      prevK = k + 1;
-    } else {
-      prevK = k - 1;
-    }
-    const prevX = v.get(prevK) ?? 0;
-    const prevY = prevX - prevK;
-    while (x > prevX && y > prevY) {
-      edits.push({ op: "equal", a: x - 1, b: y - 1, line: a[x - 1] ?? "" });
-      x--;
-      y--;
-    }
-    if (d > 0) {
-      if (x === prevX) {
-        edits.push({ op: "insert", a: x, b: y - 1, line: b[y - 1] ?? "" });
-      } else {
-        edits.push({ op: "delete", a: x - 1, b: y, line: a[x - 1] ?? "" });
-      }
-      x = prevX;
-      y = prevY;
-    }
-  }
-  while (x > 0 && y > 0) {
-    edits.push({ op: "equal", a: x - 1, b: y - 1, line: a[x - 1] ?? "" });
-    x--;
-    y--;
-  }
-  return edits.reverse();
-}
-function unifiedDiff(oldText, newText, opts = {}) {
-  const context = opts.context ?? 3;
-  const a = oldText.split("\n");
-  const b = newText.split("\n");
-  if (a[a.length - 1] === "") a.pop();
-  if (b[b.length - 1] === "") b.pop();
-  const edits = myersDiff(a, b);
-  if (edits.every((e) => e.op === "equal")) return "";
-  const hunks = [];
-  let i = 0;
-  while (i < edits.length) {
-    while (i < edits.length && edits[i]?.op === "equal") i++;
-    if (i >= edits.length) break;
-    const hunkStart = Math.max(0, i - context);
-    const lines = [];
-    let aStart = (edits[hunkStart]?.a ?? 0) + 1;
-    let bStart = (edits[hunkStart]?.b ?? 0) + 1;
-    let aCount = 0;
-    let bCount = 0;
-    let cursor = hunkStart;
-    let trailing = 0;
-    while (cursor < edits.length) {
-      const e = edits[cursor];
-      if (!e) break;
-      if (e.op === "equal") {
-        trailing++;
-        if (trailing > context * 2) break;
-      } else {
-        trailing = 0;
-      }
-      if (e.op === "equal") {
-        lines.push(` ${e.line}`);
-        aCount++;
-        bCount++;
-      } else if (e.op === "delete") {
-        lines.push(`-${e.line}`);
-        aCount++;
-      } else {
-        lines.push(`+${e.line}`);
-        bCount++;
-      }
-      cursor++;
-    }
-    while (lines.length > 0 && lines[lines.length - 1]?.startsWith(" ") && trailing > context) {
-      lines.pop();
-      aCount--;
-      bCount--;
-      trailing--;
-    }
-    if (aCount === 0) aStart = 0;
-    if (bCount === 0) bStart = 0;
-    hunks.push({ aStart, bStart, lines });
-    i = cursor;
-  }
-  if (hunks.length === 0) return "";
-  let out = "";
-  out += `--- ${opts.fromFile ?? "a"}
-`;
-  out += `+++ ${opts.toFile ?? "b"}
-`;
-  for (const h of hunks) {
-    let aCount = 0;
-    let bCount = 0;
-    for (const l of h.lines) {
-      if (l.startsWith(" ")) {
-        aCount++;
-        bCount++;
-      } else if (l.startsWith("-")) aCount++;
-      else if (l.startsWith("+")) bCount++;
-    }
-    out += `@@ -${h.aStart},${aCount} +${h.bStart},${bCount} @@
-`;
-    out += `${h.lines.join("\n")}
-`;
-  }
-  return out;
-}
-
 // src/utils/error.ts
 function toErrorMessage(err) {
   return err instanceof Error ? err.message : String(err);
@@ -1435,1511 +1268,1894 @@ function expectDefined(value, label) {
   return value;
 }
 
-// src/utils/glob-expand.ts
-import * as fsp from "node:fs/promises";
-import { isAbsolute as isAbsolute2, resolve as resolve2 } from "node:path";
-var GLOB_CHARS = /* @__PURE__ */ new Set(["*", "?", "["]);
-var IS_WINDOWS = process.platform === "win32";
-var SEP = IS_WINDOWS ? "\\" : "/";
-function isGlob(p) {
-  for (const c of p) {
-    if (GLOB_CHARS.has(c)) return true;
-  }
-  return false;
-}
-function globToRegex(pat) {
-  let i = 0;
-  let re = "^";
-  while (i < pat.length) {
-    const c = expectDefined(pat[i]);
-    if (c === "*") {
-      if (pat[i + 1] === "*") {
-        re += ".*";
-        i += 2;
-        if (pat[i] === "/") i++;
-      } else {
-        re += "[^/\\\\]*";
-        i++;
-      }
-    } else if (c === "?") {
-      re += "[^/\\\\]";
-      i++;
-    } else if (c === "[") {
-      let cls = "[";
-      i++;
-      if (pat[i] === "!" || pat[i] === "^") {
-        cls += "^";
-        i++;
-      }
-      while (i < pat.length && pat[i] !== "]") {
-        const ch = pat[i] ?? "";
-        if (ch === "\\") cls += "\\\\";
-        else if (ch === "]" || ch === "^") cls += `\\${ch}`;
-        else cls += ch;
-        i++;
-      }
-      cls += "]";
-      re += cls;
-      i++;
-    } else {
-      re += c.replace(/[.+^${}()|\\]/g, "\\$&");
-      i++;
-    }
-  }
-  return new RegExp(re + "$");
-}
-function baseDir(pat) {
-  let firstGlob = pat.length;
-  for (let i = 0; i < pat.length; i++) {
-    if (GLOB_CHARS.has(expectDefined(pat[i]))) {
-      firstGlob = i;
-      break;
-    }
-  }
-  const cut = Math.max(
-    pat.lastIndexOf(SEP, firstGlob - 1),
-    pat.lastIndexOf("/", firstGlob - 1)
-  );
-  return cut < 0 ? "." : pat.slice(0, cut);
-}
-async function expandGlob(pattern) {
-  if (!isGlob(pattern)) return [pattern];
-  const results = /* @__PURE__ */ new Set();
-  const abs = isAbsolute2(pattern);
-  const base = abs ? baseDir(pattern) : baseDir(pattern);
-  const relPat = base === "." ? pattern : pattern.slice(base.length + 1);
-  async function walk2(dir, pat) {
-    let entries;
-    try {
-      entries = await fsp.readdir(dir);
-    } catch {
-      return;
-    }
-    const firstGlob = pat.search(/[*?[[]/);
-    if (firstGlob < 0) {
-      const re = globToRegex(pat);
-      for (const e of entries) {
-        if (re.test(e)) {
-          const full = `${dir}${SEP}${e}`;
-          results.add(abs ? resolve2(full) : full);
+// src/utils/message-invariants.ts
+function repairToolUseAdjacency(messages) {
+  const removedToolUses = [];
+  const removedToolResults = [];
+  let removedMessages = 0;
+  let changed = false;
+  const out = [];
+  for (let i = 0; i < messages.length; i++) {
+    const original = expectDefined(messages[i]);
+    let msg = original;
+    if (hasToolUse(msg)) {
+      const nextIds = toolResultIds(messages[i + 1]);
+      const filtered = mapContent(msg, (blocks) => {
+        const next = [];
+        for (const block of blocks) {
+          if (block.type === "tool_use" && !nextIds.has(block.id)) {
+            removedToolUses.push(block.id);
+            changed = true;
+            continue;
+          }
+          next.push(block);
         }
-      }
-      return;
+        return next;
+      });
+      msg = filtered ?? msg;
     }
-    const before = pat.slice(0, firstGlob);
-    const rest = pat.slice(firstGlob);
-    if (before.endsWith("**")) {
-      await walk2(dir, rest);
-      for (const e of entries) {
-        const full = `${dir}${SEP}${e}`;
-        try {
-          const stat3 = await fsp.stat(full);
-          if (stat3.isDirectory()) await walk2(full, rest);
-        } catch {
-        }
-      }
-    } else if (before === "") {
-      const re = globToRegex(rest);
-      for (const e of entries) {
-        if (re.test(e)) {
-          const full = `${dir}${SEP}${e}`;
-          results.add(abs ? resolve2(full) : full);
-        }
-      }
-    } else {
-      const seg = before.replace(/[*?[\]]/g, "").replace(/\/$/, "");
-      if (entries.includes(seg)) {
-        const full = `${dir}${SEP}${seg}`;
-        try {
-          const stat3 = await fsp.stat(full);
-          if (stat3.isDirectory()) await walk2(full, rest);
-        } catch {
+    if (hasToolResult(msg)) {
+      const allowed = toolUseIds(out[out.length - 1]);
+      const filtered = mapContent(msg, (blocks) => {
+        const next = [];
+        for (const block of blocks) {
+          if (block.type === "tool_result" && !allowed.has(block.tool_use_id)) {
+            removedToolResults.push(block.tool_use_id);
+            changed = true;
+            continue;
+          }
+          next.push(block);
         }
-      }
+        return next;
+      });
+      msg = filtered ?? msg;
+    }
+    if (isEmptyMessage(msg)) {
+      removedMessages++;
+      changed = true;
+      continue;
     }
+    out.push(msg);
   }
-  await walk2(base === "." ? "." : base, relPat);
-  return [...results];
+  return {
+    messages: changed ? out : messages,
+    report: { changed, removedToolUses, removedToolResults, removedMessages }
+  };
 }
-
-// src/utils/glob-match.ts
-function escapeRegex(s) {
-  return s.replace(/[.+^${}()|\\]/g, "\\$&");
+function hasToolUse(msg) {
+  return contentBlocks(msg).some((b) => b.type === "tool_use");
 }
-var COMPILED_GLOB_CACHE = /* @__PURE__ */ new Map();
-var CACHE_MAX_SIZE = 2e3;
-var NEVER_MATCH = /[^\s\S]/;
-function getCachedGlob(pattern) {
-  const cached = COMPILED_GLOB_CACHE.get(pattern);
-  if (cached) return cached;
-  if (COMPILED_GLOB_CACHE.size >= CACHE_MAX_SIZE) {
-    const keys = [...COMPILED_GLOB_CACHE.keys()];
-    for (let i = 0; i < Math.floor(CACHE_MAX_SIZE / 4); i++) {
-      COMPILED_GLOB_CACHE.delete(expectDefined(keys[i]));
-    }
+function hasToolResult(msg) {
+  return contentBlocks(msg).some((b) => b.type === "tool_result");
+}
+function toolUseIds(msg) {
+  const ids = /* @__PURE__ */ new Set();
+  if (msg?.role !== "assistant") return ids;
+  for (const block of contentBlocks(msg)) {
+    if (block.type === "tool_use") ids.add(block.id);
   }
-  let re;
-  try {
-    re = compileGlob(pattern);
-  } catch {
-    re = NEVER_MATCH;
+  return ids;
+}
+function toolResultIds(msg) {
+  const ids = /* @__PURE__ */ new Set();
+  if (msg?.role !== "user") return ids;
+  for (const block of contentBlocks(msg)) {
+    if (block.type === "tool_result") ids.add(block.tool_use_id);
   }
-  COMPILED_GLOB_CACHE.set(pattern, re);
-  return re;
+  return ids;
 }
-var MAX_GLOB_PATTERN_LEN = 1024;
-function compileGlob(pattern) {
-  if (pattern.length > MAX_GLOB_PATTERN_LEN) {
-    throw new Error(`Glob pattern exceeds ${MAX_GLOB_PATTERN_LEN} characters`);
+function contentBlocks(msg) {
+  return msg && Array.isArray(msg.content) ? msg.content : [];
+}
+function mapContent(msg, fn) {
+  if (!Array.isArray(msg.content)) return msg;
+  const next = fn(msg.content);
+  if (next.length === msg.content.length && next.every((b, idx) => b === msg.content[idx])) {
+    return msg;
   }
-  let i = 0;
-  let re = "^";
-  while (i < pattern.length) {
-    const c = pattern[i];
-    if (c === "*") {
-      if (pattern[i + 1] === "*") {
-        re += ".*";
-        i += 2;
-        if (pattern[i] === "/") i++;
-      } else {
-        re += "[^/]*";
-        i++;
-      }
-    } else if (c === "?") {
-      re += "[^/]";
-      i++;
-    } else if (c === "[") {
-      let cls = "[";
-      i++;
-      if (pattern[i] === "!" || pattern[i] === "^") {
-        cls += "^";
-        i++;
-      }
-      while (i < pattern.length && pattern[i] !== "]") {
-        const ch = pattern[i] ?? "";
-        if (ch === "\\") {
-          cls += "\\\\";
-        } else if (ch === "]" || ch === "^") {
-          cls += `\\${ch}`;
-        } else {
-          cls += ch;
-        }
-        i++;
-      }
-      cls += "]";
-      re += cls;
-      i++;
-    } else {
-      re += escapeRegex(c ?? "");
-      i++;
+  return { ...msg, content: next };
+}
+function hasMeaningfulContent(content) {
+  if (typeof content === "string") return content.trim().length > 0;
+  for (const block of content) {
+    if (block.type === "text") {
+      if (block.text.trim().length > 0) return true;
+      continue;
+    }
+    if (block.type === "thinking") {
+      if (block.thinking.trim().length > 0 || block.signature) return true;
+      continue;
     }
+    return true;
   }
-  re += "$";
-  return new RegExp(re);
-}
-function matchGlob(pattern, input) {
-  return getCachedGlob(pattern).test(input);
+  return false;
 }
-function matchAny(patterns, input) {
-  return patterns.some((p) => matchGlob(p, input));
+function isEmptyMessage(msg) {
+  return !hasMeaningfulContent(msg.content);
 }
 
-// src/utils/incoming-images.ts
-var MAX_INCOMING_IMAGES = 8;
-var MAX_INCOMING_IMAGE_BYTES = 8 * 1024 * 1024;
-var ALLOWED_IMAGE_MEDIA_TYPES = /* @__PURE__ */ new Set([
-  "image/png",
-  "image/jpeg",
-  "image/webp",
-  "image/gif"
-]);
-var IncomingImageError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "IncomingImageError";
+// src/core/agent-response.ts
+var MAX_TODO_SNAPSHOT_ITEMS = 10;
+var MAX_TODO_SNAPSHOT_CONTENT = 180;
+function buildLiveNextStepsGateBlock(ctx) {
+  if (ctx.agentId !== "leader") return void 0;
+  const openTodos = ctx.todos.filter(
+    (todo) => todo.status === "pending" || todo.status === "in_progress"
+  );
+  if (openTodos.length === 0) {
+    return {
+      type: "text",
+      text: [
+        "[nextsteps_gate]",
+        "Authoritative live state for this request: open todos = 0.",
+        "On the final response, you MUST take exactly one branch:",
+        "1. If at least one genuinely useful follow-on action exists, include a balanced <nextsteps> block containing 1-4 exact prompt messages that can be submitted back to you through the current TUI or WebUI input.",
+        "Every item must ask the agent to perform work. Never put a human-only chore or an instruction addressed to the user inside <nextsteps>; natural-language agent-directed imperatives are valid and need not be shell commands.",
+        "2. If no useful follow-on action truly exists, omit <nextsteps> and explicitly tell the user in normal prose that no further steps are needed for this task.",
+        "Silently omitting both is invalid. Do not decide by chance, tone, or response length, and do not invent filler suggestions.",
+        "[/nextsteps_gate]"
+      ].join("\n"),
+      cache_control: { type: "ephemeral" }
+    };
   }
-};
-var DATA_URL_RE = /^data:([a-z0-9.+-]+\/[a-z0-9.+-]+)?(?:;[a-z0-9-]+=[^;,]*)*(;base64)?,/i;
-function splitDataUrl(data) {
-  const match = DATA_URL_RE.exec(data);
-  if (!match) return { base64: data.trim() };
+  const todoSnapshot = openTodos.slice(0, MAX_TODO_SNAPSHOT_ITEMS).map((todo) => {
+    const normalized = todo.content.replace(/\s+/g, " ").trim();
+    const content = normalized.length > MAX_TODO_SNAPSHOT_CONTENT ? `${normalized.slice(0, MAX_TODO_SNAPSHOT_CONTENT - 1)}\u2026` : normalized;
+    return `- [${todo.status}] ${content}`;
+  });
+  const omitted = openTodos.length - todoSnapshot.length;
+  if (omitted > 0) todoSnapshot.push(`- \u2026and ${omitted} more open todo(s)`);
   return {
-    base64: data.slice(match[0].length).trim(),
-    mediaType: match[1]?.toLowerCase()
+    type: "text",
+    text: [
+      "[nextsteps_gate]",
+      `Authoritative live state for this request: open todos = ${openTodos.length}.`,
+      "You MUST omit <nextsteps> entirely while these todos remain open. Continue or finish the tracked work; do not propose unrelated follow-on work.",
+      "Open todo snapshot:",
+      ...todoSnapshot,
+      "[/nextsteps_gate]"
+    ].join("\n"),
+    cache_control: { type: "ephemeral" }
   };
 }
-function parseIncomingImages(images, legacyImageBase64) {
-  const raw = [...images ?? []];
-  if (legacyImageBase64) raw.push({ data: legacyImageBase64 });
-  if (raw.length === 0) return [];
-  if (raw.length > MAX_INCOMING_IMAGES) {
-    throw new IncomingImageError(
-      `Too many images: ${raw.length} (max ${MAX_INCOMING_IMAGES} per message).`
-    );
+
+// src/core/system-prompt-builder.ts
+var SYSTEM_BLOCK_SOURCE = /* @__PURE__ */ new WeakMap();
+
+// src/utils/tool-wire-compact.ts
+var TOOL_DESCRIPTION_MAX_CHARS = 400;
+var SCHEMA_DESCRIPTION_MAX_CHARS = 120;
+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 cached2 = compactCache.get(tool);
+    if (cached2) return cached2;
   }
-  return raw.map((img, i) => {
-    const { base64, mediaType: fromUrl } = splitDataUrl(img.data ?? "");
-    const mediaType = (img.mediaType ?? fromUrl ?? "image/png").toLowerCase();
-    if (!ALLOWED_IMAGE_MEDIA_TYPES.has(mediaType)) {
-      throw new IncomingImageError(
-        `Image ${i + 1}: unsupported media type "${mediaType}" (allowed: ${[...ALLOWED_IMAGE_MEDIA_TYPES].join(", ")}).`
-      );
-    }
-    if (!base64) {
-      throw new IncomingImageError(`Image ${i + 1}: empty image data.`);
-    }
-    if (!/^[A-Za-z0-9+/]+={0,2}$/.test(base64)) {
-      throw new IncomingImageError(`Image ${i + 1}: data is not valid base64.`);
+  const compact = {
+    name: tool.name,
+    description: compactDescription(
+      tool.description ?? "",
+      opts.descriptionMaxChars ?? TOOL_DESCRIPTION_MAX_CHARS
+    ),
+    inputSchema: normalizeTopLevelToolSchema(
+      compactSchemaDescriptions(
+        tool.inputSchema,
+        opts.schemaDescriptionMaxChars ?? SCHEMA_DESCRIPTION_MAX_CHARS
+      )
+    )
+  };
+  if (useDefaultOptions && typeof tool === "object" && tool !== null) {
+    compactCache.set(tool, compact);
+  }
+  return compact;
+}
+function normalizeTopLevelToolSchema(schema) {
+  const combinators = ["oneOf", "anyOf", "allOf"].map((keyword) => ({ keyword, branches: schema[keyword] })).filter(
+    (entry) => Array.isArray(entry.branches)
+  );
+  if (combinators.length === 0) return schema;
+  const out = { ...schema, type: "object" };
+  delete out["oneOf"];
+  delete out["anyOf"];
+  delete out["allOf"];
+  const properties = isRecord(schema["properties"]) ? { ...schema["properties"] } : {};
+  let required = stringSet(schema["required"]);
+  for (const { keyword, branches } of combinators) {
+    const objectBranches = branches.filter(isRecord);
+    for (const branch of objectBranches) {
+      if (isRecord(branch["properties"])) Object.assign(properties, branch["properties"]);
     }
-    const bytes = Math.floor(base64.length * 3 / 4);
-    if (bytes > MAX_INCOMING_IMAGE_BYTES) {
-      throw new IncomingImageError(
-        `Image ${i + 1}: ${(bytes / (1024 * 1024)).toFixed(1)} MB exceeds the ${MAX_INCOMING_IMAGE_BYTES / (1024 * 1024)} MB limit.`
+    const branchRequired = objectBranches.map((branch) => stringSet(branch["required"]));
+    if (keyword === "allOf") {
+      for (const fields of branchRequired) for (const field of fields) required.add(field);
+    } else if (branchRequired.length > 0) {
+      const common = new Set(
+        [...branchRequired[0]].filter(
+          (field) => branchRequired.slice(1).every((fields) => fields.has(field))
+        )
       );
+      required = /* @__PURE__ */ new Set([...required, ...common]);
     }
-    return {
-      type: "image",
-      source: { type: "base64", media_type: mediaType, data: base64 }
-    };
-  });
-}
-function buildUserContentBlocks(text, images) {
-  const blocks = [...images];
-  if (text) blocks.push({ type: "text", text });
-  return blocks;
-}
-
-// src/utils/ip-guard.ts
-import * as dns from "node:dns/promises";
-import * as net from "node:net";
-function isPrivateIPv4(addr) {
-  const parts = addr.split(".").map((p) => Number.parseInt(p, 10));
-  if (parts.length !== 4 || parts.some((n) => Number.isNaN(n) || n < 0 || n > 255)) {
-    return true;
   }
-  const [a, b, c] = parts;
-  if (a === 0) return true;
-  if (a === 10) return true;
-  if (a === 127) return true;
-  if (a === 169 && b === 254) return true;
-  if (a === 172 && b >= 16 && b <= 31) return true;
-  if (a === 192 && b === 168) return true;
-  if (a === 192 && b === 0 && c === 0) return true;
-  if (a === 100 && b >= 64 && b <= 127) return true;
-  if (a >= 224) return true;
-  return false;
+  out["properties"] = properties;
+  if (required.size > 0) out["required"] = [...required];
+  else delete out["required"];
+  return out;
 }
-function isPrivateIPv6(raw) {
-  const lower = raw.toLowerCase();
-  if (lower === "::" || lower === "::1") return true;
-  const groups = expandIPv6(lower);
-  if (!groups) return true;
-  if (groups[0] === 0 && groups[1] === 0 && groups[2] === 0 && groups[3] === 0 && groups[4] === 0 && groups[5] === 65535) {
-    const a = (groups[6] ?? 0) >> 8;
-    const b = (groups[6] ?? 0) & 255;
-    const c = (groups[7] ?? 0) >> 8;
-    const d = (groups[7] ?? 0) & 255;
-    return isPrivateIPv4(`${a}.${b}.${c}.${d}`);
-  }
-  const high = groups[0] ?? 0;
-  if ((high & 65024) === 64512) return true;
-  if ((high & 65472) === 65152) return true;
-  if ((high & 65280) === 65280) return true;
-  return false;
+function stringSet(value) {
+  return new Set(
+    Array.isArray(value) ? value.filter((item) => typeof item === "string") : []
+  );
 }
-function expandIPv6(addr) {
-  const parts = addr.split("::");
-  if (parts.length > 2) return null;
-  const parseGroups = (s) => {
-    if (s === "") return [];
-    const out = [];
-    for (const g of s.split(":")) {
-      if (g.length === 0 || g.length > 4) return null;
-      const n = Number.parseInt(g, 16);
-      if (Number.isNaN(n) || n < 0 || n > 65535) return null;
-      out.push(n);
-    }
-    return out;
-  };
-  if (parts.length === 1) {
-    const groups = parseGroups(parts[0] ?? "");
-    if (groups?.length !== 8) return null;
-    return groups;
-  }
-  const head = parseGroups(parts[0] ?? "");
-  const tail = parseGroups(parts[1] ?? "");
-  if (!head || !tail) return null;
-  const fill = 8 - head.length - tail.length;
-  if (fill < 0) return null;
-  return [...head, ...new Array(fill).fill(0), ...tail];
+function compactSchemaDescriptions(schema, maxDescriptionChars = SCHEMA_DESCRIPTION_MAX_CHARS) {
+  const compact = compactSchemaNode(schema, maxDescriptionChars);
+  return isRecord(compact) ? compact : { type: "object", properties: {} };
 }
-async function assertNotPrivateHost(hostname) {
-  const host = hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
-  if (host === "localhost" || host.endsWith(".localhost")) {
-    throw new Error("fetch: blocked localhost target");
+function compactSchemaNode(node, maxDescriptionChars) {
+  if (Array.isArray(node)) {
+    return node.map((item) => compactSchemaNode(item, maxDescriptionChars));
   }
-  const ipVersion = net.isIP(host);
-  if (ipVersion === 4) {
-    if (isPrivateIPv4(host)) {
-      throw new Error(`fetch: blocked private/loopback address "${host}"`);
-    }
-  } else if (ipVersion === 6) {
-    if (isPrivateIPv6(host)) {
-      throw new Error(`fetch: blocked private/loopback address "${host}"`);
-    }
-  } else {
-    try {
-      const records = await dns.lookup(host, { all: true });
-      for (const r of records) {
-        const bad = r.family === 4 ? isPrivateIPv4(r.address) : isPrivateIPv6(r.address);
-        if (bad) {
-          throw new Error(`fetch: resolved to private address ${r.address}`);
-        }
-      }
-    } catch (err) {
-      if (err instanceof Error && err.message.startsWith("fetch:")) throw err;
+  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/json-repair.ts
-function completePartialObject(s) {
-  if (!s.trim().startsWith("{")) return s;
-  if (tryParse(s).ok) return s;
-  return repairTruncated(s);
+// src/utils/token-estimate.ts
+var RoughTokenEstimate = (text, charsPerToken = 3.5) => Math.max(1, Math.ceil(text.length / charsPerToken));
+var CAL_ALPHA = 0.3;
+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;
 }
-function repairTruncated(s) {
-  const stack = [];
-  let inString = false;
-  let escaped = false;
-  let sawKey = false;
-  let prevSig = "";
-  let contentEnd = 0;
-  let stringBraceDepth = 0;
-  for (let i = 0; i < s.length; i++) {
-    const ch = expectDefined(s[i]);
-    if (inString) {
-      contentEnd = i + 1;
-      if (escaped) {
-        escaped = false;
-        continue;
-      }
-      if (ch === "\\") {
-        escaped = true;
-        continue;
-      }
-      if (ch === '"') {
-        inString = false;
-        prevSig = '"';
-        stringBraceDepth = 0;
-        continue;
-      }
-      if (ch === "{") stringBraceDepth++;
-      else if (ch === "}" && stringBraceDepth > 0) stringBraceDepth--;
-      continue;
-    }
-    if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") continue;
-    contentEnd = i + 1;
-    if (ch === '"') {
-      inString = true;
-      sawKey = true;
-      stringBraceDepth = 0;
-      prevSig = '"';
-    } else if (ch === "{" || ch === "[") {
-      stack.push(ch);
-      prevSig = ch;
-    } else if (ch === "}" || ch === "]") {
-      stack.pop();
-      prevSig = ch;
-    } else {
-      prevSig = ch;
-    }
-  }
-  if (!sawKey && !inString) return s;
-  let result = s.slice(0, contentEnd);
-  if (inString) {
-    if (escaped) {
-      result = result.slice(0, -1);
-    } else if (endsWithInvalidEscape(result)) {
-      result = result.slice(0, -2);
+var MIN_SAMPLES_FOR_CALIBRATION = 3;
+var MODEL_FAMILY_RATIO = {
+  // Anthropic: ~3.8-4.0 chars/token depending on model
+  claude: 3.8,
+  // OpenAI: ~4.0 chars/token
+  "gpt-4": 4,
+  "gpt-3.5": 4,
+  // Google: ~3.5 chars/token
+  gemini: 3.5,
+  // DeepSeek: ~3.5 chars/token
+  deepseek: 3.5
+};
+var ESTIMATE_CACHE = /* @__PURE__ */ new Map();
+var _estimateCacheOrder = [];
+var ESTIMATE_CACHE_MAX_SIZE = 5e4;
+function getCachedEstimate(key, compute) {
+  const existing = ESTIMATE_CACHE.get(key);
+  if (existing !== void 0) return existing;
+  if (ESTIMATE_CACHE.size >= ESTIMATE_CACHE_MAX_SIZE) {
+    while (ESTIMATE_CACHE.size > Math.floor(ESTIMATE_CACHE_MAX_SIZE / 2)) {
+      const oldest = _estimateCacheOrder.shift();
+      if (oldest !== void 0) ESTIMATE_CACHE.delete(oldest);
     }
-    if (stringBraceDepth > 0) result += "}".repeat(stringBraceDepth);
-    result += '"';
-  } else if (prevSig === ":") {
-    result += "null";
-  }
-  for (let k = stack.length - 1; k >= 0; k--) {
-    result += stack[k] === "{" ? "}" : "]";
   }
-  if (!tryParse(result).ok) {
-    const patched = result.replace(/:(\s*)([}\]])/g, ":null$2");
-    if (tryParse(patched).ok) result = patched;
-  }
-  return result;
-}
-var VALID_ESCAPE = /* @__PURE__ */ new Set(['"', "\\", "/", "b", "f", "n", "r", "t", "u"]);
-function endsWithInvalidEscape(str) {
-  const last = str[str.length - 1];
-  if (str[str.length - 2] !== "\\" || last === void 0) return false;
-  if (VALID_ESCAPE.has(last)) return false;
-  let backslashes = 0;
-  for (let k = str.length - 2; k >= 0 && str[k] === "\\"; k--) backslashes++;
-  return backslashes % 2 === 1;
+  const estimate = compute(key);
+  ESTIMATE_CACHE.set(key, estimate);
+  _estimateCacheOrder.push(key);
+  return estimate;
 }
-function tryParse(s) {
-  try {
-    return { ok: true, value: JSON.parse(s) };
-  } catch {
-    return { ok: false };
+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));
 }
-
-// src/utils/json-schema-validate.ts
-function validateAgainstSchema(value, schema) {
-  const errors = [];
-  walk(value, schema, "", errors, 0);
-  return { ok: errors.length === 0, errors };
+function estimateToolResultTokens(content) {
+  if (typeof content === "string") return RoughTokenEstimate(content);
+  return getCachedEstimate(JSON.stringify(content), (key) => RoughTokenEstimate(key));
 }
-var MAX_SCHEMA_DEPTH = 64;
-function walk(value, schema, path6, errors, depth) {
-  if (depth > MAX_SCHEMA_DEPTH) {
-    errors.push({
-      path: path6 || "<root>",
-      message: `schema nesting exceeds maximum depth (${MAX_SCHEMA_DEPTH})`
-    });
-    return;
-  }
-  if (schema.enum !== void 0) {
-    if (!enumIncludes(schema.enum, value)) {
-      errors.push({
-        path: path6 || "<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: path6 || "<root>",
-        message: `expected ${schema.type}, got ${describeType(value)} (${previewValue(value)})`
-      });
-      return;
-    }
-  }
-  if (schema.type === "object" && isPlainObject(value)) {
-    const obj = value;
-    for (const req of schema.required ?? []) {
-      if (!(req in obj)) {
-        const expected = schema.properties?.[req]?.type;
-        errors.push({
-          path: joinPath(path6, req),
-          message: `required property missing${typeof expected === "string" ? ` (expected ${expected})` : ""}`
-        });
-      }
-    }
-    if (schema.properties) {
-      for (const [key, subSchema] of Object.entries(schema.properties)) {
-        if (key in obj) {
-          walk(obj[key], subSchema, joinPath(path6, key), errors, depth + 1);
-        }
-      }
-    }
+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));
   }
-  if (schema.type === "array" && Array.isArray(value) && schema.items) {
-    for (let i = 0; i < value.length; i++) {
-      walk(value[i], schema.items, `${path6}[${i}]`, errors, depth + 1);
+  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 coerceAgainstSchema(value, schema) {
-  return coerceWalk(value, schema, 0);
+function estimateToolDefTokens(tool) {
+  const cached2 = tool._estDefTokens;
+  if (typeof cached2 === "number" && cached2 > 0) return cached2;
+  const compact = compactToolDefinitionForWire(tool);
+  return RoughTokenEstimate(tool.name) + RoughTokenEstimate(compact.description) + RoughTokenEstimate(JSON.stringify(compact.inputSchema));
 }
-function coerceWalk(value, schema, depth) {
-  if (depth > MAX_SCHEMA_DEPTH) return { value, changed: false };
-  const type = typeof schema.type === "string" ? schema.type : void 0;
-  if (type && !checkType(value, type)) {
-    if (type === "string" && (typeof value === "number" || typeof value === "boolean")) {
-      return { value: String(value), changed: true };
-    }
-    if ((type === "number" || type === "integer") && typeof value === "string") {
-      const trimmed = value.trim();
-      if (trimmed !== "" && /^-?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/.test(trimmed)) {
-        const num = Number(trimmed);
-        if (!Number.isNaN(num) && (type === "number" || Number.isInteger(num))) {
-          return { value: num, changed: true };
+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 cached2 = m._estTokens;
+        if (typeof cached2 === "number" && cached2 > 0) {
+          messagesTokens += cached2;
+          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));
+              }
+            }
+          }
         }
       }
-      return { value, changed: false };
-    }
-    if (type === "boolean" && typeof value === "string") {
-      const lowered = value.trim().toLowerCase();
-      if (lowered === "true") return { value: true, changed: true };
-      if (lowered === "false") return { value: false, changed: true };
-      return { value, changed: false };
     }
-    if ((type === "object" || type === "array") && typeof value === "string") {
-      try {
-        const parsed = JSON.parse(value);
-        if (checkType(parsed, type)) {
-          return { value: coerceWalk(parsed, schema, depth + 1).value, changed: true };
-        }
-      } catch {
+  }
+  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);
       }
-      return { value, changed: false };
     }
-    return { value, changed: false };
   }
-  if (type === "object" && isPlainObject(value) && schema.properties) {
-    const obj = value;
-    let changed = false;
-    const out = { ...obj };
-    for (const [key, subSchema] of Object.entries(schema.properties)) {
-      if (!(key in obj)) continue;
-      const r = coerceWalk(obj[key], subSchema, depth + 1);
-      if (r.changed) {
-        out[key] = r.value;
-        changed = true;
-      }
-    }
-    return changed ? { value: out, changed } : { value, changed: false };
-  }
-  if (type === "array" && Array.isArray(value) && schema.items) {
-    let changed = false;
-    const out = value.map((item) => {
-      const r = coerceWalk(item, schema.items, depth + 1);
-      if (r.changed) changed = true;
-      return r.value;
-    });
-    return changed ? { value: out, changed } : { value, changed: false };
+  let toolsTokens = 0;
+  for (const t of tools) {
+    toolsTokens += estimateToolDefTokens(t);
   }
-  return { value, changed: false };
+  const total = messagesTokens + systemTokens + toolsTokens;
+  calState(calibrationKey).prevEst = total;
+  return {
+    messages: messagesTokens,
+    systemPrompt: systemTokens,
+    tools: toolsTokens,
+    total
+  };
 }
-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 recordActualUsage(actualInputTokens, estimatedInputTokens, calibrationKey = CALIBRATION_GLOBAL_KEY) {
+  if (actualInputTokens <= 0) return;
+  const cal = calState(calibrationKey);
+  const est = estimatedInputTokens ?? cal.prevEst;
+  if (est <= 0) return;
+  const sampleRatio = actualInputTokens / est;
+  if (cal.count === 0) {
+    cal.ratio = sampleRatio;
+  } else {
+    cal.ratio = CAL_ALPHA * sampleRatio + (1 - CAL_ALPHA) * cal.ratio;
   }
+  cal.ratio = Math.min(1.5, Math.max(0.5, cal.ratio));
+  cal.count++;
 }
-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 getCalibrationState(calibrationKey = CALIBRATION_GLOBAL_KEY) {
+  const cal = calState(calibrationKey);
+  return {
+    ratio: cal.ratio,
+    count: cal.count,
+    calibrated: cal.count >= MIN_SAMPLES_FOR_CALIBRATION
+  };
 }
-function previewValue(v) {
-  try {
-    const s = JSON.stringify(v);
-    if (s === void 0) return String(v);
-    return s.length > 80 ? `${s.slice(0, 80)}\u2026` : s;
-  } catch {
-    return String(v);
+function estimateRequestTokensCalibrated(messages, systemPrompt, tools, calibrationKey = CALIBRATION_GLOBAL_KEY) {
+  const result = estimateRequestTokens(messages, systemPrompt, tools, calibrationKey);
+  const cal = calState(calibrationKey);
+  if (cal.count >= MIN_SAMPLES_FOR_CALIBRATION) {
+    const safeRatio = Math.min(1.5, Math.max(0.5, cal.ratio));
+    return {
+      messages: Math.round(result.messages * safeRatio),
+      systemPrompt: Math.round(result.systemPrompt * safeRatio),
+      tools: Math.round(result.tools * safeRatio),
+      total: Math.round(result.total * safeRatio)
+    };
   }
+  const fallbackRatio = getModelFamilyRatio(calibrationKey);
+  if (fallbackRatio !== null) {
+    return {
+      messages: Math.round(result.messages * fallbackRatio),
+      systemPrompt: Math.round(result.systemPrompt * fallbackRatio),
+      tools: Math.round(result.tools * fallbackRatio),
+      total: Math.round(result.total * fallbackRatio)
+    };
+  }
+  return result;
 }
-function joinPath(parent, key) {
-  if (!parent) return key;
-  return `${parent}.${key}`;
-}
-function enumIncludes(values, value) {
-  if (value === null || typeof value !== "object") return values.includes(value);
-  return values.some((candidate) => deepEqual(candidate, value));
-}
-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]));
+function getModelFamilyRatio(calibrationKey) {
+  const lower = calibrationKey.toLowerCase();
+  for (const [family, ratio] of Object.entries(MODEL_FAMILY_RATIO)) {
+    if (lower.includes(family)) return ratio / 3.5;
   }
-  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 null;
+}
+function resetCalibration(calibrationKey) {
+  if (calibrationKey === void 0) {
+    _cals.clear();
+    return;
   }
-  return false;
+  _cals.delete(calibrationKey);
 }
 
-// src/utils/merge-custom-models.ts
-function mergeCustomModelDefs(providerCustomModels, configModels) {
+// src/utils/context-breakdown.ts
+var SYSTEM_BLOCK_SOURCES = [
+  "identity",
+  "tool-usage",
+  "environment",
+  "skills",
+  "mode",
+  "plan",
+  "leader-after-task",
+  "contributor",
+  "ledger",
+  "nextsteps",
+  "other"
+];
+function emptyBySource() {
   const out = {};
-  if (providerCustomModels) {
-    for (const [id, def] of Object.entries(providerCustomModels)) {
-      out[id] = { ...def };
+  for (const key of SYSTEM_BLOCK_SOURCES) out[key] = 0;
+  return out;
+}
+function isMcpTool(tool) {
+  return (tool.capabilities?.includes("mcp.proxy") ?? false) || tool.name.startsWith("mcp__");
+}
+function mcpServerOf(tool) {
+  const parts = tool.name.split("__");
+  return parts.length >= 3 && parts[0] === "mcp" ? parts[1] ?? "mcp" : "mcp";
+}
+function safeBuild(fn, warn = () => {
+}) {
+  try {
+    return fn();
+  } catch (e) {
+    warn(e);
+    return void 0;
+  }
+}
+function resolveEffectiveMaxContext(ctx) {
+  const metaLimit = ctx.meta?.["effectiveMaxContext"];
+  const providerMax = ctx.provider.capabilities.maxContext;
+  return typeof metaLimit === "number" && metaLimit > 0 ? metaLimit : typeof providerMax === "number" && providerMax > 0 ? providerMax : 2e5;
+}
+function getContextBreakdown(ctx) {
+  const bySource = emptyBySource();
+  let systemTotal = 0;
+  for (const block of ctx.systemPrompt) {
+    const tokens = estimateTextTokens(block.text);
+    systemTotal += tokens;
+    bySource[SYSTEM_BLOCK_SOURCE.get(block) ?? "other"] += tokens;
+  }
+  let toolsBuiltin = 0;
+  let toolsMcp = 0;
+  const mcpByServer = {};
+  for (const tool of ctx.tools) {
+    const tokens = estimateToolDefTokens(tool);
+    if (isMcpTool(tool)) {
+      toolsMcp += tokens;
+      const server = mcpServerOf(tool);
+      mcpByServer[server] = (mcpByServer[server] ?? 0) + tokens;
+    } else {
+      toolsBuiltin += tokens;
     }
   }
-  if (configModels) {
-    for (const [id, def] of Object.entries(configModels)) {
-      out[id] = { ...def };
+  let histText = 0;
+  let histToolResults = 0;
+  for (const msg of ctx.messages) {
+    if (typeof msg.content === "string") {
+      histText += estimateTextTokens(msg.content);
+      continue;
+    }
+    for (const b of msg.content) {
+      switch (b.type) {
+        case "text":
+          histText += estimateTextTokens(b.text);
+          break;
+        case "tool_use":
+          histText += estimateToolInputTokens(b.input);
+          break;
+        case "tool_result":
+          histToolResults += estimateToolResultTokens(b.content);
+          break;
+        case "thinking":
+          histText += estimateTextTokens(b.thinking);
+          break;
+        default:
+          histText += estimateTextTokens(JSON.stringify(b));
+      }
     }
   }
-  if (Object.keys(out).length === 0) return void 0;
-  return out;
+  const warnings = [];
+  const warn = (e) => {
+    const msg = e instanceof Error ? e.message : String(e);
+    warnings.push(msg);
+  };
+  const ledgerBlock = safeBuild(() => buildCompletedWorkLedgerBlock(ctx), warn);
+  const nextstepsBlock = safeBuild(() => buildLiveNextStepsGateBlock(ctx), warn);
+  const ledger = ledgerBlock ? estimateTextTokens(ledgerBlock.text) : 0;
+  const nextsteps = nextstepsBlock ? estimateTextTokens(nextstepsBlock.text) : 0;
+  const toolsTotal = toolsBuiltin + toolsMcp;
+  const historyTotal = histText + histToolResults;
+  const volatileTotal = ledger + nextsteps;
+  const total = systemTotal + toolsTotal + historyTotal + volatileTotal;
+  const effectiveMaxContext = resolveEffectiveMaxContext(ctx);
+  return {
+    system: { total: systemTotal, bySource },
+    tools: {
+      total: toolsTotal,
+      builtin: toolsBuiltin,
+      mcp: toolsMcp,
+      count: ctx.tools.length,
+      mcpByServer
+    },
+    history: {
+      total: historyTotal,
+      text: histText,
+      toolResults: histToolResults,
+      messageCount: ctx.messages.length
+    },
+    volatile: { ledger, nextsteps, total: volatileTotal },
+    total,
+    effectiveMaxContext,
+    usedPct: effectiveMaxContext > 0 ? total / effectiveMaxContext : 0,
+    warnings
+  };
 }
 
-// src/utils/merge-models-payload.ts
-function mergeModelsPayload(base, overlay) {
-  const out = {};
-  for (const [id, provider] of Object.entries(base)) {
-    out[id] = cloneProvider(provider);
-  }
-  for (const [id, ovProvider] of Object.entries(overlay)) {
-    const existing = out[id];
-    out[id] = existing ? mergeProvider(existing, ovProvider) : cloneProvider(ovProvider);
-  }
-  return out;
+// src/utils/deep-merge.ts
+var FORBIDDEN_PROTO_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype",
+  "__defineGetter__",
+  "__defineSetter__",
+  "__lookupGetter__",
+  "__lookupSetter__"
+]);
+function isPrimitiveArray(a) {
+  return a.every((v) => v === null || typeof v !== "object" && typeof v !== "function");
 }
-function mergeProvider(base, overlay) {
-  const models = {};
-  for (const [mid, m] of Object.entries(base.models ?? {})) {
-    models[mid] = { ...m };
+function deepMerge(base, patch, options = {}) {
+  const {
+    conflictResolution = "prefer-patch",
+    arrayMode = "replace",
+    protectProto = true,
+    onNonPrimitiveArrayReplace
+  } = options;
+  if (typeof base !== "object" || base === null) {
+    return conflictResolution === "prefer-patch" ? patch : base;
   }
-  for (const [mid, ovModel] of Object.entries(overlay.models ?? {})) {
-    const existing = models[mid];
-    models[mid] = existing ? mergeModel(existing, ovModel) : { ...ovModel };
+  if (typeof patch !== "object" || patch === null) {
+    return conflictResolution === "prefer-patch" ? patch : base;
   }
-  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
-    }),
-    models
-  };
-}
-function mergeModel(base, overlay) {
-  const merged = { ...base, ...overlay };
-  if (base.limit || overlay.limit) {
-    merged.limit = { ...base.limit, ...overlay.limit };
+  if (Array.isArray(base) && Array.isArray(patch)) {
+    if (arrayMode === "concat-primitives" && isPrimitiveArray(base) && isPrimitiveArray(patch)) {
+      return [.../* @__PURE__ */ new Set([...base, ...patch])];
+    }
+    return conflictResolution === "prefer-patch" ? patch : base;
   }
-  if (base.cost || overlay.cost) {
-    merged.cost = { ...base.cost, ...overlay.cost };
+  if (Array.isArray(base) || Array.isArray(patch)) {
+    return conflictResolution === "prefer-patch" ? patch : base;
   }
-  if (base.modalities || overlay.modalities) {
-    merged.modalities = { ...base.modalities, ...overlay.modalities };
+  const baseObj = base;
+  const patchObj = patch;
+  const out = { ...baseObj };
+  for (const [k, v] of Object.entries(patchObj)) {
+    if (protectProto && FORBIDDEN_PROTO_KEYS.has(k)) continue;
+    const existing = out[k];
+    if (v !== null && typeof v === "object" && !Array.isArray(v) && existing !== null && typeof existing === "object" && !Array.isArray(existing)) {
+      out[k] = deepMerge(existing, v, options);
+    } else if (Array.isArray(v) && Array.isArray(existing)) {
+      if (onNonPrimitiveArrayReplace && !isPrimitiveArray(v)) {
+        onNonPrimitiveArrayReplace(k, existing.length, v.length);
+      }
+      out[k] = deepMerge(existing, v, options);
+    } else if (v !== void 0) {
+      if (onNonPrimitiveArrayReplace && Array.isArray(v) && !isPrimitiveArray(v)) {
+        const existingLen = Array.isArray(existing) ? existing.length : 0;
+        onNonPrimitiveArrayReplace(k, existingLen, v.length);
+      }
+      out[k] = v;
+    }
   }
-  return merged;
+  return out;
 }
-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;
+
+// src/utils/diff.ts
+function myersDiff(a, b) {
+  const N = a.length;
+  const M = b.length;
+  const max = N + M;
+  if (max === 0) return [];
+  const v = /* @__PURE__ */ new Map();
+  v.set(1, 0);
+  const trace = [];
+  for (let d = 0; d <= max; d++) {
+    const snapshot = new Map(v);
+    trace.push(snapshot);
+    for (let k = -d; k <= d; k += 2) {
+      const left = v.get(k - 1) ?? -1;
+      const right = v.get(k + 1) ?? -1;
+      let x;
+      if (k === -d || k !== d && left < right) {
+        x = right;
+      } else {
+        x = left + 1;
+      }
+      let y = x - k;
+      while (x < N && y < M && a[x] === b[y]) {
+        x++;
+        y++;
+      }
+      v.set(k, x);
+      if (x >= N && y >= M) {
+        return backtrack(trace, a, b, N, M, d);
+      }
+    }
   }
-  return out;
+  return [];
 }
-
-// src/utils/message-invariants.ts
-function repairToolUseAdjacency(messages) {
-  const removedToolUses = [];
-  const removedToolResults = [];
-  let removedMessages = 0;
-  let changed = false;
-  const out = [];
-  for (let i = 0; i < messages.length; i++) {
-    const original = expectDefined(messages[i]);
-    let msg = original;
-    if (hasToolUse(msg)) {
-      const nextIds = toolResultIds(messages[i + 1]);
-      const filtered = mapContent(msg, (blocks) => {
-        const next = [];
-        for (const block of blocks) {
-          if (block.type === "tool_use" && !nextIds.has(block.id)) {
-            removedToolUses.push(block.id);
-            changed = true;
-            continue;
-          }
-          next.push(block);
-        }
-        return next;
-      });
-      msg = filtered ?? msg;
+function backtrack(trace, a, b, N, M, finalD) {
+  const edits = [];
+  let x = N;
+  let y = M;
+  for (let d = finalD; d > 0; d--) {
+    const v = trace[d];
+    if (!v) break;
+    const k = x - y;
+    const left = v.get(k - 1) ?? -1;
+    const right = v.get(k + 1) ?? -1;
+    let prevK;
+    if (k === -d || k !== d && left < right) {
+      prevK = k + 1;
+    } else {
+      prevK = k - 1;
     }
-    if (hasToolResult(msg)) {
-      const allowed = toolUseIds(out[out.length - 1]);
-      const filtered = mapContent(msg, (blocks) => {
-        const next = [];
-        for (const block of blocks) {
-          if (block.type === "tool_result" && !allowed.has(block.tool_use_id)) {
-            removedToolResults.push(block.tool_use_id);
-            changed = true;
-            continue;
-          }
-          next.push(block);
-        }
-        return next;
-      });
-      msg = filtered ?? msg;
+    const prevX = v.get(prevK) ?? 0;
+    const prevY = prevX - prevK;
+    while (x > prevX && y > prevY) {
+      edits.push({ op: "equal", a: x - 1, b: y - 1, line: a[x - 1] ?? "" });
+      x--;
+      y--;
     }
-    if (isEmptyMessage(msg)) {
-      removedMessages++;
-      changed = true;
-      continue;
+    if (d > 0) {
+      if (x === prevX) {
+        edits.push({ op: "insert", a: x, b: y - 1, line: b[y - 1] ?? "" });
+      } else {
+        edits.push({ op: "delete", a: x - 1, b: y, line: a[x - 1] ?? "" });
+      }
+      x = prevX;
+      y = prevY;
     }
-    out.push(msg);
   }
-  return {
-    messages: changed ? out : messages,
-    report: { changed, removedToolUses, removedToolResults, removedMessages }
-  };
-}
-function hasToolUse(msg) {
-  return contentBlocks(msg).some((b) => b.type === "tool_use");
-}
-function hasToolResult(msg) {
-  return contentBlocks(msg).some((b) => b.type === "tool_result");
-}
-function toolUseIds(msg) {
-  const ids = /* @__PURE__ */ new Set();
-  if (msg?.role !== "assistant") return ids;
-  for (const block of contentBlocks(msg)) {
-    if (block.type === "tool_use") ids.add(block.id);
+  while (x > 0 && y > 0) {
+    edits.push({ op: "equal", a: x - 1, b: y - 1, line: a[x - 1] ?? "" });
+    x--;
+    y--;
   }
-  return ids;
+  return edits.reverse();
 }
-function toolResultIds(msg) {
-  const ids = /* @__PURE__ */ new Set();
-  if (msg?.role !== "user") return ids;
-  for (const block of contentBlocks(msg)) {
-    if (block.type === "tool_result") ids.add(block.tool_use_id);
+function unifiedDiff(oldText, newText, opts = {}) {
+  const context = opts.context ?? 3;
+  const a = oldText.split("\n");
+  const b = newText.split("\n");
+  if (a[a.length - 1] === "") a.pop();
+  if (b[b.length - 1] === "") b.pop();
+  const edits = myersDiff(a, b);
+  if (edits.every((e) => e.op === "equal")) return "";
+  const hunks = [];
+  let i = 0;
+  while (i < edits.length) {
+    while (i < edits.length && edits[i]?.op === "equal") i++;
+    if (i >= edits.length) break;
+    const hunkStart = Math.max(0, i - context);
+    const lines = [];
+    let aStart = (edits[hunkStart]?.a ?? 0) + 1;
+    let bStart = (edits[hunkStart]?.b ?? 0) + 1;
+    let aCount = 0;
+    let bCount = 0;
+    let cursor = hunkStart;
+    let trailing = 0;
+    while (cursor < edits.length) {
+      const e = edits[cursor];
+      if (!e) break;
+      if (e.op === "equal") {
+        trailing++;
+        if (trailing > context * 2) break;
+      } else {
+        trailing = 0;
+      }
+      if (e.op === "equal") {
+        lines.push(` ${e.line}`);
+        aCount++;
+        bCount++;
+      } else if (e.op === "delete") {
+        lines.push(`-${e.line}`);
+        aCount++;
+      } else {
+        lines.push(`+${e.line}`);
+        bCount++;
+      }
+      cursor++;
+    }
+    while (lines.length > 0 && lines[lines.length - 1]?.startsWith(" ") && trailing > context) {
+      lines.pop();
+      aCount--;
+      bCount--;
+      trailing--;
+    }
+    if (aCount === 0) aStart = 0;
+    if (bCount === 0) bStart = 0;
+    hunks.push({ aStart, bStart, lines });
+    i = cursor;
   }
-  return ids;
-}
-function contentBlocks(msg) {
-  return msg && Array.isArray(msg.content) ? msg.content : [];
-}
-function mapContent(msg, fn) {
-  if (!Array.isArray(msg.content)) return msg;
-  const next = fn(msg.content);
-  if (next.length === msg.content.length && next.every((b, idx) => b === msg.content[idx])) {
-    return msg;
+  if (hunks.length === 0) return "";
+  let out = "";
+  out += `--- ${opts.fromFile ?? "a"}
+`;
+  out += `+++ ${opts.toFile ?? "b"}
+`;
+  for (const h of hunks) {
+    let aCount = 0;
+    let bCount = 0;
+    for (const l of h.lines) {
+      if (l.startsWith(" ")) {
+        aCount++;
+        bCount++;
+      } else if (l.startsWith("-")) aCount++;
+      else if (l.startsWith("+")) bCount++;
+    }
+    out += `@@ -${h.aStart},${aCount} +${h.bStart},${bCount} @@
+`;
+    out += `${h.lines.join("\n")}
+`;
   }
-  return { ...msg, content: next };
+  return out;
 }
-function hasMeaningfulContent(content) {
-  if (typeof content === "string") return content.trim().length > 0;
-  for (const block of content) {
-    if (block.type === "text") {
-      if (block.text.trim().length > 0) return true;
-      continue;
-    }
-    if (block.type === "thinking") {
-      if (block.thinking.trim().length > 0 || block.signature) return true;
-      continue;
-    }
-    return true;
+
+// src/utils/glob-expand.ts
+import * as fsp from "node:fs/promises";
+import { isAbsolute as isAbsolute2, resolve as resolve2 } from "node:path";
+var GLOB_CHARS = /* @__PURE__ */ new Set(["*", "?", "["]);
+var IS_WINDOWS = process.platform === "win32";
+var SEP = IS_WINDOWS ? "\\" : "/";
+function isGlob(p) {
+  for (const c of p) {
+    if (GLOB_CHARS.has(c)) return true;
   }
   return false;
 }
-function isEmptyMessage(msg) {
-  return !hasMeaningfulContent(msg.content);
-}
-
-// src/utils/newline-normalize.ts
-function detectNewlineStyle(text) {
-  let lf = 0;
-  let crlf = 0;
-  let cr = 0;
-  for (let i = 0; i < text.length; i++) {
-    const c = text.charCodeAt(i);
-    if (c === 13) {
-      if (text.charCodeAt(i + 1) === 10) {
-        crlf++;
-        i++;
+function globToRegex(pat) {
+  let i = 0;
+  let re = "^";
+  while (i < pat.length) {
+    const c = expectDefined(pat[i]);
+    if (c === "*") {
+      if (pat[i + 1] === "*") {
+        re += ".*";
+        i += 2;
+        if (pat[i] === "/") i++;
       } else {
-        cr++;
+        re += "[^/\\\\]*";
+        i++;
       }
-    } else if (c === 10) {
-      lf++;
+    } else if (c === "?") {
+      re += "[^/\\\\]";
+      i++;
+    } else if (c === "[") {
+      let cls = "[";
+      i++;
+      if (pat[i] === "!" || pat[i] === "^") {
+        cls += "^";
+        i++;
+      }
+      while (i < pat.length && pat[i] !== "]") {
+        const ch = pat[i] ?? "";
+        if (ch === "\\") cls += "\\\\";
+        else if (ch === "]" || ch === "^") cls += `\\${ch}`;
+        else cls += ch;
+        i++;
+      }
+      cls += "]";
+      re += cls;
+      i++;
+    } else {
+      re += c.replace(/[.+^${}()|\\]/g, "\\$&");
+      i++;
     }
   }
-  if (crlf > lf && crlf > cr) return "crlf";
-  if (cr > lf && cr > crlf) return "cr";
-  return "lf";
-}
-function toStyle(text, style) {
-  const normalized = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-  if (style === "lf") return normalized;
-  if (style === "crlf") return normalized.replace(/\n/g, "\r\n");
-  return normalized.replace(/\n/g, "\r");
-}
-function normalizeToLf(text) {
-  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  return new RegExp(re + "$");
 }
-
-// src/utils/regex-guard.ts
-var MAX_PATTERN_LEN = 512;
-var DANGEROUS_PATTERNS = [
-  /(\([^)]*[+*][^)]*\))[+*]/,
-  // (a+)+, (.*)+, etc
-  /(\(\?:[^)]*[+*][^)]*\))[+*]/
-  // same, with non-capturing group
-];
-function compileUserRegex(pattern, flags) {
-  if (typeof pattern !== "string") {
-    return { ok: false, reason: "pattern must be a string" };
-  }
-  if (pattern.length === 0) {
-    return { ok: false, reason: "pattern is empty" };
-  }
-  if (pattern.length > MAX_PATTERN_LEN) {
-    return { ok: false, reason: `pattern exceeds ${MAX_PATTERN_LEN} characters` };
-  }
-  for (const rx of DANGEROUS_PATTERNS) {
-    if (rx.test(pattern)) {
-      return {
-        ok: false,
-        reason: "pattern looks vulnerable to catastrophic backtracking \u2014 rewrite without nested quantifiers"
-      };
+function baseDir(pat) {
+  let firstGlob = pat.length;
+  for (let i = 0; i < pat.length; i++) {
+    if (GLOB_CHARS.has(expectDefined(pat[i]))) {
+      firstGlob = i;
+      break;
     }
   }
-  try {
-    return { ok: true, regex: new RegExp(pattern, flags) };
-  } catch (err) {
-    return {
-      ok: false,
-      reason: err instanceof Error ? err.message : "invalid regex"
-    };
+  const cut = Math.max(
+    pat.lastIndexOf(SEP, firstGlob - 1),
+    pat.lastIndexOf("/", firstGlob - 1)
+  );
+  return cut < 0 ? "." : pat.slice(0, cut);
+}
+async function expandGlob(pattern) {
+  if (!isGlob(pattern)) return [pattern];
+  const results = /* @__PURE__ */ new Set();
+  const abs = isAbsolute2(pattern);
+  const base = abs ? baseDir(pattern) : baseDir(pattern);
+  const relPat = base === "." ? pattern : pattern.slice(base.length + 1);
+  async function walk2(dir, pat) {
+    let entries;
+    try {
+      entries = await fsp.readdir(dir);
+    } catch {
+      return;
+    }
+    const firstGlob = pat.search(/[*?[[]/);
+    if (firstGlob < 0) {
+      const re = globToRegex(pat);
+      for (const e of entries) {
+        if (re.test(e)) {
+          const full = `${dir}${SEP}${e}`;
+          results.add(abs ? resolve2(full) : full);
+        }
+      }
+      return;
+    }
+    const before = pat.slice(0, firstGlob);
+    const rest = pat.slice(firstGlob);
+    if (before.endsWith("**")) {
+      await walk2(dir, rest);
+      for (const e of entries) {
+        const full = `${dir}${SEP}${e}`;
+        try {
+          const stat3 = await fsp.stat(full);
+          if (stat3.isDirectory()) await walk2(full, rest);
+        } catch {
+        }
+      }
+    } else if (before === "") {
+      const re = globToRegex(rest);
+      for (const e of entries) {
+        if (re.test(e)) {
+          const full = `${dir}${SEP}${e}`;
+          results.add(abs ? resolve2(full) : full);
+        }
+      }
+    } else {
+      const seg = before.replace(/[*?[\]]/g, "").replace(/\/$/, "");
+      if (entries.includes(seg)) {
+        const full = `${dir}${SEP}${seg}`;
+        try {
+          const stat3 = await fsp.stat(full);
+          if (stat3.isDirectory()) await walk2(full, rest);
+        } catch {
+        }
+      }
+    }
   }
+  await walk2(base === "." ? "." : base, relPat);
+  return [...results];
 }
 
-// src/utils/safe-json.ts
-function safeParse(input, maxBytes = 5e6) {
-  if (Buffer.byteLength(input, "utf8") > maxBytes) {
-    return { ok: false, error: `Input exceeds limit (${maxBytes} bytes)` };
-  }
-  try {
-    return { ok: true, value: JSON.parse(input) };
-  } catch (err) {
-    return {
-      ok: false,
-      error: toErrorMessage(err)
-    };
-  }
+// src/utils/glob-match.ts
+function escapeRegex(s) {
+  return s.replace(/[.+^${}()|\\]/g, "\\$&");
 }
-function safeStringify(value, pretty = false) {
-  const seen = /* @__PURE__ */ new WeakSet();
-  const replacer = (_k, v) => {
-    if (typeof v === "bigint") return v.toString();
-    if (v instanceof Error) {
-      return { name: v.name, message: v.message, stack: v.stack };
-    }
-    if (typeof v === "object" && v !== null) {
-      if (seen.has(v)) return "[Circular]";
-      seen.add(v);
+var COMPILED_GLOB_CACHE = /* @__PURE__ */ new Map();
+var CACHE_MAX_SIZE = 2e3;
+var NEVER_MATCH = /[^\s\S]/;
+function getCachedGlob(pattern) {
+  const cached2 = COMPILED_GLOB_CACHE.get(pattern);
+  if (cached2) return cached2;
+  if (COMPILED_GLOB_CACHE.size >= CACHE_MAX_SIZE) {
+    const keys = [...COMPILED_GLOB_CACHE.keys()];
+    for (let i = 0; i < Math.floor(CACHE_MAX_SIZE / 4); i++) {
+      COMPILED_GLOB_CACHE.delete(expectDefined(keys[i]));
     }
-    return v;
-  };
-  try {
-    return JSON.stringify(value, replacer, pretty ? 2 : void 0) ?? "null";
-  } catch (err) {
-    return JSON.stringify({
-      __serialization_error: toErrorMessage(err)
-    });
   }
-}
-function sanitizeJsonString(s) {
-  let out = s.trim();
-  out = stripJsonComments(out);
-  out = out.replace(/,(\s*[}\]])/g, "$1");
-  out = escapeControlCharsInStrings(out);
+  let re;
   try {
-    JSON.parse(out);
-    return out;
+    re = compileGlob(pattern);
   } catch {
-    return null;
+    re = NEVER_MATCH;
   }
+  COMPILED_GLOB_CACHE.set(pattern, re);
+  return re;
 }
-function stripCodeFences(s) {
-  const trimmed = s.trim();
-  const opener = /^```[\w+-]*[ \t]*\r?\n?/.exec(trimmed);
-  if (opener) {
-    const inner = trimmed.slice(opener[0].length).replace(/(\r?\n)?[ \t]*```[ \t]*$/, "");
-    return inner.trim();
+var MAX_GLOB_PATTERN_LEN = 1024;
+function compileGlob(pattern) {
+  if (pattern.length > MAX_GLOB_PATTERN_LEN) {
+    throw new Error(`Glob pattern exceeds ${MAX_GLOB_PATTERN_LEN} characters`);
   }
-  const embedded = /```[\w+-]*[ \t]*\r?\n([\s\S]*?)\r?\n[ \t]*```/.exec(trimmed);
-  if (embedded) return (embedded[1] ?? "").trim();
-  return null;
-}
-function escapeControlCharsInStrings(s) {
-  let inString = false;
-  let out = "";
-  for (let i = 0; i < s.length; i++) {
-    const c = s.charAt(i);
-    if (c === '"' && (i === 0 || s[i - 1] !== "\\")) {
-      inString = !inString;
-      out += c;
-      continue;
-    }
-    const code = c.charCodeAt(0);
-    if (inString && code < 32) {
-      switch (c) {
-        case "\n":
-          out += "\\n";
-          break;
-        case "\r":
-          out += "\\r";
-          break;
-        case "	":
-          out += "\\t";
-          break;
-        case "\b":
-          out += "\\b";
-          break;
-        case "\f":
-          out += "\\f";
-          break;
-        default:
-          out += `\\u${code.toString(16).padStart(4, "0")}`;
-      }
-      continue;
-    }
-    out += c;
-  }
-  return out;
-}
-function stripJsonComments(s) {
-  let inString = false;
-  let escaped = false;
-  const chars = [];
   let i = 0;
-  while (i < s.length) {
-    const c = s.charAt(i);
-    if (inString) {
-      chars.push(c);
-      if (escaped) {
-        escaped = false;
-      } else if (c === "\\") {
-        escaped = true;
-      } else if (c === '"') {
-        inString = false;
+  let re = "^";
+  while (i < pattern.length) {
+    const c = pattern[i];
+    if (c === "*") {
+      if (pattern[i + 1] === "*") {
+        re += ".*";
+        i += 2;
+        if (pattern[i] === "/") i++;
+      } else {
+        re += "[^/]*";
+        i++;
       }
+    } else if (c === "?") {
+      re += "[^/]";
       i++;
-      continue;
-    }
-    if (c === '"') {
-      inString = true;
-      chars.push(c);
+    } else if (c === "[") {
+      let cls = "[";
       i++;
-      continue;
-    }
-    if (c === "/" && s.charAt(i + 1) === "/") {
-      while (i < s.length && s.charAt(i) !== "\n") i++;
-      continue;
-    }
-    if (c === "/" && s.charAt(i + 1) === "*") {
-      const end = s.indexOf("*/", i + 2);
-      if (end === -1) {
-        chars.push(s.slice(i));
-        break;
+      if (pattern[i] === "!" || pattern[i] === "^") {
+        cls += "^";
+        i++;
       }
-      i = end + 2;
-      continue;
+      while (i < pattern.length && pattern[i] !== "]") {
+        const ch = pattern[i] ?? "";
+        if (ch === "\\") {
+          cls += "\\\\";
+        } else if (ch === "]" || ch === "^") {
+          cls += `\\${ch}`;
+        } else {
+          cls += ch;
+        }
+        i++;
+      }
+      cls += "]";
+      re += cls;
+      i++;
+    } else {
+      re += escapeRegex(c ?? "");
+      i++;
     }
-    chars.push(c);
-    i++;
   }
-  return chars.join("");
+  re += "$";
+  return new RegExp(re);
 }
-
-// src/utils/session-scoped-path.ts
-import * as path4 from "node:path";
-function sessionScopedPath(dir, sessionId, suffix) {
-  if (!sessionId || sessionId.includes("\\") || sessionId.includes("..")) {
-    throw invalid(sessionId);
-  }
-  const resolved = path4.resolve(dir, `${sessionId}${suffix}`);
-  const rel = path4.relative(path4.resolve(dir), resolved);
-  if (rel.startsWith("..") || path4.isAbsolute(rel)) {
-    throw invalid(sessionId);
-  }
-  return resolved;
+function matchGlob(pattern, input) {
+  return getCachedGlob(pattern).test(input);
 }
-function invalid(sessionId) {
-  return new FsError({
-    message: `Invalid sessionId: ${sessionId}`,
-    code: ERROR_CODES.FS_DELETE_FAILED,
-    path: sessionId,
-    context: { reason: "path_traversal" }
-  });
+function matchAny(patterns, input) {
+  return patterns.some((p) => matchGlob(p, input));
 }
 
-// src/utils/sleep.ts
-function sleep(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+// src/utils/incoming-images.ts
+var MAX_INCOMING_IMAGES = 8;
+var MAX_INCOMING_IMAGE_BYTES = 8 * 1024 * 1024;
+var ALLOWED_IMAGE_MEDIA_TYPES = /* @__PURE__ */ new Set([
+  "image/png",
+  "image/jpeg",
+  "image/webp",
+  "image/gif"
+]);
+var IncomingImageError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "IncomingImageError";
+  }
+};
+var DATA_URL_RE = /^data:([a-z0-9.+-]+\/[a-z0-9.+-]+)?(?:;[a-z0-9-]+=[^;,]*)*(;base64)?,/i;
+function splitDataUrl(data) {
+  const match = DATA_URL_RE.exec(data);
+  if (!match) return { base64: data.trim() };
+  return {
+    base64: data.slice(match[0].length).trim(),
+    mediaType: match[1]?.toLowerCase()
+  };
 }
-
-// src/utils/slug.ts
-function slugify(name, fallback = "prompt", maxLen = 64) {
-  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, maxLen).replace(/-+$/g, "") || fallback;
+function parseIncomingImages(images, legacyImageBase64) {
+  const raw = [...images ?? []];
+  if (legacyImageBase64) raw.push({ data: legacyImageBase64 });
+  if (raw.length === 0) return [];
+  if (raw.length > MAX_INCOMING_IMAGES) {
+    throw new IncomingImageError(
+      `Too many images: ${raw.length} (max ${MAX_INCOMING_IMAGES} per message).`
+    );
+  }
+  return raw.map((img, i) => {
+    const { base64, mediaType: fromUrl } = splitDataUrl(img.data ?? "");
+    const mediaType = (img.mediaType ?? fromUrl ?? "image/png").toLowerCase();
+    if (!ALLOWED_IMAGE_MEDIA_TYPES.has(mediaType)) {
+      throw new IncomingImageError(
+        `Image ${i + 1}: unsupported media type "${mediaType}" (allowed: ${[...ALLOWED_IMAGE_MEDIA_TYPES].join(", ")}).`
+      );
+    }
+    if (!base64) {
+      throw new IncomingImageError(`Image ${i + 1}: empty image data.`);
+    }
+    if (!/^[A-Za-z0-9+/]+={0,2}$/.test(base64)) {
+      throw new IncomingImageError(`Image ${i + 1}: data is not valid base64.`);
+    }
+    const bytes = Math.floor(base64.length * 3 / 4);
+    if (bytes > MAX_INCOMING_IMAGE_BYTES) {
+      throw new IncomingImageError(
+        `Image ${i + 1}: ${(bytes / (1024 * 1024)).toFixed(1)} MB exceeds the ${MAX_INCOMING_IMAGE_BYTES / (1024 * 1024)} MB limit.`
+      );
+    }
+    return {
+      type: "image",
+      source: { type: "base64", media_type: mediaType, data: base64 }
+    };
+  });
 }
-
-// src/utils/string.ts
-function truncate(s, max) {
-  return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
+function buildUserContentBlocks(text, images) {
+  const blocks = [...images];
+  if (text) blocks.push({ type: "text", text });
+  return blocks;
 }
 
-// src/utils/task-format.ts
-function computeTaskItemProgress(tasks) {
-  let completed = 0;
-  let pending = 0;
-  let inProgress = 0;
-  let blocked = 0;
-  let failed = 0;
-  let review = 0;
-  let estimatedHours = 0;
-  const actualHours = 0;
-  for (const t of tasks) {
-    switch (t.status) {
-      case "completed":
-        completed++;
-        break;
-      case "pending":
-        pending++;
-        break;
-      case "in_progress":
-        inProgress++;
-        break;
-      case "blocked":
-        blocked++;
-        break;
-      case "failed":
-        failed++;
-        break;
-      case "review":
-        review++;
-        break;
-    }
-    estimatedHours += t.estimateHours ?? 0;
+// src/utils/ip-guard.ts
+import * as dns from "node:dns/promises";
+import * as net from "node:net";
+function isPrivateIPv4(addr) {
+  const parts = addr.split(".").map((p) => Number.parseInt(p, 10));
+  if (parts.length !== 4 || parts.some((n) => Number.isNaN(n) || n < 0 || n > 255)) {
+    return true;
   }
-  return {
-    total: tasks.length,
-    pending,
-    inProgress,
-    blocked,
-    failed,
-    review,
-    completed,
-    percentComplete: tasks.length > 0 ? Math.round(completed / tasks.length * 100) : 0,
-    estimatedHours,
-    actualHours
-  };
+  const [a, b, c] = parts;
+  if (a === 0) return true;
+  if (a === 10) return true;
+  if (a === 127) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 192 && b === 0 && c === 0) return true;
+  if (a === 100 && b >= 64 && b <= 127) return true;
+  if (a >= 224) return true;
+  return false;
 }
-var STATUS_ICON = {
-  pending: "\u25CB",
-  in_progress: "\u25D0",
-  blocked: "\u2298",
-  failed: "\u2717",
-  review: "\u25D1",
-  completed: "\u25CF"
-};
-var PRIORITY_ICON = {
-  critical: "\u{1F534}",
-  high: "\u{1F7E0}",
-  medium: "\u{1F7E1}",
-  low: "\u{1F7E2}"
-};
-var TYPE_ICON = {
-  feature: "\u26A1",
-  bugfix: "\u{1F41B}",
-  refactor: "\u267B\uFE0F",
-  docs: "\u{1F4DD}",
-  test: "\u{1F9EA}",
-  chore: "\u{1F527}"
-};
-function formatTaskProgress(tasks) {
-  const p = computeTaskItemProgress(tasks);
-  if (p.total === 0) return "No tasks.";
-  const barWidth = 24;
-  const filled = Math.round(p.percentComplete / 100 * barWidth);
-  const empty = barWidth - filled;
-  const bar = "\u2588".repeat(filled) + "\u2591".repeat(empty);
-  return [
-    `${color.bold("Tasks")} [${bar}] ${p.percentComplete}%`,
-    `  ${color.green("\u25CF")} ${p.completed} done \u2502 ${color.yellow("\u25D0")} ${p.inProgress} active \u2502 ${color.dim("\u25CB")} ${p.pending} pending \u2502 \u2298 ${p.blocked} blocked \u2502 \u2717 ${p.failed} failed`,
-    p.estimatedHours > 0 ? `  ${color.dim(`est. ${p.estimatedHours}h`)}` : ""
-  ].filter(Boolean).join("\n");
+function isPrivateIPv6(raw) {
+  const lower = raw.toLowerCase();
+  if (lower === "::" || lower === "::1") return true;
+  const groups = expandIPv6(lower);
+  if (!groups) return true;
+  if (groups[0] === 0 && groups[1] === 0 && groups[2] === 0 && groups[3] === 0 && groups[4] === 0 && groups[5] === 65535) {
+    const a = (groups[6] ?? 0) >> 8;
+    const b = (groups[6] ?? 0) & 255;
+    const c = (groups[7] ?? 0) >> 8;
+    const d = (groups[7] ?? 0) & 255;
+    return isPrivateIPv4(`${a}.${b}.${c}.${d}`);
+  }
+  const high = groups[0] ?? 0;
+  if ((high & 65024) === 64512) return true;
+  if ((high & 65472) === 65152) return true;
+  if ((high & 65280) === 65280) return true;
+  return false;
+}
+function expandIPv6(addr) {
+  const parts = addr.split("::");
+  if (parts.length > 2) return null;
+  const parseGroups = (s) => {
+    if (s === "") return [];
+    const out = [];
+    for (const g of s.split(":")) {
+      if (g.length === 0 || g.length > 4) return null;
+      const n = Number.parseInt(g, 16);
+      if (Number.isNaN(n) || n < 0 || n > 65535) return null;
+      out.push(n);
+    }
+    return out;
+  };
+  if (parts.length === 1) {
+    const groups = parseGroups(parts[0] ?? "");
+    if (groups?.length !== 8) return null;
+    return groups;
+  }
+  const head = parseGroups(parts[0] ?? "");
+  const tail = parseGroups(parts[1] ?? "");
+  if (!head || !tail) return null;
+  const fill = 8 - head.length - tail.length;
+  if (fill < 0) return null;
+  return [...head, ...new Array(fill).fill(0), ...tail];
+}
+async function assertNotPrivateHost(hostname) {
+  const host = hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
+  if (host === "localhost" || host.endsWith(".localhost")) {
+    throw new Error("fetch: blocked localhost target");
+  }
+  const ipVersion = net.isIP(host);
+  if (ipVersion === 4) {
+    if (isPrivateIPv4(host)) {
+      throw new Error(`fetch: blocked private/loopback address "${host}"`);
+    }
+  } else if (ipVersion === 6) {
+    if (isPrivateIPv6(host)) {
+      throw new Error(`fetch: blocked private/loopback address "${host}"`);
+    }
+  } else {
+    try {
+      const records = await dns.lookup(host, { all: true });
+      for (const r of records) {
+        const bad = r.family === 4 ? isPrivateIPv4(r.address) : isPrivateIPv6(r.address);
+        if (bad) {
+          throw new Error(`fetch: resolved to private address ${r.address}`);
+        }
+      }
+    } catch (err) {
+      if (err instanceof Error && err.message.startsWith("fetch:")) throw err;
+    }
+  }
+}
+
+// src/utils/json-repair.ts
+function completePartialObject(s) {
+  if (!s.trim().startsWith("{")) return s;
+  if (tryParse(s).ok) return s;
+  return repairTruncated(s);
+}
+function repairTruncated(s) {
+  const stack = [];
+  let inString = false;
+  let escaped = false;
+  let sawKey = false;
+  let prevSig = "";
+  let contentEnd = 0;
+  let stringBraceDepth = 0;
+  for (let i = 0; i < s.length; i++) {
+    const ch = expectDefined(s[i]);
+    if (inString) {
+      contentEnd = i + 1;
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (ch === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (ch === '"') {
+        inString = false;
+        prevSig = '"';
+        stringBraceDepth = 0;
+        continue;
+      }
+      if (ch === "{") stringBraceDepth++;
+      else if (ch === "}" && stringBraceDepth > 0) stringBraceDepth--;
+      continue;
+    }
+    if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") continue;
+    contentEnd = i + 1;
+    if (ch === '"') {
+      inString = true;
+      sawKey = true;
+      stringBraceDepth = 0;
+      prevSig = '"';
+    } else if (ch === "{" || ch === "[") {
+      stack.push(ch);
+      prevSig = ch;
+    } else if (ch === "}" || ch === "]") {
+      stack.pop();
+      prevSig = ch;
+    } else {
+      prevSig = ch;
+    }
+  }
+  if (!sawKey && !inString) return s;
+  let result = s.slice(0, contentEnd);
+  if (inString) {
+    if (escaped) {
+      result = result.slice(0, -1);
+    } else if (endsWithInvalidEscape(result)) {
+      result = result.slice(0, -2);
+    }
+    if (stringBraceDepth > 0) result += "}".repeat(stringBraceDepth);
+    result += '"';
+  } else if (prevSig === ":") {
+    result += "null";
+  }
+  for (let k = stack.length - 1; k >= 0; k--) {
+    result += stack[k] === "{" ? "}" : "]";
+  }
+  if (!tryParse(result).ok) {
+    const patched = result.replace(/:(\s*)([}\]])/g, ":null$2");
+    if (tryParse(patched).ok) result = patched;
+  }
+  return result;
+}
+var VALID_ESCAPE = /* @__PURE__ */ new Set(['"', "\\", "/", "b", "f", "n", "r", "t", "u"]);
+function endsWithInvalidEscape(str) {
+  const last = str[str.length - 1];
+  if (str[str.length - 2] !== "\\" || last === void 0) return false;
+  if (VALID_ESCAPE.has(last)) return false;
+  let backslashes = 0;
+  for (let k = str.length - 2; k >= 0 && str[k] === "\\"; k--) backslashes++;
+  return backslashes % 2 === 1;
+}
+function tryParse(s) {
+  try {
+    return { ok: true, value: JSON.parse(s) };
+  } catch {
+    return { ok: false };
+  }
+}
+
+// src/utils/json-schema-validate.ts
+function validateAgainstSchema(value, schema) {
+  const errors = [];
+  walk(value, schema, "", errors, 0);
+  return { ok: errors.length === 0, errors };
+}
+var MAX_SCHEMA_DEPTH = 64;
+function walk(value, schema, path6, errors, depth) {
+  if (depth > MAX_SCHEMA_DEPTH) {
+    errors.push({
+      path: path6 || "<root>",
+      message: `schema nesting exceeds maximum depth (${MAX_SCHEMA_DEPTH})`
+    });
+    return;
+  }
+  if (schema.enum !== void 0) {
+    if (!enumIncludes(schema.enum, value)) {
+      errors.push({
+        path: path6 || "<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: path6 || "<root>",
+        message: `expected ${schema.type}, got ${describeType(value)} (${previewValue(value)})`
+      });
+      return;
+    }
+  }
+  if (schema.type === "object" && isPlainObject(value)) {
+    const obj = value;
+    for (const req of schema.required ?? []) {
+      if (!(req in obj)) {
+        const expected = schema.properties?.[req]?.type;
+        errors.push({
+          path: joinPath(path6, req),
+          message: `required property missing${typeof expected === "string" ? ` (expected ${expected})` : ""}`
+        });
+      }
+    }
+    if (schema.properties) {
+      for (const [key, subSchema] of Object.entries(schema.properties)) {
+        if (key in obj) {
+          walk(obj[key], subSchema, joinPath(path6, key), errors, depth + 1);
+        }
+      }
+    }
+  }
+  if (schema.type === "array" && Array.isArray(value) && schema.items) {
+    for (let i = 0; i < value.length; i++) {
+      walk(value[i], schema.items, `${path6}[${i}]`, errors, depth + 1);
+    }
+  }
+}
+function coerceAgainstSchema(value, schema) {
+  return coerceWalk(value, schema, 0);
+}
+function coerceWalk(value, schema, depth) {
+  if (depth > MAX_SCHEMA_DEPTH) return { value, changed: false };
+  const type = typeof schema.type === "string" ? schema.type : void 0;
+  if (type && !checkType(value, type)) {
+    if (type === "string" && (typeof value === "number" || typeof value === "boolean")) {
+      return { value: String(value), changed: true };
+    }
+    if ((type === "number" || type === "integer") && typeof value === "string") {
+      const trimmed = value.trim();
+      if (trimmed !== "" && /^-?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/.test(trimmed)) {
+        const num = Number(trimmed);
+        if (!Number.isNaN(num) && (type === "number" || Number.isInteger(num))) {
+          return { value: num, changed: true };
+        }
+      }
+      return { value, changed: false };
+    }
+    if (type === "boolean" && typeof value === "string") {
+      const lowered = value.trim().toLowerCase();
+      if (lowered === "true") return { value: true, changed: true };
+      if (lowered === "false") return { value: false, changed: true };
+      return { value, changed: false };
+    }
+    if ((type === "object" || type === "array") && typeof value === "string") {
+      try {
+        const parsed = JSON.parse(value);
+        if (checkType(parsed, type)) {
+          return { value: coerceWalk(parsed, schema, depth + 1).value, changed: true };
+        }
+      } catch {
+      }
+      return { value, changed: false };
+    }
+    return { value, changed: false };
+  }
+  if (type === "object" && isPlainObject(value) && schema.properties) {
+    const obj = value;
+    let changed = false;
+    const out = { ...obj };
+    for (const [key, subSchema] of Object.entries(schema.properties)) {
+      if (!(key in obj)) continue;
+      const r = coerceWalk(obj[key], subSchema, depth + 1);
+      if (r.changed) {
+        out[key] = r.value;
+        changed = true;
+      }
+    }
+    return changed ? { value: out, changed } : { value, changed: false };
+  }
+  if (type === "array" && Array.isArray(value) && schema.items) {
+    let changed = false;
+    const out = value.map((item) => {
+      const r = coerceWalk(item, schema.items, depth + 1);
+      if (r.changed) changed = true;
+      return r.value;
+    });
+    return changed ? { value: out, changed } : { value, changed: false };
+  }
+  return { value, changed: false };
 }
-function formatTaskList(tasks) {
-  if (tasks.length === 0) return "No tasks.";
-  const order = ["in_progress", "blocked", "review", "pending", "failed", "completed"];
-  const groups = /* @__PURE__ */ new Map();
-  for (const t of tasks) {
-    const list = groups.get(t.status) ?? [];
-    list.push(t);
-    groups.set(t.status, list);
+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;
   }
-  const lines = [];
-  lines.push(color.dim(`Tasks (${tasks.length} total):`));
-  for (const status of order) {
-    const group = groups.get(status);
-    if (!group || group.length === 0) continue;
-    const icon = STATUS_ICON[status];
-    lines.push(`  ${icon} ${status.toUpperCase()} (${group.length})`);
-    for (const t of group) {
-      const prio = PRIORITY_ICON[t.priority];
-      const type = TYPE_ICON[t.type];
-      const deps = t.dependsOn && t.dependsOn.length > 0 ? ` ${color.dim("\u2190")} ${color.dim(t.dependsOn.map((d) => d.slice(0, 8)).join(", "))}` : "";
-      const who = t.assignee ? ` ${color.dim(`@${t.assignee}`)}` : "";
-      const hrs = t.estimateHours ? ` ${color.dim(`${t.estimateHours}h`)}` : "";
-      lines.push(`    ${type} ${prio} ${t.title}${deps}${who}${hrs}`);
-    }
+}
+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 previewValue(v) {
+  try {
+    const s = JSON.stringify(v);
+    if (s === void 0) return String(v);
+    return s.length > 80 ? `${s.slice(0, 80)}\u2026` : s;
+  } catch {
+    return String(v);
   }
-  return lines.join("\n");
 }
-
-// src/utils/todos-format.ts
-function formatTodosList(todos) {
-  if (todos.length === 0) return "No todos.";
-  const lines = [];
-  const done = todos.filter((t) => t.status === "completed").length;
-  lines.push(color.dim(`Todos (${done}/${todos.length} done):`));
-  todos.forEach((t, i) => {
-    const mark = t.status === "completed" ? color.green("[x]") : t.status === "in_progress" ? color.yellow("[~]") : color.dim("[ ]");
-    const text = t.status === "in_progress" && t.activeForm ? t.activeForm : t.content;
-    const label = t.status === "completed" ? color.dim(text) : text;
-    lines.push(`  ${color.dim(String(i + 1).padStart(2))}. ${mark} ${label}`);
-  });
-  return lines.join("\n");
+function joinPath(parent, key) {
+  if (!parent) return key;
+  return `${parent}.${key}`;
 }
-function hasOpenTodos(todos) {
-  if (!Array.isArray(todos) || todos.length === 0) return false;
-  return todos.some((t) => t.status === "pending" || t.status === "in_progress");
+function enumIncludes(values, value) {
+  if (value === null || typeof value !== "object") return values.includes(value);
+  return values.some((candidate) => deepEqual(candidate, value));
 }
-
-// src/utils/tool-wire-compact.ts
-var TOOL_DESCRIPTION_MAX_CHARS = 400;
-var SCHEMA_DESCRIPTION_MAX_CHARS = 120;
-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;
+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]));
   }
-  const compact = {
-    name: tool.name,
-    description: compactDescription(
-      tool.description ?? "",
-      opts.descriptionMaxChars ?? TOOL_DESCRIPTION_MAX_CHARS
-    ),
-    inputSchema: normalizeTopLevelToolSchema(
-      compactSchemaDescriptions(
-        tool.inputSchema,
-        opts.schemaDescriptionMaxChars ?? SCHEMA_DESCRIPTION_MAX_CHARS
-      )
-    )
-  };
-  if (useDefaultOptions && typeof tool === "object" && tool !== null) {
-    compactCache.set(tool, compact);
+  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 compact;
+  return false;
 }
-function normalizeTopLevelToolSchema(schema) {
-  const combinators = ["oneOf", "anyOf", "allOf"].map((keyword) => ({ keyword, branches: schema[keyword] })).filter(
-    (entry) => Array.isArray(entry.branches)
-  );
-  if (combinators.length === 0) return schema;
-  const out = { ...schema, type: "object" };
-  delete out["oneOf"];
-  delete out["anyOf"];
-  delete out["allOf"];
-  const properties = isRecord(schema["properties"]) ? { ...schema["properties"] } : {};
-  let required = stringSet(schema["required"]);
-  for (const { keyword, branches } of combinators) {
-    const objectBranches = branches.filter(isRecord);
-    for (const branch of objectBranches) {
-      if (isRecord(branch["properties"])) Object.assign(properties, branch["properties"]);
+
+// src/utils/merge-custom-models.ts
+function mergeCustomModelDefs(providerCustomModels, configModels) {
+  const out = {};
+  if (providerCustomModels) {
+    for (const [id, def] of Object.entries(providerCustomModels)) {
+      out[id] = { ...def };
     }
-    const branchRequired = objectBranches.map((branch) => stringSet(branch["required"]));
-    if (keyword === "allOf") {
-      for (const fields of branchRequired) for (const field of fields) required.add(field);
-    } else if (branchRequired.length > 0) {
-      const common = new Set(
-        [...branchRequired[0]].filter(
-          (field) => branchRequired.slice(1).every((fields) => fields.has(field))
-        )
-      );
-      required = /* @__PURE__ */ new Set([...required, ...common]);
+  }
+  if (configModels) {
+    for (const [id, def] of Object.entries(configModels)) {
+      out[id] = { ...def };
     }
   }
-  out["properties"] = properties;
-  if (required.size > 0) out["required"] = [...required];
-  else delete out["required"];
+  if (Object.keys(out).length === 0) return void 0;
   return out;
 }
-function stringSet(value) {
-  return new Set(
-    Array.isArray(value) ? value.filter((item) => typeof item === "string") : []
-  );
+
+// src/utils/merge-models-payload.ts
+function mergeModelsPayload(base, overlay) {
+  const out = {};
+  for (const [id, provider] of Object.entries(base)) {
+    out[id] = cloneProvider(provider);
+  }
+  for (const [id, ovProvider] of Object.entries(overlay)) {
+    const existing = out[id];
+    out[id] = existing ? mergeProvider(existing, ovProvider) : cloneProvider(ovProvider);
+  }
+  return out;
 }
-function compactSchemaDescriptions(schema, maxDescriptionChars = SCHEMA_DESCRIPTION_MAX_CHARS) {
-  const compact = compactSchemaNode(schema, maxDescriptionChars);
-  return isRecord(compact) ? compact : { type: "object", properties: {} };
+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 };
+  }
+  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
+    }),
+    models
+  };
 }
-function compactSchemaNode(node, maxDescriptionChars) {
-  if (Array.isArray(node)) {
-    return node.map((item) => compactSchemaNode(item, maxDescriptionChars));
+function mergeModel(base, overlay) {
+  const merged = { ...base, ...overlay };
+  if (base.limit || overlay.limit) {
+    merged.limit = { ...base.limit, ...overlay.limit };
   }
-  if (!isRecord(node)) return node;
+  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 [key, value] of Object.entries(node)) {
-    if (key === "description" && typeof value === "string") {
-      out[key] = compactDescription(value, maxDescriptionChars);
-    } else {
-      out[key] = compactSchemaNode(value, maxDescriptionChars);
+  for (const [k, v] of Object.entries(obj)) {
+    if (v !== void 0) out[k] = v;
+  }
+  return out;
+}
+
+// src/utils/newline-normalize.ts
+function detectNewlineStyle(text) {
+  let lf = 0;
+  let crlf = 0;
+  let cr = 0;
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    if (c === 13) {
+      if (text.charCodeAt(i + 1) === 10) {
+        crlf++;
+        i++;
+      } else {
+        cr++;
+      }
+    } else if (c === 10) {
+      lf++;
     }
   }
-  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} ...`;
+  if (crlf > lf && crlf > cr) return "crlf";
+  if (cr > lf && cr > crlf) return "cr";
+  return "lf";
 }
-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 toStyle(text, style) {
+  const normalized = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  if (style === "lf") return normalized;
+  if (style === "crlf") return normalized.replace(/\n/g, "\r\n");
+  return normalized.replace(/\n/g, "\r");
 }
-function isRecord(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
+function normalizeToLf(text) {
+  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
 }
 
-// src/utils/token-estimate.ts
-var RoughTokenEstimate = (text, charsPerToken = 3.5) => Math.max(1, Math.ceil(text.length / charsPerToken));
-var CAL_ALPHA = 0.3;
-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);
+// src/utils/regex-guard.ts
+var MAX_PATTERN_LEN = 512;
+var DANGEROUS_PATTERNS = [
+  /(\([^)]*[+*][^)]*\))[+*]/,
+  // (a+)+, (.*)+, etc
+  /(\(\?:[^)]*[+*][^)]*\))[+*]/
+  // same, with non-capturing group
+];
+function compileUserRegex(pattern, flags) {
+  if (typeof pattern !== "string") {
+    return { ok: false, reason: "pattern must be a string" };
   }
-  return state;
-}
-var MIN_SAMPLES_FOR_CALIBRATION = 3;
-var MODEL_FAMILY_RATIO = {
-  // Anthropic: ~3.8-4.0 chars/token depending on model
-  claude: 3.8,
-  // OpenAI: ~4.0 chars/token
-  "gpt-4": 4,
-  "gpt-3.5": 4,
-  // Google: ~3.5 chars/token
-  gemini: 3.5,
-  // DeepSeek: ~3.5 chars/token
-  deepseek: 3.5
-};
-var ESTIMATE_CACHE = /* @__PURE__ */ new Map();
-var _estimateCacheOrder = [];
-var ESTIMATE_CACHE_MAX_SIZE = 5e4;
-function getCachedEstimate(key, compute) {
-  const existing = ESTIMATE_CACHE.get(key);
-  if (existing !== void 0) return existing;
-  if (ESTIMATE_CACHE.size >= ESTIMATE_CACHE_MAX_SIZE) {
-    while (ESTIMATE_CACHE.size > Math.floor(ESTIMATE_CACHE_MAX_SIZE / 2)) {
-      const oldest = _estimateCacheOrder.shift();
-      if (oldest !== void 0) ESTIMATE_CACHE.delete(oldest);
+  if (pattern.length === 0) {
+    return { ok: false, reason: "pattern is empty" };
+  }
+  if (pattern.length > MAX_PATTERN_LEN) {
+    return { ok: false, reason: `pattern exceeds ${MAX_PATTERN_LEN} characters` };
+  }
+  for (const rx of DANGEROUS_PATTERNS) {
+    if (rx.test(pattern)) {
+      return {
+        ok: false,
+        reason: "pattern looks vulnerable to catastrophic backtracking \u2014 rewrite without nested quantifiers"
+      };
     }
   }
-  const estimate = compute(key);
-  ESTIMATE_CACHE.set(key, estimate);
-  _estimateCacheOrder.push(key);
-  return estimate;
+  try {
+    return { ok: true, regex: new RegExp(pattern, flags) };
+  } catch (err) {
+    return {
+      ok: false,
+      reason: err instanceof Error ? err.message : "invalid regex"
+    };
+  }
 }
-function estimateToolInputTokens(input) {
-  if (typeof input === "string") return RoughTokenEstimate(input);
-  if (input === null || typeof input !== "object") {
-    return RoughTokenEstimate(String(input));
+
+// src/utils/safe-json.ts
+function safeParse(input, maxBytes = 5e6) {
+  if (Buffer.byteLength(input, "utf8") > maxBytes) {
+    return { ok: false, error: `Input exceeds limit (${maxBytes} bytes)` };
+  }
+  try {
+    return { ok: true, value: JSON.parse(input) };
+  } catch (err) {
+    return {
+      ok: false,
+      error: toErrorMessage(err)
+    };
   }
-  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 safeStringify(value, pretty = false) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  const replacer = (_k, v) => {
+    if (typeof v === "bigint") return v.toString();
+    if (v instanceof Error) {
+      return { name: v.name, message: v.message, stack: v.stack };
+    }
+    if (typeof v === "object" && v !== null) {
+      if (seen.has(v)) return "[Circular]";
+      seen.add(v);
+    }
+    return v;
+  };
+  try {
+    return JSON.stringify(value, replacer, pretty ? 2 : void 0) ?? "null";
+  } catch (err) {
+    return JSON.stringify({
+      __serialization_error: toErrorMessage(err)
+    });
+  }
 }
-function estimateTextTokens(text) {
-  return RoughTokenEstimate(text);
+function sanitizeJsonString(s) {
+  let out = s.trim();
+  out = stripJsonComments(out);
+  out = out.replace(/,(\s*[}\]])/g, "$1");
+  out = escapeControlCharsInStrings(out);
+  try {
+    JSON.parse(out);
+    return out;
+  } catch {
+    return null;
+  }
 }
-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));
+function stripCodeFences(s) {
+  const trimmed = s.trim();
+  const opener = /^```[\w+-]*[ \t]*\r?\n?/.exec(trimmed);
+  if (opener) {
+    const inner = trimmed.slice(opener[0].length).replace(/(\r?\n)?[ \t]*```[ \t]*$/, "");
+    return inner.trim();
   }
-  return total;
+  const embedded = /```[\w+-]*[ \t]*\r?\n([\s\S]*?)\r?\n[ \t]*```/.exec(trimmed);
+  if (embedded) return (embedded[1] ?? "").trim();
+  return null;
 }
-function estimateMessageTokens(messages) {
-  let total = 0;
-  for (const m of messages) {
-    if (typeof m._estTokens === "number" && m._estTokens > 0) {
-      total += m._estTokens;
+function escapeControlCharsInStrings(s) {
+  let inString = false;
+  let out = "";
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charAt(i);
+    if (c === '"' && (i === 0 || s[i - 1] !== "\\")) {
+      inString = !inString;
+      out += c;
       continue;
     }
-    total += computeMessageTokens(m);
+    const code = c.charCodeAt(0);
+    if (inString && code < 32) {
+      switch (c) {
+        case "\n":
+          out += "\\n";
+          break;
+        case "\r":
+          out += "\\r";
+          break;
+        case "	":
+          out += "\\t";
+          break;
+        case "\b":
+          out += "\\b";
+          break;
+        case "\f":
+          out += "\\f";
+          break;
+        default:
+          out += `\\u${code.toString(16).padStart(4, "0")}`;
+      }
+      continue;
+    }
+    out += c;
   }
-  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));
+  return out;
 }
-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));
-              }
-            }
-          }
-        }
+function stripJsonComments(s) {
+  let inString = false;
+  let escaped = false;
+  const chars = [];
+  let i = 0;
+  while (i < s.length) {
+    const c = s.charAt(i);
+    if (inString) {
+      chars.push(c);
+      if (escaped) {
+        escaped = false;
+      } else if (c === "\\") {
+        escaped = true;
+      } else if (c === '"') {
+        inString = false;
       }
+      i++;
+      continue;
     }
-  }
-  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);
+    if (c === '"') {
+      inString = true;
+      chars.push(c);
+      i++;
+      continue;
+    }
+    if (c === "/" && s.charAt(i + 1) === "/") {
+      while (i < s.length && s.charAt(i) !== "\n") i++;
+      continue;
+    }
+    if (c === "/" && s.charAt(i + 1) === "*") {
+      const end = s.indexOf("*/", i + 2);
+      if (end === -1) {
+        chars.push(s.slice(i));
+        break;
       }
+      i = end + 2;
+      continue;
     }
+    chars.push(c);
+    i++;
   }
-  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
-  };
+  return chars.join("");
 }
-function recordActualUsage(actualInputTokens, estimatedInputTokens, calibrationKey = CALIBRATION_GLOBAL_KEY) {
-  if (actualInputTokens <= 0) return;
-  const cal = calState(calibrationKey);
-  const est = estimatedInputTokens ?? cal.prevEst;
-  if (est <= 0) return;
-  const sampleRatio = actualInputTokens / est;
-  if (cal.count === 0) {
-    cal.ratio = sampleRatio;
-  } else {
-    cal.ratio = CAL_ALPHA * sampleRatio + (1 - CAL_ALPHA) * cal.ratio;
+
+// src/utils/session-scoped-path.ts
+import * as path4 from "node:path";
+function sessionScopedPath(dir, sessionId, suffix) {
+  if (!sessionId || sessionId.includes("\\") || sessionId.includes("..")) {
+    throw invalid(sessionId);
   }
-  cal.ratio = Math.min(1.5, Math.max(0.5, cal.ratio));
-  cal.count++;
+  const resolved = path4.resolve(dir, `${sessionId}${suffix}`);
+  const rel = path4.relative(path4.resolve(dir), resolved);
+  if (rel.startsWith("..") || path4.isAbsolute(rel)) {
+    throw invalid(sessionId);
+  }
+  return resolved;
 }
-function getCalibrationState(calibrationKey = CALIBRATION_GLOBAL_KEY) {
-  const cal = calState(calibrationKey);
+function invalid(sessionId) {
+  return new FsError({
+    message: `Invalid sessionId: ${sessionId}`,
+    code: ERROR_CODES.FS_DELETE_FAILED,
+    path: sessionId,
+    context: { reason: "path_traversal" }
+  });
+}
+
+// src/utils/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
+}
+
+// src/utils/slug.ts
+function slugify(name, fallback = "prompt", maxLen = 64) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, maxLen).replace(/-+$/g, "") || fallback;
+}
+
+// src/utils/string.ts
+function truncate(s, max) {
+  return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
+}
+
+// src/utils/task-format.ts
+function computeTaskItemProgress(tasks) {
+  let completed = 0;
+  let pending = 0;
+  let inProgress = 0;
+  let blocked = 0;
+  let failed = 0;
+  let review = 0;
+  let estimatedHours = 0;
+  const actualHours = 0;
+  for (const t of tasks) {
+    switch (t.status) {
+      case "completed":
+        completed++;
+        break;
+      case "pending":
+        pending++;
+        break;
+      case "in_progress":
+        inProgress++;
+        break;
+      case "blocked":
+        blocked++;
+        break;
+      case "failed":
+        failed++;
+        break;
+      case "review":
+        review++;
+        break;
+    }
+    estimatedHours += t.estimateHours ?? 0;
+  }
   return {
-    ratio: cal.ratio,
-    count: cal.count,
-    calibrated: cal.count >= MIN_SAMPLES_FOR_CALIBRATION
+    total: tasks.length,
+    pending,
+    inProgress,
+    blocked,
+    failed,
+    review,
+    completed,
+    percentComplete: tasks.length > 0 ? Math.round(completed / tasks.length * 100) : 0,
+    estimatedHours,
+    actualHours
   };
 }
-function estimateRequestTokensCalibrated(messages, systemPrompt, tools, calibrationKey = CALIBRATION_GLOBAL_KEY) {
-  const result = estimateRequestTokens(messages, systemPrompt, tools, calibrationKey);
-  const cal = calState(calibrationKey);
-  if (cal.count >= MIN_SAMPLES_FOR_CALIBRATION) {
-    const safeRatio = Math.min(1.5, Math.max(0.5, cal.ratio));
-    return {
-      messages: Math.round(result.messages * safeRatio),
-      systemPrompt: Math.round(result.systemPrompt * safeRatio),
-      tools: Math.round(result.tools * safeRatio),
-      total: Math.round(result.total * safeRatio)
-    };
+var STATUS_ICON = {
+  pending: "\u25CB",
+  in_progress: "\u25D0",
+  blocked: "\u2298",
+  failed: "\u2717",
+  review: "\u25D1",
+  completed: "\u25CF"
+};
+var PRIORITY_ICON = {
+  critical: "\u{1F534}",
+  high: "\u{1F7E0}",
+  medium: "\u{1F7E1}",
+  low: "\u{1F7E2}"
+};
+var TYPE_ICON = {
+  feature: "\u26A1",
+  bugfix: "\u{1F41B}",
+  refactor: "\u267B\uFE0F",
+  docs: "\u{1F4DD}",
+  test: "\u{1F9EA}",
+  chore: "\u{1F527}"
+};
+function formatTaskProgress(tasks) {
+  const p = computeTaskItemProgress(tasks);
+  if (p.total === 0) return "No tasks.";
+  const barWidth = 24;
+  const filled = Math.round(p.percentComplete / 100 * barWidth);
+  const empty = barWidth - filled;
+  const bar = "\u2588".repeat(filled) + "\u2591".repeat(empty);
+  return [
+    `${color.bold("Tasks")} [${bar}] ${p.percentComplete}%`,
+    `  ${color.green("\u25CF")} ${p.completed} done \u2502 ${color.yellow("\u25D0")} ${p.inProgress} active \u2502 ${color.dim("\u25CB")} ${p.pending} pending \u2502 \u2298 ${p.blocked} blocked \u2502 \u2717 ${p.failed} failed`,
+    p.estimatedHours > 0 ? `  ${color.dim(`est. ${p.estimatedHours}h`)}` : ""
+  ].filter(Boolean).join("\n");
+}
+function formatTaskList(tasks) {
+  if (tasks.length === 0) return "No tasks.";
+  const order = ["in_progress", "blocked", "review", "pending", "failed", "completed"];
+  const groups = /* @__PURE__ */ new Map();
+  for (const t of tasks) {
+    const list = groups.get(t.status) ?? [];
+    list.push(t);
+    groups.set(t.status, list);
   }
-  const fallbackRatio = getModelFamilyRatio(calibrationKey);
-  if (fallbackRatio !== null) {
-    return {
-      messages: Math.round(result.messages * fallbackRatio),
-      systemPrompt: Math.round(result.systemPrompt * fallbackRatio),
-      tools: Math.round(result.tools * fallbackRatio),
-      total: Math.round(result.total * fallbackRatio)
-    };
+  const lines = [];
+  lines.push(color.dim(`Tasks (${tasks.length} total):`));
+  for (const status of order) {
+    const group = groups.get(status);
+    if (!group || group.length === 0) continue;
+    const icon = STATUS_ICON[status];
+    lines.push(`  ${icon} ${status.toUpperCase()} (${group.length})`);
+    for (const t of group) {
+      const prio = PRIORITY_ICON[t.priority];
+      const type = TYPE_ICON[t.type];
+      const deps = t.dependsOn && t.dependsOn.length > 0 ? ` ${color.dim("\u2190")} ${color.dim(t.dependsOn.map((d) => d.slice(0, 8)).join(", "))}` : "";
+      const who = t.assignee ? ` ${color.dim(`@${t.assignee}`)}` : "";
+      const hrs = t.estimateHours ? ` ${color.dim(`${t.estimateHours}h`)}` : "";
+      lines.push(`    ${type} ${prio} ${t.title}${deps}${who}${hrs}`);
+    }
   }
-  return result;
+  return lines.join("\n");
 }
-function getModelFamilyRatio(calibrationKey) {
-  const lower = calibrationKey.toLowerCase();
-  for (const [family, ratio] of Object.entries(MODEL_FAMILY_RATIO)) {
-    if (lower.includes(family)) return ratio / 3.5;
-  }
-  return null;
+
+// src/utils/todos-format.ts
+function formatTodosList(todos) {
+  if (todos.length === 0) return "No todos.";
+  const lines = [];
+  const done = todos.filter((t) => t.status === "completed").length;
+  lines.push(color.dim(`Todos (${done}/${todos.length} done):`));
+  todos.forEach((t, i) => {
+    const mark = t.status === "completed" ? color.green("[x]") : t.status === "in_progress" ? color.yellow("[~]") : color.dim("[ ]");
+    const text = t.status === "in_progress" && t.activeForm ? t.activeForm : t.content;
+    const label = t.status === "completed" ? color.dim(text) : text;
+    lines.push(`  ${color.dim(String(i + 1).padStart(2))}. ${mark} ${label}`);
+  });
+  return lines.join("\n");
 }
-function resetCalibration(calibrationKey) {
-  if (calibrationKey === void 0) {
-    _cals.clear();
-    return;
-  }
-  _cals.delete(calibrationKey);
+function hasOpenTodos(todos) {
+  if (!Array.isArray(todos) || todos.length === 0) return false;
+  return todos.some((t) => t.status === "pending" || t.status === "in_progress");
 }
 
 // src/utils/tool-description-mode.ts
@@ -3821,7 +4037,7 @@ function isUlid(value) {
 }
 
 // src/utils/wstack-paths.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import * as fs4 from "node:fs";
 import * as os from "node:os";
 import * as path5 from "node:path";
@@ -3844,12 +4060,12 @@ function canonicalProjectRoot(absRoot) {
   }
 }
 function projectHash(absRoot) {
-  return createHash("sha256").update(canonicalProjectRoot(absRoot)).digest("hex").slice(0, 12);
+  return createHash2("sha256").update(canonicalProjectRoot(absRoot)).digest("hex").slice(0, 12);
 }
 function projectSlug(absRoot) {
   const identityRoot = canonicalProjectRoot(absRoot);
   const base = slugify2(path5.basename(identityRoot));
-  const hash = createHash("sha256").update(identityRoot).digest("hex").slice(0, 6);
+  const hash = createHash2("sha256").update(identityRoot).digest("hex").slice(0, 6);
   return `${base}-${hash}`;
 }
 function slugify2(name) {
@@ -3960,6 +4176,7 @@ export {
   buildTitleSequence,
   buildUserContentBlocks,
   canonicalProjectRoot,
+  checkConnectivity,
   coerceAgainstSchema,
   color,
   compactSchemaDescriptions,
@@ -3974,6 +4191,7 @@ export {
   createContextEvidenceState,
   createToolOutputSerializer,
   deepMerge,
+  deriveCachePrefixKey,
   detectNewlineStyle,
   detectTerminal,
   ensureDir,
@@ -3994,6 +4212,7 @@ export {
   formatTodosList,
   getCalibrationState,
   getChildEnvGitIdentity,
+  getContextBreakdown,
   getJsonPath,
   getToolDescriptionMode,
   getToolResultRenderMode,
@@ -4029,6 +4248,7 @@ export {
   repairToolUseAdjacency,
   repeatedReadPressure,
   resetCalibration,
+  resetConnectivityCache,
   resolveToolDescriptionMode,
   resolveToolResultRenderMode,
   resolveWstackPaths,