@wrongstack/core 0.296.4 → 0.298.0

package/dist/utils/index.js

@@ -133,6 +133,19 @@ var atomicReplaceWithWriter = primitives.atomicReplaceWithWriter;
 var ensureDir = primitives.ensureDir;
 var withFileLock = primitives.withFileLock;
 
+// 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/child-env.ts
 var ALLOWED_KEYS = /* @__PURE__ */ new Set([
   "PATH",
@@ -169,6 +182,11 @@ var SECRET_NAME_PARTS = [
   "SECRET",
   "PASSWORD",
   "PASSWD",
+  // WRONGSTACK_VAULT_PASSPHRASE is the vault KEK. Without this entry it matched
+  // no rule here and fell through to the `WRONGSTACK_` prefix allow-rule, so the
+  // key that protects the credential vault was forwarded to every child process
+  // — including the agent's own exec/bash tools and MCP stdio servers (WS-033).
+  "PASSPHRASE",
   "AUTH",
   "CRED",
   "BEARER",
@@ -614,52 +632,69 @@ 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;
+// src/utils/config-json.ts
+import * as fs2 from "node:fs/promises";
+
+// 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");
 }
-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 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;
   }
-}
-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;
+  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/config-json.ts
-import * as fs2 from "node:fs/promises";
 async function readJsonObjectFile(filePath) {
   try {
     const parsed = JSON.parse(await fs2.readFile(filePath, "utf8"));
@@ -686,9 +721,20 @@ async function updateJsonObjectFile(filePath, mutator) {
   await writeJsonObjectFile(filePath, next);
   return next;
 }
-function getJsonPath(root, path9) {
+function isForbiddenSegment(segment) {
+  return typeof segment === "string" && FORBIDDEN_PROTO_KEYS.has(segment);
+}
+function assertSafePath(path11) {
+  for (const segment of path11) {
+    if (isForbiddenSegment(segment)) {
+      throw new Error(`Refusing to use reserved key "${String(segment)}" in a JSON path`);
+    }
+  }
+}
+function getJsonPath(root, path11) {
+  if (path11.some(isForbiddenSegment)) return void 0;
   let current = root;
-  for (const segment of path9) {
+  for (const segment of path11) {
     if (typeof segment === "number") {
       if (!Array.isArray(current)) return void 0;
       current = current[segment];
@@ -699,15 +745,17 @@ function getJsonPath(root, path9) {
   }
   return current;
 }
-function setJsonPath(root, path9, value) {
-  if (path9.length === 0) {
+function setJsonPath(root, path11, value) {
+  assertSafePath(path11);
+  if (path11.length === 0) {
     if (!isJsonObject(value)) throw new Error("Root config value must be an object");
     return value;
   }
-  const parent = ensureJsonParent(root, path9);
-  const leaf = lastPathSegment(path9);
+  const parent = ensureJsonParent(root, path11);
+  const leaf = lastPathSegment(path11);
   if (typeof leaf === "number") {
-    if (!Array.isArray(parent)) throw new Error(`Cannot set numeric segment ${leaf} on non-array parent`);
+    if (!Array.isArray(parent))
+      throw new Error(`Cannot set numeric segment ${leaf} on non-array parent`);
     parent[leaf] = value;
   } else {
     if (!isJsonObject(parent)) throw new Error(`Cannot set property ${leaf} on non-object parent`);
@@ -715,10 +763,11 @@ function setJsonPath(root, path9, value) {
   }
   return root;
 }
-function removeJsonPath(root, path9) {
-  if (path9.length === 0) return false;
-  const parent = getJsonPath(root, path9.slice(0, -1));
-  const leaf = lastPathSegment(path9);
+function removeJsonPath(root, path11) {
+  if (path11.some(isForbiddenSegment)) return false;
+  if (path11.length === 0) return false;
+  const parent = getJsonPath(root, path11.slice(0, -1));
+  const leaf = lastPathSegment(path11);
   if (typeof leaf === "number") {
     if (!Array.isArray(parent) || leaf < 0 || leaf >= parent.length) return false;
     parent.splice(leaf, 1);
@@ -728,42 +777,78 @@ function removeJsonPath(root, path9) {
   delete parent[leaf];
   return true;
 }
-async function setJsonPathInFile(filePath, path9, value) {
-  return updateJsonObjectFile(filePath, (config) => setJsonPath(config, path9, value));
+async function setJsonPathInFile(filePath, path11, value) {
+  return updateJsonObjectFile(filePath, (config) => setJsonPath(config, path11, value));
 }
-async function removeJsonPathInFile(filePath, path9) {
+async function removeJsonPathInFile(filePath, path11) {
   return updateJsonObjectFile(filePath, (config) => {
-    removeJsonPath(config, path9);
+    removeJsonPath(config, path11);
   });
 }
 function isJsonObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function lastPathSegment(path9) {
-  const segment = path9[path9.length - 1];
+function lastPathSegment(path11) {
+  const segment = path11[path11.length - 1];
   if (segment === void 0) throw new Error("Invalid empty JSON path");
   return segment;
 }
-function ensureJsonParent(root, path9) {
+function ensureJsonParent(root, path11) {
+  assertSafePath(path11);
   let current = root;
-  for (let i = 0; i < path9.length - 1; i += 1) {
-    const segment = path9[i];
-    const nextSegment = path9[i + 1];
+  for (let i = 0; i < path11.length - 1; i += 1) {
+    const segment = path11[i];
+    const nextSegment = path11[i + 1];
     if (segment === void 0) throw new Error("Invalid empty JSON path segment");
     const nextContainer = typeof nextSegment === "number" ? [] : {};
     if (typeof segment === "number") {
-      if (!Array.isArray(current)) throw new Error(`Cannot traverse numeric segment ${segment} on non-array parent`);
-      if (!isJsonObject(current[segment]) && !Array.isArray(current[segment])) current[segment] = nextContainer;
+      if (!Array.isArray(current))
+        throw new Error(`Cannot traverse numeric segment ${segment} on non-array parent`);
+      if (!isJsonObject(current[segment]) && !Array.isArray(current[segment]))
+        current[segment] = nextContainer;
       current = current[segment];
     } else {
-      if (!isJsonObject(current)) throw new Error(`Cannot traverse property ${segment} on non-object parent`);
-      if (!isJsonObject(current[segment]) && !Array.isArray(current[segment])) current[segment] = nextContainer;
+      if (!isJsonObject(current))
+        throw new Error(`Cannot traverse property ${segment} on non-object parent`);
+      if (!isJsonObject(current[segment]) && !Array.isArray(current[segment]))
+        current[segment] = nextContainer;
       current = current[segment];
     }
   }
   return current;
 }
 
+// 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/context-evidence.ts
 import * as path2 from "node:path";
 var MAX_TOOL_CALLS = 80;
@@ -1742,63 +1827,55 @@ function getContextBreakdown(ctx) {
   };
 }
 
-// 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])];
+// src/utils/crash-shield.ts
+var CRASH_STORM_WINDOW_MS = 6e4;
+var CRASH_STORM_LIMIT = 20;
+function isBrokenOutputConsumer(error) {
+  if (typeof error !== "object" || error === null || !("code" in error)) return false;
+  return error.code === "EPIPE" || error.code === "ECONNRESET" || error.code === "ECONNABORTED";
+}
+function installCrashShield(options = {}) {
+  const target = options.target ?? process;
+  const exit = options.exit ?? ((code) => process.exit(code));
+  const write = options.write ?? ((s) => void writeErr(s));
+  const recent = [];
+  const isStorming = () => {
+    const now = Date.now();
+    recent.push(now);
+    while (recent.length > 0 && now - recent[0] > CRASH_STORM_WINDOW_MS) {
+      recent.shift();
     }
-    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 recent.length > CRASH_STORM_LIMIT;
+  };
+  const report = (kind, reason) => {
+    try {
+      const detail = reason instanceof Error ? reason.stack ?? reason.message : String(reason);
+      write(`[wrongstack] ${kind} (recovered \u2014 please report): ${detail}
+`);
+    } catch {
     }
-  }
-  return out;
+  };
+  const guard = (kind) => (reason) => {
+    if (isBrokenOutputConsumer(reason)) return;
+    report(kind, reason);
+    if (isStorming()) {
+      report(
+        kind,
+        new Error(
+          `error storm: >${CRASH_STORM_LIMIT} in ${CRASH_STORM_WINDOW_MS / 1e3}s \u2014 exiting`
+        )
+      );
+      exit(1);
+    }
+  };
+  const onRejection = guard("unhandled promise rejection");
+  const onException = guard("uncaught exception");
+  target.on("unhandledRejection", onRejection);
+  target.on("uncaughtException", onException);
+  return () => {
+    target.off("unhandledRejection", onRejection);
+    target.off("uncaughtException", onException);
+  };
 }
 
 // src/utils/diff.ts
@@ -1953,6 +2030,47 @@ function unifiedDiff(oldText, newText, opts = {}) {
   return out;
 }
 
+// src/utils/env-typed.ts
+function envBool(key, env = process.env) {
+  const raw = env[key];
+  if (raw === void 0 || raw === "") return false;
+  return !/^(0|false|no|off)$/i.test(raw.trim());
+}
+function envBoolOptional(key, env = process.env) {
+  const raw = env[key];
+  if (raw === void 0 || raw === "") return void 0;
+  return !/^(0|false|no|off)$/i.test(raw.trim());
+}
+function envInt(key, options = { default: 0 }, env = process.env) {
+  const raw = env[key];
+  if (raw === void 0 || raw === "") return options.default;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed)) return options.default;
+  if (options.min !== void 0 && parsed < options.min) return options.default;
+  if (options.max !== void 0 && parsed > options.max) return options.default;
+  return parsed;
+}
+function envFloat(key, options = { default: 0 }, env = process.env) {
+  const raw = env[key];
+  if (raw === void 0 || raw === "") return options.default;
+  const parsed = Number.parseFloat(raw);
+  if (!Number.isFinite(parsed)) return options.default;
+  if (options.min !== void 0 && parsed < options.min) return options.default;
+  if (options.max !== void 0 && parsed > options.max) return options.default;
+  return parsed;
+}
+function envString(key, env = process.env) {
+  const raw = env[key];
+  if (raw === void 0) return void 0;
+  const trimmed = raw.trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
+function envEnum(key, allowed, options, env = process.env) {
+  const raw = envString(key, env);
+  if (raw === void 0) return options.default;
+  return allowed.includes(raw) ? raw : options.default;
+}
+
 // src/utils/glob-expand.ts
 import * as fsp from "node:fs/promises";
 import { isAbsolute as isAbsolute2, resolve as resolve2 } from "node:path";
@@ -2051,8 +2169,8 @@ async function expandGlob(pattern) {
       for (const e of entries) {
         const full = `${dir}${SEP}${e}`;
         try {
-          const stat2 = await fsp.stat(full);
-          if (stat2.isDirectory()) await walk2(full, rest);
+          const stat3 = await fsp.stat(full);
+          if (stat3.isDirectory()) await walk2(full, rest);
         } catch {
         }
       }
@@ -2069,8 +2187,8 @@ async function expandGlob(pattern) {
       if (entries.includes(seg)) {
         const full = `${dir}${SEP}${seg}`;
         try {
-          const stat2 = await fsp.stat(full);
-          if (stat2.isDirectory()) await walk2(full, rest);
+          const stat3 = await fsp.stat(full);
+          if (stat3.isDirectory()) await walk2(full, rest);
         } catch {
         }
       }
@@ -2087,8 +2205,10 @@ function escapeRegex(s) {
 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);
+var COMMAND_WILDCARD_STOP = ";&|\\n\\r`$<>";
+function getCachedGlob(pattern, commandSubject = false) {
+  const cacheKey = commandSubject ? `cmd\0${pattern}` : pattern;
+  const cached2 = COMPILED_GLOB_CACHE.get(cacheKey);
   if (cached2) return cached2;
   if (COMPILED_GLOB_CACHE.size >= CACHE_MAX_SIZE) {
     const keys = [...COMPILED_GLOB_CACHE.keys()];
@@ -2098,33 +2218,35 @@ function getCachedGlob(pattern) {
   }
   let re;
   try {
-    re = compileGlob(pattern);
+    re = compileGlob(pattern, commandSubject);
   } catch {
     re = NEVER_MATCH;
   }
-  COMPILED_GLOB_CACHE.set(pattern, re);
+  COMPILED_GLOB_CACHE.set(cacheKey, re);
   return re;
 }
 var MAX_GLOB_PATTERN_LEN = 1024;
-function compileGlob(pattern) {
+function compileGlob(pattern, commandSubject = false) {
   if (pattern.length > MAX_GLOB_PATTERN_LEN) {
     throw new Error(`Glob pattern exceeds ${MAX_GLOB_PATTERN_LEN} characters`);
   }
+  const star = commandSubject ? `[^/${COMMAND_WILDCARD_STOP}]*` : "[^/]*";
+  const question = commandSubject ? `[^/${COMMAND_WILDCARD_STOP}]` : "[^/]";
   let i = 0;
   let re = "^";
   while (i < pattern.length) {
     const c = pattern[i];
     if (c === "*") {
       if (pattern[i + 1] === "*") {
-        re += ".*";
+        re += commandSubject ? `[^${COMMAND_WILDCARD_STOP}]*` : ".*";
         i += 2;
         if (pattern[i] === "/") i++;
       } else {
-        re += "[^/]*";
+        re += star;
         i++;
       }
     } else if (c === "?") {
-      re += "[^/]";
+      re += question;
       i++;
     } else if (c === "[") {
       let cls = "[";
@@ -2161,44 +2283,878 @@ function matchGlob(pattern, input) {
 function matchAny(patterns, input) {
   return patterns.some((p) => matchGlob(p, input));
 }
+function matchCommandGlob(pattern, input) {
+  return getCachedGlob(pattern, true).test(input);
+}
+function matchAnyCommand(patterns, input) {
+  return patterns.some((p) => matchCommandGlob(p, input));
+}
 
-// 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/utils/heap-watchdog.ts
+import * as fs4 from "node:fs";
+import * as fsp3 from "node:fs/promises";
+import * as path5 from "node:path";
+import { PerformanceObserver, constants as performanceConstants } from "node:perf_hooks";
+import * as v8 from "node:v8";
+
+// src/utils/memory-flight-recorder.ts
+import * as fsp2 from "node:fs/promises";
+import * as path4 from "node:path";
+
+// src/utils/continuous-memory-profiler.ts
+import { Session } from "node:inspector/promises";
+var DEFAULT_SAMPLE_INTERVAL_BYTES = 512 * 1024;
+var DEFAULT_STACK_DEPTH = 64;
+var MAX_SUMMARY_STACKS = 20;
+var MAX_FRAMES_PER_STACK = 12;
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function numeric(value) {
+  if (typeof value === "bigint") return Number(value);
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function summarizePprof(profile) {
+  const strings = profile.stringTable.strings;
+  const functions = new Map(profile.function.map((entry) => [numeric(entry.id), entry]));
+  const locations = new Map(profile.location.map((entry) => [numeric(entry.id), entry]));
+  const stacks = /* @__PURE__ */ new Map();
+  let sampledBytes = 0;
+  let sampledObjects = 0;
+  for (const sample of profile.sample) {
+    const objects = numeric(sample.value[0]);
+    const bytes = numeric(sample.value[1]);
+    sampledObjects += objects;
+    sampledBytes += bytes;
+    const frames = sample.locationId.slice(0, MAX_FRAMES_PER_STACK).flatMap((locationId) => {
+      const location = locations.get(numeric(locationId));
+      const line = location?.line[0];
+      const fn = line ? functions.get(numeric(line.functionId)) : void 0;
+      if (!fn) return [];
+      const name = strings[numeric(fn.name)] || "(anonymous)";
+      const filename = strings[numeric(fn.filename)] || "";
+      const lineNumber = numeric(line?.line);
+      return [filename ? `${name} (${filename}${lineNumber > 0 ? `:${lineNumber}` : ""})` : name];
+    });
+    if (frames.length === 0) frames.push("(unknown)");
+    const key = frames.join("\n");
+    const existing = stacks.get(key);
+    if (existing) {
+      existing.bytes += bytes;
+      existing.objects += objects;
+    } else {
+      stacks.set(key, { bytes, objects, frames });
+    }
   }
-};
-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()
+    sampledBytes,
+    sampledObjects,
+    sampleCount: profile.sample.length,
+    topStacks: [...stacks.values()].sort((left, right) => right.bytes - left.bytes).slice(0, MAX_SUMMARY_STACKS)
   };
 }
-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).`
+async function startDatadogProfiler() {
+  const pprof = await import("@datadog/pprof");
+  pprof.heap.start(DEFAULT_SAMPLE_INTERVAL_BYTES, DEFAULT_STACK_DEPTH);
+  let stopped = false;
+  return {
+    backend: "datadog-pprof",
+    capture: async () => {
+      if (stopped) throw new Error("Continuous memory profiler is stopped");
+      const profile = pprof.heap.profile();
+      return {
+        backend: "datadog-pprof",
+        data: await pprof.encode(profile),
+        extension: ".pb.gz",
+        summary: summarizePprof(profile)
+      };
+    },
+    stop: async () => {
+      if (stopped) return;
+      stopped = true;
+      pprof.heap.stop();
+    }
+  };
+}
+async function startInspectorProfiler() {
+  const session = new Session();
+  session.connect();
+  try {
+    await session.post("HeapProfiler.enable");
+    await session.post("HeapProfiler.startSampling", {
+      samplingInterval: DEFAULT_SAMPLE_INTERVAL_BYTES,
+      includeObjectsCollectedByMajorGC: false,
+      includeObjectsCollectedByMinorGC: false
+    });
+  } catch (error) {
+    try {
+      session.disconnect();
+    } catch {
+    }
+    throw error;
+  }
+  let stopped = false;
+  return {
+    backend: "node-inspector",
+    capture: async () => {
+      if (stopped) throw new Error("Continuous memory profiler is stopped");
+      const result = await session.post("HeapProfiler.stopSampling");
+      await session.post("HeapProfiler.startSampling", {
+        samplingInterval: DEFAULT_SAMPLE_INTERVAL_BYTES,
+        includeObjectsCollectedByMajorGC: false,
+        includeObjectsCollectedByMinorGC: false
+      });
+      return {
+        backend: "node-inspector",
+        data: JSON.stringify(result.profile),
+        extension: ".heapprofile"
+      };
+    },
+    stop: async () => {
+      if (stopped) return;
+      stopped = true;
+      try {
+        await session.post("HeapProfiler.disable");
+      } catch {
+      }
+      try {
+        session.disconnect();
+      } catch {
+      }
+    }
+  };
+}
+async function startContinuousMemoryProfiler() {
+  try {
+    return { profiler: await startDatadogProfiler() };
+  } catch (error) {
+    const fallbackReason = errorMessage(error);
+    return {
+      profiler: await startInspectorProfiler(),
+      fallbackReason
+    };
+  }
+}
+
+// src/utils/wstack-paths.ts
+import { createHash as createHash2 } from "node:crypto";
+import * as fs3 from "node:fs";
+import * as os from "node:os";
+import * as path3 from "node:path";
+function canonicalProjectRoot(absRoot) {
+  const checkoutRoot = path3.resolve(absRoot);
+  const dotGit = path3.join(checkoutRoot, ".git");
+  try {
+    if (!fs3.statSync(dotGit).isFile()) return checkoutRoot;
+    const gitDirLine = fs3.readFileSync(dotGit, "utf8").trim();
+    const match = /^gitdir:\s*(.+)$/i.exec(gitDirLine);
+    if (!match?.[1]) return checkoutRoot;
+    const gitDir = path3.resolve(checkoutRoot, match[1].trim());
+    const commonDirFile = path3.join(gitDir, "commondir");
+    if (!fs3.statSync(commonDirFile).isFile()) return checkoutRoot;
+    const commonDir = path3.resolve(gitDir, fs3.readFileSync(commonDirFile, "utf8").trim());
+    if (path3.basename(commonDir).toLowerCase() !== ".git") return checkoutRoot;
+    return path3.dirname(commonDir);
+  } catch {
+    return checkoutRoot;
+  }
+}
+function projectHash(absRoot) {
+  return createHash2("sha256").update(canonicalProjectRoot(absRoot)).digest("hex").slice(0, 12);
+}
+function projectSlug(absRoot) {
+  const identityRoot = canonicalProjectRoot(absRoot);
+  const base = slugify(path3.basename(identityRoot));
+  const hash = createHash2("sha256").update(identityRoot).digest("hex").slice(0, 6);
+  return `${base}-${hash}`;
+}
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "project";
+}
+function safeProfileName(name) {
+  const safe = (name ?? "").replace(/[/\\:]/g, "_").replace(/\.\./g, "_").trim();
+  return safe || "default";
+}
+function activeProfileName(globalRoot) {
+  try {
+    const parsed = JSON.parse(fs3.readFileSync(path3.join(globalRoot, "config.json"), "utf8"));
+    return safeProfileName(typeof parsed.activeProfile === "string" ? parsed.activeProfile : void 0);
+  } catch {
+    return "default";
+  }
+}
+function wstackGlobalRoot() {
+  const fromEnv = process.env["WRONGSTACK_HOME"];
+  if (fromEnv && fromEnv.trim().length > 0) return path3.resolve(fromEnv);
+  return path3.join(os.homedir(), ".wrongstack");
+}
+function resolveWstackPaths(opts) {
+  const globalRoot = opts.globalRoot ?? (opts.userHome ? path3.join(opts.userHome, ".wrongstack") : wstackGlobalRoot());
+  const homeDir = opts.userHome ?? os.homedir();
+  const profileName = safeProfileName(opts.profileName ?? activeProfileName(globalRoot));
+  const profileDir = path3.join(globalRoot, "profiles", profileName);
+  const hash = projectHash(opts.projectRoot);
+  const slug = projectSlug(opts.projectRoot);
+  const projectDir = path3.join(globalRoot, "projects", slug);
+  return {
+    globalRoot,
+    profileName,
+    profileDir,
+    projectRoot: opts.projectRoot,
+    homeDir,
+    configDir: profileDir,
+    globalConfig: path3.join(globalRoot, "config.json"),
+    profilesDir: path3.join(globalRoot, "profiles"),
+    profileConfig: (name) => {
+      return path3.join(globalRoot, "profiles", safeProfileName(name), "config.json");
+    },
+    profileStatuslineConfig: (name) => {
+      return path3.join(globalRoot, "profiles", safeProfileName(name), "statusline.json");
+    },
+    profileModeConfig: (name) => {
+      return path3.join(globalRoot, "profiles", safeProfileName(name), "mode.json");
+    },
+    profileProviderStatus: (name) => {
+      return path3.join(globalRoot, "profiles", safeProfileName(name), "provider-status.json");
+    },
+    profileUpdateCache: (name) => {
+      return path3.join(globalRoot, "profiles", safeProfileName(name), "update-cache.json");
+    },
+    secretsKey: path3.join(globalRoot, ".key"),
+    globalMemory: path3.join(profileDir, "memory.md"),
+    globalSkills: path3.join(profileDir, "skills"),
+    globalClaudeSkills: path3.join(homeDir, ".claude", "skills"),
+    globalDesignKits: path3.join(profileDir, "design-kits"),
+    globalPrompts: path3.join(profileDir, "prompts"),
+    globalInstructions: path3.join(profileDir, "instructions"),
+    promptUsage: path3.join(profileDir, "prompt-usage.json"),
+    cacheDir: path3.join(globalRoot, "cache"),
+    modelsCache: path3.join(globalRoot, "cache", "models.dev.json"),
+    modelsOverlayCache: path3.join(globalRoot, "cache", "models-overlay.json"),
+    historyFile: path3.join(profileDir, "history"),
+    logFile: path3.join(globalRoot, "logs", "wrongstack.log"),
+    projectDir,
+    projectCodebaseIndex: path3.join(projectDir, "codebase-index"),
+    projectMemory: path3.join(projectDir, "memory.md"),
+    projectSessions: path3.join(projectDir, "sessions"),
+    projectTrust: path3.join(projectDir, "trust.json"),
+    projectMeta: path3.join(projectDir, "meta.json"),
+    projectLocalConfig: path3.join(projectDir, "config.local.json"),
+    inProjectConfig: path3.join(opts.projectRoot, ".wrongstack", "config.json"),
+    inProjectAgentsFile: path3.join(opts.projectRoot, ".wrongstack", "AGENTS.md"),
+    inProjectSkills: path3.join(opts.projectRoot, ".wrongstack", "skills"),
+    inProjectClaudeSkills: path3.join(opts.projectRoot, ".claude", "skills"),
+    inProjectPrompts: path3.join(opts.projectRoot, ".wrongstack", "prompts"),
+    inProjectInstructions: path3.join(opts.projectRoot, ".wrongstack", "instructions"),
+    inProjectDesignKits: path3.join(opts.projectRoot, ".wrongstack", "design-kits"),
+    inProjectWorktrees: path3.join(opts.projectRoot, ".wrongstack", "worktrees"),
+    projectHash: hash,
+    projectSlug: slug,
+    projectGoal: path3.join(projectDir, "goal.json"),
+    projectInputHistory: path3.join(projectDir, "input-history.json"),
+    projectSpecs: path3.join(projectDir, "specs"),
+    projectTaskGraphs: path3.join(projectDir, "task-graphs"),
+    projectSddSession: path3.join(projectDir, "sdd-session.json"),
+    projectPlan: path3.join(projectDir, "plan.json"),
+    projectAutophase: path3.join(projectDir, "autophase"),
+    projectSddBoards: path3.join(projectDir, "sdd-boards"),
+    syncConfig: path3.join(profileDir, "sync.json"),
+    configHistoryDir: path3.join(globalRoot, "config-history"),
+    projectStatus: (projectHash2) => path3.join(globalRoot, "projects", projectHash2, "status.json")
+  };
+}
+
+// src/utils/memory-flight-recorder.ts
+var MB = 1024 * 1024;
+var HOUR_MS = 60 * 60 * 1e3;
+var DEFAULT_WINDOW_MS = 5 * 60 * 1e3;
+var DEFAULT_MINIMUM_WINDOW_MS = 2 * 60 * 1e3;
+var DEFAULT_COOLDOWN_MS = 15 * 60 * 1e3;
+var DEFAULT_CONTINUOUS_CAPTURE_MS = 5 * 60 * 1e3;
+var MAX_OBSERVATIONS = 24;
+var MAX_CAPTURE_SESSIONS = 12;
+var MAX_CAPTURES_PER_SESSION = 6;
+var SESSION_MAX_AGE_MS = 7 * 24 * HOUR_MS;
+function timestampSlug(date = /* @__PURE__ */ new Date()) {
+  return date.toISOString().replaceAll(":", "").replaceAll(".", "-");
+}
+async function pruneCaptureFiles(artifactDir) {
+  const entries = await fsp2.readdir(artifactDir, { withFileTypes: true });
+  const captures = entries.filter(
+    (entry) => entry.isFile() && entry.name.startsWith("event-") && entry.name.endsWith(".json")
+  ).map((entry) => entry.name).sort();
+  const remove = captures.slice(0, Math.max(0, captures.length - MAX_CAPTURES_PER_SESSION));
+  await Promise.all(
+    remove.flatMap((eventName) => {
+      const stem = eventName.slice("event-".length, -".json".length);
+      return [
+        fsp2.rm(path4.join(artifactDir, eventName), { force: true }),
+        fsp2.rm(path4.join(artifactDir, `allocations-${stem}.heapprofile`), { force: true }),
+        fsp2.rm(path4.join(artifactDir, `allocations-${stem}.pb.gz`), { force: true })
+      ];
+    })
+  );
+}
+async function pruneOldSessions(root, currentDir) {
+  const entries = await fsp2.readdir(root, { withFileTypes: true });
+  const sessions = await Promise.all(
+    entries.filter((entry) => entry.isDirectory() && entry.name !== path4.basename(currentDir)).map(async (entry) => {
+      const fullPath = path4.join(root, entry.name);
+      const stat3 = await fsp2.stat(fullPath);
+      return { fullPath, mtimeMs: stat3.mtimeMs };
+    })
+  );
+  sessions.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  const now = Date.now();
+  await Promise.all(
+    sessions.filter(
+      (session, index) => now - session.mtimeMs > SESSION_MAX_AGE_MS || index >= MAX_CAPTURE_SESSIONS && now - session.mtimeMs > 24 * HOUR_MS
+    ).map((session) => fsp2.rm(session.fullPath, { recursive: true, force: true }))
+  );
+}
+var ContinuousMemoryCaptureWriter = class {
+  artifactDir;
+  root;
+  ready;
+  profiler;
+  profilerBackend = "initializing";
+  fallbackReason;
+  startError;
+  lastSummary;
+  stopped = false;
+  constructor(root) {
+    this.root = root;
+    this.artifactDir = path4.join(root, `${timestampSlug()}-pid-${process.pid}`);
+    this.ready = this.start().catch((error) => {
+      this.startError = error instanceof Error ? error.message : String(error);
+      this.profilerBackend = "unavailable";
+    });
+  }
+  async start() {
+    const started = await startContinuousMemoryProfiler();
+    this.profiler = started.profiler;
+    this.profilerBackend = started.profiler.backend;
+    this.fallbackReason = started.fallbackReason;
+  }
+  diagnostics() {
+    return {
+      memoryProfilerBackend: this.profilerBackend,
+      ...this.fallbackReason ? { memoryProfilerFallbackReason: this.fallbackReason } : {},
+      ...this.startError ? { memoryProfilerStartError: this.startError } : {},
+      ...this.lastSummary ? {
+        memoryProfileSampledBytes: this.lastSummary.sampledBytes,
+        memoryProfileSampledObjects: this.lastSummary.sampledObjects,
+        memoryProfileSampleCount: this.lastSummary.sampleCount,
+        memoryProfileTopStack: this.lastSummary.topStack,
+        memoryProfileTopStackBytes: this.lastSummary.topStackBytes
+      } : {}
+    };
+  }
+  async capture(event) {
+    await this.ready;
+    if (this.stopped) return;
+    let profile;
+    let captureError = this.startError;
+    if (!captureError && this.profiler) {
+      try {
+        profile = await this.profiler.capture();
+        const top = profile.summary?.topStacks[0];
+        if (profile.summary) {
+          this.lastSummary = {
+            sampledBytes: profile.summary.sampledBytes,
+            sampledObjects: profile.summary.sampledObjects,
+            sampleCount: profile.summary.sampleCount,
+            topStack: top?.frames.join(" <- "),
+            topStackBytes: top?.bytes
+          };
+        }
+      } catch (error) {
+        captureError = error instanceof Error ? error.message : String(error);
+      }
+    }
+    await fsp2.mkdir(this.artifactDir, { recursive: true });
+    const stem = `${timestampSlug(new Date(event.capturedAt))}-${event.reason}`;
+    await fsp2.writeFile(
+      path4.join(this.artifactDir, `event-${stem}.json`),
+      `${JSON.stringify(
+        {
+          ...event,
+          profilerBackend: profile?.backend ?? this.profilerBackend,
+          ...profile?.summary ? { allocationSummary: profile.summary } : {},
+          ...this.fallbackReason ? { profilerFallbackReason: this.fallbackReason } : {},
+          ...captureError ? { captureError } : {}
+        },
+        null,
+        2
+      )}
+`,
+      "utf8"
+    );
+    if (profile) {
+      await fsp2.writeFile(
+        path4.join(this.artifactDir, `allocations-${stem}${profile.extension}`),
+        profile.data
+      );
+    }
+    await Promise.all([
+      pruneCaptureFiles(this.artifactDir),
+      fsp2.mkdir(this.root, { recursive: true }).then(() => pruneOldSessions(this.root, this.artifactDir))
+    ]);
+  }
+  async stop() {
+    if (this.stopped) return;
+    this.stopped = true;
+    await this.ready;
+    await this.profiler?.stop();
+  }
+};
+function disabledWriter(artifactDir) {
+  return {
+    artifactDir,
+    capture: async () => void 0,
+    stop: async () => void 0
+  };
+}
+function createMemoryFlightRecorder(options = {}) {
+  const now = options.now ?? Date.now;
+  const startedAt = now();
+  const root = options.diagnosticsRoot ?? path4.join(wstackGlobalRoot(), "diagnostics", "memory");
+  const enabled = options.enabled ?? (process.env["WRONGSTACK_MEMORY_FLIGHT_RECORDER"] !== "0" && process.env["NODE_ENV"] !== "test");
+  const writer = options.captureWriter ?? (enabled ? new ContinuousMemoryCaptureWriter(root) : disabledWriter(path4.join(root, `${timestampSlug()}-pid-${process.pid}`)));
+  const observations = [];
+  const windowMs = options.windowMs ?? DEFAULT_WINDOW_MS;
+  const minimumWindowMs = options.minimumWindowMs ?? DEFAULT_MINIMUM_WINDOW_MS;
+  const cooldownMs = options.cooldownMs ?? DEFAULT_COOLDOWN_MS;
+  const continuousCaptureMs = options.continuousCaptureMs ?? DEFAULT_CONTINUOUS_CAPTURE_MS;
+  const warmupMs = options.warmupMs ?? 6e4;
+  let lastSignalCaptureAt = Number.NEGATIVE_INFINITY;
+  let lastContinuousCaptureAt = startedAt;
+  let captureInFlight = false;
+  let capturePromise;
+  const observe = (sample, stats) => {
+    const at = now();
+    const postGcHeapUsed = typeof stats["postGcHeapUsed"] === "number" ? stats["postGcHeapUsed"] : 0;
+    const postMajorGcHeapUsed = typeof stats["postMajorGcHeapUsed"] === "number" ? stats["postMajorGcHeapUsed"] : 0;
+    const lastGcAgoMs = typeof stats["lastGcAgoMs"] === "number" ? stats["lastGcAgoMs"] : -1;
+    const lastMajorGcAgoMs = typeof stats["lastMajorGcAgoMs"] === "number" ? stats["lastMajorGcAgoMs"] : -1;
+    const retainedHeapUsed = postMajorGcHeapUsed > 0 && lastMajorGcAgoMs >= 0 && lastMajorGcAgoMs <= windowMs ? postMajorGcHeapUsed : postGcHeapUsed > 0 && lastGcAgoMs >= 0 && lastGcAgoMs <= minimumWindowMs ? postGcHeapUsed : sample.heapUsed;
+    observations.push({
+      at,
+      heapUsed: retainedHeapUsed,
+      rss: sample.rss,
+      nativeResidual: sample.nativeResidual ?? 0
+    });
+    while (observations.length > MAX_OBSERVATIONS || observations.length > 1 && at - (observations[0]?.at ?? at) > windowMs) {
+      observations.shift();
+    }
+    const first = observations[0] ?? observations.at(-1);
+    const elapsedMs = first ? Math.max(0, at - first.at) : 0;
+    const heapGrowthBytes = first ? retainedHeapUsed - first.heapUsed : 0;
+    const rssGrowthBytes = first ? sample.rss - first.rss : 0;
+    const nativeGrowthBytes = first ? (sample.nativeResidual ?? 0) - first.nativeResidual : 0;
+    const heapGrowthBytesPerHour = elapsedMs > 0 ? Math.round(heapGrowthBytes / elapsedMs * HOUR_MS) : 0;
+    const rssGrowthBytesPerHour = elapsedMs > 0 ? Math.round(rssGrowthBytes / elapsedMs * HOUR_MS) : 0;
+    const nativeGrowthBytesPerHour = elapsedMs > 0 ? Math.round(nativeGrowthBytes / elapsedMs * HOUR_MS) : 0;
+    let signal = "stable";
+    if ((sample.detachedContexts ?? 0) > 0) signal = "detached-contexts";
+    else if (heapGrowthBytes >= 32 * MB && heapGrowthBytesPerHour > 0) signal = "js-retention";
+    else if (nativeGrowthBytes >= 64 * MB && nativeGrowthBytesPerHour > 0) signal = "native-rss";
+    const diagnosis = {
+      memorySignal: signal,
+      memoryWindowMs: elapsedMs,
+      retainedHeapUsed,
+      transientHeapBytes: Math.max(0, sample.heapUsed - retainedHeapUsed),
+      heapGrowthBytes,
+      rssGrowthBytes,
+      nativeGrowthBytes,
+      heapGrowthBytesPerHour,
+      rssGrowthBytesPerHour,
+      nativeGrowthBytesPerHour,
+      memoryArtifactDir: writer.artifactDir,
+      ...writer.diagnostics?.() ?? {}
+    };
+    let reason;
+    if (at - startedAt >= warmupMs) {
+      if ((sample.detachedContexts ?? 0) > 0) reason = "detached-contexts";
+      else if (sample.load >= 0.45) reason = "heap-load";
+      else if (sample.heapUsed >= (options.absoluteHeapBytes ?? 768 * MB)) {
+        reason = "absolute-heap";
+      } else if (elapsedMs >= minimumWindowMs && heapGrowthBytes >= (options.heapGrowthBytes ?? 32 * MB) && heapGrowthBytesPerHour >= (options.heapGrowthBytesPerHour ?? 192 * MB)) {
+        reason = "heap-growth";
+      } else if (elapsedMs >= minimumWindowMs && nativeGrowthBytes >= (options.nativeGrowthBytes ?? 128 * MB) && nativeGrowthBytesPerHour >= (options.nativeGrowthBytesPerHour ?? 256 * MB)) {
+        reason = "native-rss-growth";
+      }
+    }
+    const signalCaptureDue = reason !== void 0 && at - lastSignalCaptureAt >= cooldownMs;
+    const intervalCaptureDue = at - lastContinuousCaptureAt >= continuousCaptureMs;
+    const captureReason = signalCaptureDue ? reason : intervalCaptureDue ? "interval" : void 0;
+    if (enabled && captureReason && !captureInFlight) {
+      if (captureReason !== "interval") lastSignalCaptureAt = at;
+      lastContinuousCaptureAt = at;
+      captureInFlight = true;
+      diagnosis["memoryCaptureReason"] = captureReason;
+      capturePromise = writer.capture({
+        reason: captureReason,
+        capturedAt: new Date(at).toISOString(),
+        pid: process.pid,
+        sample,
+        stats,
+        diagnosis: { ...diagnosis },
+        observations: observations.map((observation) => ({ ...observation }))
+      }).catch(() => {
+      }).finally(() => {
+        captureInFlight = false;
+        capturePromise = void 0;
+      });
+    }
+    return diagnosis;
+  };
+  return {
+    artifactDir: writer.artifactDir,
+    observe,
+    stop: async () => {
+      await capturePromise;
+      await writer.stop();
+    }
+  };
+}
+
+// src/utils/heap-watchdog.ts
+var MB2 = 1024 * 1024;
+function defaultHeapLogPath() {
+  const override = process.env["WRONGSTACK_HEAP_LOG_PATH"]?.trim();
+  if (override) return path5.resolve(override);
+  return path5.join(wstackGlobalRoot(), "logs", "heap.jsonl");
+}
+function takeHeapSample() {
+  const m = process.memoryUsage();
+  const heap = v8.getHeapStatistics();
+  const spaces = v8.getHeapSpaceStatistics();
+  const spaceUsed = (name) => spaces.find((space) => space.space_name === name)?.space_used_size ?? 0;
+  const limit = heap.heap_size_limit || 0;
+  let activeResources = 0;
+  let activeResourceTypes = "";
+  try {
+    const resources = process.getActiveResourcesInfo?.() ?? [];
+    activeResources = resources.length;
+    const counts = /* @__PURE__ */ new Map();
+    for (const resource of resources) counts.set(resource, (counts.get(resource) ?? 0) + 1);
+    activeResourceTypes = [...counts].sort(([left], [right]) => left.localeCompare(right)).map(([resource, count]) => `${resource}=${count}`).join(",");
+  } catch {
+  }
+  return {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    rss: m.rss,
+    heapUsed: m.heapUsed,
+    heapTotal: m.heapTotal,
+    external: m.external,
+    arrayBuffers: m.arrayBuffers,
+    nativeResidual: Math.max(0, m.rss - m.heapTotal - m.external),
+    oldSpaceUsed: spaceUsed("old_space"),
+    newSpaceUsed: spaceUsed("new_space"),
+    largeObjectSpaceUsed: spaceUsed("large_object_space"),
+    codeSpaceUsed: spaceUsed("code_space"),
+    mallocedMemory: heap.malloced_memory,
+    peakMallocedMemory: heap.peak_malloced_memory,
+    nativeContexts: heap.number_of_native_contexts,
+    detachedContexts: heap.number_of_detached_contexts,
+    activeResources,
+    activeResourceTypes,
+    heapLimit: limit,
+    load: limit > 0 ? m.heapUsed / limit : 0
+  };
+}
+function startHeapWatchdog(opts = {}) {
+  const profileMode = process.env["WRONGSTACK_MEMORY_PROFILE"] === "1";
+  const sampleEveryMs = opts.sampleEveryMs ?? (profileMode ? 5e3 : 3e4);
+  const logEveryMs = opts.logEveryMs ?? (profileMode ? 5e3 : 6e4);
+  const logPath = opts.logPath ?? defaultHeapLogPath();
+  const warnAt = opts.warnAt ?? 0.6;
+  const criticalAt = opts.criticalAt ?? 0.85;
+  const REARM_MARGIN = 0.05;
+  let warnArmed = true;
+  let criticalArmed = true;
+  let lastLogAt = 0;
+  let writeInFlight = false;
+  let pendingLine;
+  let drainPromise;
+  let stopped = false;
+  let dirReady = false;
+  const flightRecorder = createMemoryFlightRecorder();
+  let gcMajorCount = 0;
+  let gcMinorCount = 0;
+  let gcIncrementalCount = 0;
+  let gcWeakCallbackCount = 0;
+  let gcDurationMs = 0;
+  let postGcHeapUsed = 0;
+  let postMajorGcHeapUsed = 0;
+  let lastGcAt = 0;
+  let lastMajorGcAt = 0;
+  const gcObserver = new PerformanceObserver((list) => {
+    for (const entry of list.getEntries()) {
+      const kind = entry.detail?.kind ?? 0;
+      if ((kind & performanceConstants.NODE_PERFORMANCE_GC_MAJOR) !== 0) gcMajorCount++;
+      if ((kind & performanceConstants.NODE_PERFORMANCE_GC_MINOR) !== 0) gcMinorCount++;
+      if ((kind & performanceConstants.NODE_PERFORMANCE_GC_INCREMENTAL) !== 0) {
+        gcIncrementalCount++;
+      }
+      if ((kind & performanceConstants.NODE_PERFORMANCE_GC_WEAKCB) !== 0) gcWeakCallbackCount++;
+      gcDurationMs += entry.duration;
+      postGcHeapUsed = process.memoryUsage().heapUsed;
+      if ((kind & performanceConstants.NODE_PERFORMANCE_GC_MAJOR) !== 0) {
+        postMajorGcHeapUsed = postGcHeapUsed;
+        lastMajorGcAt = Date.now();
+      }
+      lastGcAt = Date.now();
+    }
+  });
+  try {
+    gcObserver.observe({ entryTypes: ["gc"] });
+  } catch {
+  }
+  const collectRuntimeStats = () => ({
+    gcMajorCount,
+    gcMinorCount,
+    gcIncrementalCount,
+    gcWeakCallbackCount,
+    gcDurationMs: Math.round(gcDurationMs),
+    postGcHeapUsed,
+    postMajorGcHeapUsed,
+    lastGcAgoMs: lastGcAt > 0 ? Date.now() - lastGcAt : -1,
+    lastMajorGcAgoMs: lastMajorGcAt > 0 ? Date.now() - lastMajorGcAt : -1
+  });
+  const writeDiagnosticLine = opts.writeDiagnosticLine ?? (async (targetPath, line) => {
+    if (!dirReady) {
+      await fsp3.mkdir(path5.dirname(targetPath), { recursive: true });
+      dirReady = true;
+    }
+    await fsp3.appendFile(targetPath, `${line}
+`, { encoding: "utf8", mode: 384 });
+  });
+  const drainWrites = async (firstLine) => {
+    let line = firstLine;
+    while (line !== void 0) {
+      try {
+        await writeDiagnosticLine(logPath, line);
+      } catch {
+      }
+      line = pendingLine;
+      pendingLine = void 0;
+    }
+    writeInFlight = false;
+  };
+  const append = (line) => {
+    if (stopped) return;
+    if (writeInFlight) {
+      pendingLine = line;
+      return;
+    }
+    writeInFlight = true;
+    drainPromise = drainWrites(line);
+  };
+  const appendTerminalSample = (event, error, origin) => {
+    if (stopped) return;
+    let extras = {};
+    try {
+      extras = opts.collectStats?.() ?? {};
+    } catch {
+    }
+    try {
+      const sample = takeHeapSample();
+      const runtimeStats = collectRuntimeStats();
+      fs4.mkdirSync(path5.dirname(logPath), { recursive: true });
+      fs4.appendFileSync(
+        logPath,
+        `${JSON.stringify({
+          ...extras,
+          ...runtimeStats,
+          event,
+          ...origin ? { crashOrigin: origin } : {},
+          ...error instanceof Error ? { errorName: error.name, errorMessage: error.message.slice(0, 1e3) } : {},
+          pid: process.pid,
+          ...sample,
+          exitCode: process.exitCode
+        })}
+`,
+        "utf8"
+      );
+    } catch {
+    }
+  };
+  const onUncaughtException = (error, origin) => {
+    appendTerminalSample("memory.flight_recorder.crash", error, origin);
+  };
+  const onProcessExit = () => {
+    appendTerminalSample("memory.flight_recorder.exit");
+  };
+  process.on("uncaughtExceptionMonitor", onUncaughtException);
+  process.on("exit", onProcessExit);
+  const tick = () => {
+    let userTimings = 0;
+    try {
+      userTimings = performance.getEntriesByType("mark").length + performance.getEntriesByType("measure").length;
+      if (userTimings > 0) {
+        performance.clearMarks();
+        performance.clearMeasures();
+      }
+    } catch {
+    }
+    const s = takeHeapSample();
+    let extras = {};
+    try {
+      extras = opts.collectStats?.() ?? {};
+    } catch {
+    }
+    const runtimeStats = collectRuntimeStats();
+    const diagnosticStats = { ...extras, ...runtimeStats };
+    const memoryDiagnosis = flightRecorder.observe(s, diagnosticStats);
+    if (s.load >= criticalAt && criticalArmed) {
+      criticalArmed = false;
+      warnArmed = false;
+      opts.onWarn?.(
+        "critical",
+        `Heap critical: ${Math.round(s.heapUsed / MB2)} MB of ~${Math.round(s.heapLimit / MB2)} MB V8 limit (${Math.round(s.load * 100)}%). An out-of-memory crash is likely soon \u2014 finish/checkpoint work and restart the session. Diagnostics: ${logPath}`,
+        s
+      );
+    } else if (s.load >= warnAt && warnArmed) {
+      warnArmed = false;
+      opts.onWarn?.(
+        "warn",
+        `Heap high: ${Math.round(s.heapUsed / MB2)} MB of ~${Math.round(s.heapLimit / MB2)} MB V8 limit (${Math.round(s.load * 100)}%). Memory diagnostics are being recorded to ${logPath}`,
+        s
+      );
+    }
+    if (!warnArmed && s.load < warnAt - REARM_MARGIN) warnArmed = true;
+    if (!criticalArmed && s.load < criticalAt - REARM_MARGIN) criticalArmed = true;
+    const due = Date.now() - lastLogAt >= logEveryMs;
+    const crossed = s.load >= warnAt;
+    const captured = typeof memoryDiagnosis["memoryCaptureReason"] === "string";
+    if (due || crossed || captured) {
+      lastLogAt = Date.now();
+      append(
+        JSON.stringify({
+          ...extras,
+          ...runtimeStats,
+          ...memoryDiagnosis,
+          pid: process.pid,
+          ...s,
+          userTimings
+        })
+      );
+    }
+  };
+  const timer = setInterval(tick, sampleEveryMs);
+  timer.unref?.();
+  tick();
+  return async () => {
+    stopped = true;
+    clearInterval(timer);
+    gcObserver.disconnect();
+    process.removeListener("uncaughtExceptionMonitor", onUncaughtException);
+    process.removeListener("exit", onProcessExit);
+    await drainPromise;
+    await flightRecorder.stop();
+  };
+}
+var sharedContributors = /* @__PURE__ */ new Map();
+var nextSharedContributorId = 1;
+var sharedSamplerActive = false;
+var stopSharedSampler;
+function collectSharedStats() {
+  const merged = {};
+  for (const contributor of sharedContributors.values()) {
+    try {
+      Object.assign(merged, contributor.collectStats?.() ?? {});
+    } catch {
+    }
+  }
+  return merged;
+}
+function warnSharedContributors(level, message, sample) {
+  for (const contributor of sharedContributors.values()) {
+    try {
+      contributor.onWarn?.(level, message, sample);
+    } catch {
+    }
+  }
+}
+function startSharedHeapWatchdog(opts = {}) {
+  if (process.env["NODE_ENV"] === "test" && !sharedSamplerActive && opts.logPath === void 0 && opts.writeDiagnosticLine === void 0) {
+    return async () => void 0;
+  }
+  const id = nextSharedContributorId++;
+  sharedContributors.set(id, {
+    collectStats: opts.collectStats,
+    onWarn: opts.onWarn
+  });
+  if (!sharedSamplerActive) {
+    sharedSamplerActive = true;
+    stopSharedSampler = startHeapWatchdog({
+      ...opts,
+      collectStats: collectSharedStats,
+      onWarn: warnSharedContributors
+    });
+  }
+  let stopped = false;
+  return async () => {
+    if (stopped) return;
+    stopped = true;
+    sharedContributors.delete(id);
+    if (sharedContributors.size > 0 || !sharedSamplerActive) return;
+    const stop = stopSharedSampler;
+    if (!stop) return;
+    sharedSamplerActive = false;
+    stopSharedSampler = void 0;
+    await stop();
+  };
+}
+
+// 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"
+]);
+function isAllowedImageMediaType(mediaType) {
+  return ALLOWED_IMAGE_MEDIA_TYPES.has(mediaType.toLowerCase());
+}
+function isValidImageBase64(base64) {
+  return /^[A-Za-z0-9+/]+={0,2}$/.test(base64);
+}
+function base64DecodedBytes(base64) {
+  return Math.floor(base64.length * 3 / 4);
+}
+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()
+  };
+}
+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)) {
+    if (!isAllowedImageMediaType(mediaType)) {
       throw new IncomingImageError(
         `Image ${i + 1}: unsupported media type "${mediaType}" (allowed: ${[...ALLOWED_IMAGE_MEDIA_TYPES].join(", ")}).`
       );
@@ -2206,10 +3162,10 @@ function parseIncomingImages(images, legacyImageBase64) {
     if (!base64) {
       throw new IncomingImageError(`Image ${i + 1}: empty image data.`);
     }
-    if (!/^[A-Za-z0-9+/]+={0,2}$/.test(base64)) {
+    if (!isValidImageBase64(base64)) {
       throw new IncomingImageError(`Image ${i + 1}: data is not valid base64.`);
     }
-    const bytes = Math.floor(base64.length * 3 / 4);
+    const bytes = base64DecodedBytes(base64);
     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.`
@@ -2227,6 +3183,51 @@ function buildUserContentBlocks(text, images) {
   return blocks;
 }
 
+// src/utils/instruction-file.ts
+import { readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
+import * as path6 from "node:path";
+import { fileURLToPath } from "node:url";
+var textCache = /* @__PURE__ */ new Map();
+var rootCandidates;
+function readBundledInstructionText(relativePath) {
+  const cached2 = textCache.get(relativePath);
+  if (cached2 !== void 0) return cached2;
+  let resolved = "";
+  for (const root of instructionRootCandidates()) {
+    try {
+      resolved = readFileSync2(path6.join(root, relativePath), "utf8").trimEnd();
+      break;
+    } catch {
+    }
+  }
+  textCache.set(relativePath, resolved);
+  return resolved;
+}
+function renderInstructionTemplate(template, values) {
+  return template.replace(
+    /\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g,
+    (match, key) => Object.hasOwn(values, key) ? values[key] ?? "" : match
+  );
+}
+function instructionRootCandidates() {
+  if (rootCandidates !== void 0) return rootCandidates;
+  const here = path6.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path6.resolve(here, "../../instructions"),
+    path6.resolve(here, "../instructions"),
+    path6.resolve(here, "instructions")
+  ];
+  rootCandidates = candidates.sort((a, b) => Number(!isDirectory(a)) - Number(!isDirectory(b)));
+  return rootCandidates;
+}
+function isDirectory(candidate) {
+  try {
+    return statSync2(candidate).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
 // src/utils/ip-guard.ts
 import * as dns from "node:dns/promises";
 import * as net from "node:net";
@@ -2252,6 +3253,7 @@ function isPrivateIPv6(raw) {
   if (lower === "::" || lower === "::1") return true;
   const groups = expandIPv6(lower);
   if (!groups) return true;
+  if (groups[0] === 100 && groups[1] === 65435 && groups[2] === 1) 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;
@@ -2259,12 +3261,36 @@ function isPrivateIPv6(raw) {
     const d = (groups[7] ?? 0) & 255;
     return isPrivateIPv4(`${a}.${b}.${c}.${d}`);
   }
+  const embedded = embeddedIPv4(groups);
+  if (embedded) return isPrivateIPv4(embedded);
   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 quad(hi, lo) {
+  return `${(hi ?? 0) >> 8}.${(hi ?? 0) & 255}.${(lo ?? 0) >> 8}.${(lo ?? 0) & 255}`;
+}
+function embeddedIPv4(groups) {
+  const g = (i) => groups[i] ?? 0;
+  if (g(0) === 100 && g(1) === 65435) {
+    if (g(2) === 0 && g(3) === 0 && g(4) === 0 && g(5) === 0) {
+      return quad(g(6), g(7));
+    }
+  }
+  if (g(0) === 8194) return quad(g(1), g(2));
+  if (g(0) === 8193 && g(1) === 0) {
+    return quad(~g(6) & 65535, ~g(7) & 65535);
+  }
+  if ((g(4) === 0 || g(4) === 512) && g(5) === 24318) {
+    return quad(g(6), g(7));
+  }
+  const highZero = g(0) === 0 && g(1) === 0 && g(2) === 0 && g(3) === 0;
+  if (highZero && g(4) === 65535 && g(5) === 0) return quad(g(6), g(7));
+  if (highZero && g(4) === 0 && g(5) === 0) return quad(g(6), g(7));
+  return void 0;
+}
 function expandIPv6(addr) {
   const parts = addr.split("::");
   if (parts.length > 2) return null;
@@ -2320,51 +3346,6 @@ async function assertNotPrivateHost(hostname) {
   }
 }
 
-// src/utils/instruction-file.ts
-import { readFileSync, statSync } from "node:fs";
-import * as path3 from "node:path";
-import { fileURLToPath } from "node:url";
-var textCache = /* @__PURE__ */ new Map();
-var rootCandidates;
-function readBundledInstructionText(relativePath) {
-  const cached2 = textCache.get(relativePath);
-  if (cached2 !== void 0) return cached2;
-  let resolved = "";
-  for (const root of instructionRootCandidates()) {
-    try {
-      resolved = readFileSync(path3.join(root, relativePath), "utf8").trimEnd();
-      break;
-    } catch {
-    }
-  }
-  textCache.set(relativePath, resolved);
-  return resolved;
-}
-function renderInstructionTemplate(template, values) {
-  return template.replace(
-    /\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g,
-    (match, key) => Object.hasOwn(values, key) ? values[key] ?? "" : match
-  );
-}
-function instructionRootCandidates() {
-  if (rootCandidates !== void 0) return rootCandidates;
-  const here = path3.dirname(fileURLToPath(import.meta.url));
-  const candidates = [
-    path3.resolve(here, "../../instructions"),
-    path3.resolve(here, "../instructions"),
-    path3.resolve(here, "instructions")
-  ];
-  rootCandidates = candidates.sort((a, b) => Number(!isDirectory(a)) - Number(!isDirectory(b)));
-  return rootCandidates;
-}
-function isDirectory(candidate) {
-  try {
-    return statSync(candidate).isDirectory();
-  } catch {
-    return false;
-  }
-}
-
 // src/utils/json-repair.ts
 function completePartialObject(s) {
   if (!s.trim().startsWith("{")) return s;
@@ -2464,10 +3445,10 @@ function validateAgainstSchema(value, schema) {
   return { ok: errors.length === 0, errors };
 }
 var MAX_SCHEMA_DEPTH = 64;
-function walk(value, schema, path9, errors, depth) {
+function walk(value, schema, path11, errors, depth) {
   if (depth > MAX_SCHEMA_DEPTH) {
     errors.push({
-      path: path9 || "<root>",
+      path: path11 || "<root>",
       message: `schema nesting exceeds maximum depth (${MAX_SCHEMA_DEPTH})`
     });
     return;
@@ -2475,7 +3456,7 @@ function walk(value, schema, path9, errors, depth) {
   if (schema.enum !== void 0) {
     if (!enumIncludes(schema.enum, value)) {
       errors.push({
-        path: path9 || "<root>",
+        path: path11 || "<root>",
         message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
       });
       return;
@@ -2484,7 +3465,7 @@ function walk(value, schema, path9, errors, depth) {
   if (typeof schema.type === "string") {
     if (!checkType(value, schema.type)) {
       errors.push({
-        path: path9 || "<root>",
+        path: path11 || "<root>",
         message: `expected ${schema.type}, got ${describeType(value)} (${previewValue(value)})`
       });
       return;
@@ -2496,7 +3477,7 @@ function walk(value, schema, path9, errors, depth) {
       if (!(req in obj)) {
         const expected = schema.properties?.[req]?.type;
         errors.push({
-          path: joinPath(path9, req),
+          path: joinPath(path11, req),
           message: `required property missing${typeof expected === "string" ? ` (expected ${expected})` : ""}`
         });
       }
@@ -2504,14 +3485,14 @@ function walk(value, schema, path9, errors, depth) {
     if (schema.properties) {
       for (const [key, subSchema] of Object.entries(schema.properties)) {
         if (key in obj) {
-          walk(obj[key], subSchema, joinPath(path9, key), errors, depth + 1);
+          walk(obj[key], subSchema, joinPath(path11, 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, `${path9}[${i}]`, errors, depth + 1);
+      walk(value[i], schema.items, `${path11}[${i}]`, errors, depth + 1);
     }
   }
 }
@@ -2768,6 +3749,29 @@ function normalizeToLf(text) {
   return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
 }
 
+// src/utils/path-segment.ts
+import * as path7 from "node:path";
+var MAX_PATH_SEGMENT_LENGTH = 256;
+function isSafePathSegment(value) {
+  if (value.length === 0 || value.length > MAX_PATH_SEGMENT_LENGTH) return false;
+  if (value === "." || value === "..") return false;
+  if (value.includes("/") || value.includes("\\")) return false;
+  if (value.includes("\0")) return false;
+  if (value.includes(":")) return false;
+  return true;
+}
+function resolveContainedPath(root, ...segments) {
+  if (segments.length === 0) return null;
+  for (const segment of segments) {
+    if (!isSafePathSegment(segment)) return null;
+  }
+  const resolvedRoot = path7.resolve(root);
+  const candidate = path7.resolve(resolvedRoot, ...segments);
+  if (candidate === resolvedRoot) return null;
+  if (!candidate.startsWith(resolvedRoot + path7.sep)) return null;
+  return candidate;
+}
+
 // src/utils/perf-profile.ts
 var daemonDefaults = false;
 function useDaemonPerfDefaults() {
@@ -2825,9 +3829,9 @@ function isPidAlive(pid) {
 }
 
 // src/utils/project-identity.ts
-import * as fs3 from "node:fs";
+import * as fs5 from "node:fs";
 import * as fsPromises from "node:fs/promises";
-import * as path4 from "node:path";
+import * as path8 from "node:path";
 
 // src/utils/ulid.ts
 import { randomBytes } from "node:crypto";
@@ -2867,7 +3871,7 @@ function isUlid(value) {
 // src/utils/project-identity.ts
 var PROJECT_IDENTITY_VERSION = 1;
 var PROJECT_ID_PREFIX = "proj_";
-var PROJECT_IDENTITY_RELATIVE_PATH = path4.join(".wrongstack", "project.json");
+var PROJECT_IDENTITY_RELATIVE_PATH = path8.join(".wrongstack", "project.json");
 var PROJECT_GITIGNORE_RULES = [
   ".wrongstack/",
   "!/.wrongstack/",
@@ -2875,7 +3879,7 @@ var PROJECT_GITIGNORE_RULES = [
   "!/.wrongstack/project.json"
 ];
 function projectIdentityPath(projectRoot) {
-  return path4.join(projectRoot, PROJECT_IDENTITY_RELATIVE_PATH);
+  return path8.join(projectRoot, PROJECT_IDENTITY_RELATIVE_PATH);
 }
 function createProjectId(seedTime = Date.now()) {
   return `${PROJECT_ID_PREFIX}${ulid(seedTime)}`;
@@ -2886,7 +3890,7 @@ function isProjectId(value) {
 function readProjectIdentitySync(projectRoot) {
   const filePath = projectIdentityPath(projectRoot);
   try {
-    return parseProjectIdentity(fs3.readFileSync(filePath, "utf8"), filePath);
+    return parseProjectIdentity(fs5.readFileSync(filePath, "utf8"), filePath);
   } catch (error) {
     if (isMissingFileError(error)) return void 0;
     throw error;
@@ -2906,7 +3910,7 @@ async function ensureProjectIdentity(projectRoot, idFactory = createProjectId) {
   if (existing) return { identity: existing, created: false };
   const filePath = projectIdentityPath(projectRoot);
   const identity = makeIdentity(idFactory());
-  await fsPromises.mkdir(path4.dirname(filePath), { recursive: true });
+  await fsPromises.mkdir(path8.dirname(filePath), { recursive: true });
   try {
     await fsPromises.writeFile(filePath, serializeProjectIdentity(identity), {
       encoding: "utf8",
@@ -2924,12 +3928,12 @@ async function rekeyProjectIdentity(projectRoot, idFactory = createProjectId) {
   const previous = await readProjectIdentity(projectRoot);
   const identity = makeIdentity(idFactory());
   const filePath = projectIdentityPath(projectRoot);
-  await fsPromises.mkdir(path4.dirname(filePath), { recursive: true });
+  await fsPromises.mkdir(path8.dirname(filePath), { recursive: true });
   await atomicWrite(filePath, serializeProjectIdentity(identity));
   return { previous, identity };
 }
 async function ensureProjectGitignore(projectRoot) {
-  const filePath = path4.join(projectRoot, ".gitignore");
+  const filePath = path8.join(projectRoot, ".gitignore");
   let content = "";
   try {
     content = await fsPromises.readFile(filePath, "utf8");
@@ -2993,6 +3997,73 @@ function isAlreadyExistsError(error) {
   return error?.code === "EEXIST";
 }
 
+// src/utils/project-watch.ts
+import * as fs6 from "node:fs";
+import * as path9 from "node:path";
+var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("wrongstack.projectWatchRegistry");
+var globalScope = globalThis;
+if (!globalScope[REGISTRY_KEY]) globalScope[REGISTRY_KEY] = /* @__PURE__ */ new Map();
+var registry = globalScope[REGISTRY_KEY];
+function registryKey(root) {
+  const resolved = path9.resolve(root);
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function watchProjectTree(root, listener, opts) {
+  const key = registryKey(root);
+  let entry = registry.get(key);
+  if (!entry || entry.dead) {
+    const subscribers = /* @__PURE__ */ new Set();
+    const watcher = fs6.watch(
+      path9.resolve(root),
+      { recursive: true, persistent: false },
+      (eventType, filename) => {
+        const event = {
+          eventType: eventType === "rename" ? "rename" : "change",
+          filename: filename === null ? null : String(filename)
+        };
+        for (const sub of subscribers) {
+          try {
+            sub.listener(event);
+          } catch (error) {
+            sub.onError?.(error);
+          }
+        }
+      }
+    );
+    const created = { watcher, subscribers, dead: false };
+    const retire = () => {
+      created.dead = true;
+      if (registry.get(key) === created) registry.delete(key);
+    };
+    watcher.on("error", (error) => {
+      retire();
+      for (const sub of subscribers) sub.onError?.(error);
+    });
+    watcher.on("close", retire);
+    registry.set(key, created);
+    entry = created;
+  }
+  const active = entry;
+  const subscriber = { listener, onError: opts?.onError };
+  active.subscribers.add(subscriber);
+  let closed = false;
+  return {
+    close() {
+      if (closed) return;
+      closed = true;
+      active.subscribers.delete(subscriber);
+      if (active.subscribers.size === 0 && !active.dead) {
+        active.dead = true;
+        if (registry.get(key) === active) registry.delete(key);
+        try {
+          active.watcher.close();
+        } catch {
+        }
+      }
+    }
+  };
+}
+
 // src/utils/regex-guard.ts
 var MAX_PATTERN_LEN = 512;
 var DANGEROUS_PATTERNS = [
@@ -3169,14 +4240,14 @@ function stripJsonComments(s) {
 }
 
 // src/utils/session-scoped-path.ts
-import * as path5 from "node:path";
+import * as path10 from "node:path";
 function sessionScopedPath(dir, sessionId, suffix) {
   if (!sessionId || sessionId.includes("\\") || sessionId.includes("..")) {
     throw invalid(sessionId);
   }
-  const resolved = path5.resolve(dir, `${sessionId}${suffix}`);
-  const rel = path5.relative(path5.resolve(dir), resolved);
-  if (rel.startsWith("..") || path5.isAbsolute(rel)) {
+  const resolved = path10.resolve(dir, `${sessionId}${suffix}`);
+  const rel = path10.relative(path10.resolve(dir), resolved);
+  if (rel.startsWith("..") || path10.isAbsolute(rel)) {
     throw invalid(sessionId);
   }
   return resolved;
@@ -3190,6 +4261,16 @@ function invalid(sessionId) {
   });
 }
 
+// src/utils/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve9) => setTimeout(resolve9, ms));
+}
+
+// src/utils/slug.ts
+function slugify2(name, fallback = "prompt", maxLen = 64) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, maxLen).replace(/-+$/g, "") || fallback;
+}
+
 // src/utils/socket-path.ts
 import {
   assertUnixSocketPathWithinLimit,
@@ -3220,16 +4301,6 @@ function withSqliteExperimentalWarningSuppressed(run) {
   }
 }
 
-// src/utils/sleep.ts
-function sleep(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, 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`;
@@ -3471,6 +4542,23 @@ function findWordBoundary(text, limit) {
   return space > 40 ? space : limit;
 }
 
+// src/utils/tool-name.ts
+var WIRE_TOOL_NAME_MAX_LENGTH = 128;
+var WIRE_TOOL_NAME_PATTERN = /^[a-zA-Z0-9_-]{1,128}$/;
+function sanitizeWireToolName(name) {
+  const replaced = name.replace(/[^a-zA-Z0-9_-]/g, "_");
+  const clamped = replaced.slice(0, WIRE_TOOL_NAME_MAX_LENGTH);
+  return clamped.length > 0 ? clamped : "tool";
+}
+function mcpServerToolPrefix(serverName) {
+  return `mcp__${sanitizeWireToolName(serverName)}__`;
+}
+function mcpQualifiedToolName(serverName, toolName) {
+  return sanitizeWireToolName(
+    `${mcpServerToolPrefix(serverName)}${sanitizeWireToolName(toolName)}`
+  );
+}
+
 // src/utils/tool-output-serializer.ts
 var DEFAULT_LIST_LIMIT = 500;
 var LOG_ENTRY_LIMIT = 200;
@@ -3528,12 +4616,38 @@ function createToolOutputSerializer(opts = {}) {
       return { text: "[truncated: iteration output cap exceeded]", newBudget: 0 };
     }
     const half = Math.floor(available / 2);
-    const first = text.slice(0, half);
-    const second = text.slice(text.length - half);
+    const first = utf8Prefix(text, half);
+    const second = utf8Suffix(text, available - Buffer.byteLength(first, "utf8"));
     return { text: `${first}${marker}${second}`, newBudget: 0 };
   }
   return { serialize, enforceCap, capBytes };
 }
+function utf8Prefix(text, maxBytes) {
+  if (maxBytes <= 0) return "";
+  let low = 0;
+  let high = text.length;
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    if (Buffer.byteLength(text.slice(0, mid), "utf8") <= maxBytes) low = mid;
+    else high = mid - 1;
+  }
+  let end = low;
+  if (end > 0 && /[\uD800-\uDBFF]/.test(text[end - 1])) end--;
+  return text.slice(0, end);
+}
+function utf8Suffix(text, maxBytes) {
+  if (maxBytes <= 0) return "";
+  let low = 0;
+  let high = text.length;
+  while (low < high) {
+    const chars = Math.ceil((low + high) / 2);
+    if (Buffer.byteLength(text.slice(text.length - chars), "utf8") <= maxBytes) low = chars;
+    else high = chars - 1;
+  }
+  let start = text.length - low;
+  if (start < text.length && /[\uDC00-\uDFFF]/.test(text[start])) start++;
+  return text.slice(start);
+}
 function renderToolObject(toolName, obj, input) {
   if (toolName === "read" && typeof obj["text"] === "string") {
     return joinSections([
@@ -4182,13 +5296,43 @@ function normalizePathSubject(value) {
 function isPathSubjectKey(subjectKey) {
   return subjectKey === "path" || subjectKey === "file" || subjectKey === "files";
 }
+function renderCommandLine(command, args) {
+  if (!Array.isArray(args) || args.length === 0) return command;
+  const rendered = args.map((arg) => {
+    const str = String(arg);
+    return /\s/.test(str) ? `"${str.replace(/"/g, '\\"')}"` : str;
+  });
+  return [command, ...rendered].join(" ");
+}
 function subjectForToolInput(toolName, input, subjectKey) {
   if (!input || typeof input !== "object") return void 0;
   const obj = input;
   if (subjectKey) {
     const value = obj[subjectKey];
     if (typeof value === "string") {
-      return isPathSubjectKey(subjectKey) ? normalizePathSubject(value) : escapeGlobSubject(value);
+      if (isPathSubjectKey(subjectKey)) {
+        const normalized = normalizePathSubject(value);
+        if (subjectKey === "files" && obj["check"] === true) return `${normalized}:check`;
+        if (subjectKey === "files" && obj["dry_run"] === true) return `${normalized}:dry-run`;
+        return normalized;
+      }
+      if (subjectKey === "command") {
+        const rendered = renderCommandLine(value, obj["args"]);
+        if (value === "commit" && obj["dry_run"] === true) {
+          return `${escapeGlobSubject(rendered)}:dry-run`;
+        }
+        return escapeGlobSubject(rendered);
+      }
+      if (subjectKey === "directory" && obj["dry_run"] === true) {
+        return `${escapeGlobSubject(value)}:dry-run`;
+      }
+      if (subjectKey === "packages" && obj["dry_run"] === true) {
+        return `${escapeGlobSubject(value)}:dry-run`;
+      }
+      if (subjectKey === "name" && obj["dry_run"] === true) {
+        return `${escapeGlobSubject(value)}:dry-run`;
+      }
+      return escapeGlobSubject(value);
     }
   }
   if (toolName === "bash" && typeof obj.command === "string") {
@@ -4206,73 +5350,6 @@ function subjectForToolInput(toolName, input, subjectKey) {
   return void 0;
 }
 
-// src/utils/project-watch.ts
-import * as fs4 from "node:fs";
-import * as path6 from "node:path";
-var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("wrongstack.projectWatchRegistry");
-var globalScope = globalThis;
-if (!globalScope[REGISTRY_KEY]) globalScope[REGISTRY_KEY] = /* @__PURE__ */ new Map();
-var registry = globalScope[REGISTRY_KEY];
-function registryKey(root) {
-  const resolved = path6.resolve(root);
-  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
-}
-function watchProjectTree(root, listener, opts) {
-  const key = registryKey(root);
-  let entry = registry.get(key);
-  if (!entry || entry.dead) {
-    const subscribers = /* @__PURE__ */ new Set();
-    const watcher = fs4.watch(
-      path6.resolve(root),
-      { recursive: true, persistent: false },
-      (eventType, filename) => {
-        const event = {
-          eventType: eventType === "rename" ? "rename" : "change",
-          filename: filename === null ? null : String(filename)
-        };
-        for (const sub of subscribers) {
-          try {
-            sub.listener(event);
-          } catch (error) {
-            sub.onError?.(error);
-          }
-        }
-      }
-    );
-    const created = { watcher, subscribers, dead: false };
-    const retire = () => {
-      created.dead = true;
-      if (registry.get(key) === created) registry.delete(key);
-    };
-    watcher.on("error", (error) => {
-      retire();
-      for (const sub of subscribers) sub.onError?.(error);
-    });
-    watcher.on("close", retire);
-    registry.set(key, created);
-    entry = created;
-  }
-  const active = entry;
-  const subscriber = { listener, onError: opts?.onError };
-  active.subscribers.add(subscriber);
-  let closed = false;
-  return {
-    close() {
-      if (closed) return;
-      closed = true;
-      active.subscribers.delete(subscriber);
-      if (active.subscribers.size === 0 && !active.dead) {
-        active.dead = true;
-        if (registry.get(key) === active) registry.delete(key);
-        try {
-          active.watcher.close();
-        } catch {
-        }
-      }
-    }
-  };
-}
-
 // src/utils/walk-ignore.ts
 var DEFAULT_WALK_IGNORE_DIRS = Object.freeze([
   "node_modules",
@@ -4296,250 +5373,31 @@ var DEFAULT_WALK_IGNORE_DIRS = Object.freeze([
 ]);
 var DEFAULT_WALK_IGNORE_SET = new Set(DEFAULT_WALK_IGNORE_DIRS);
 
-// src/utils/wstack-paths.ts
-import { createHash as createHash2 } from "node:crypto";
-import * as fs5 from "node:fs";
-import * as os from "node:os";
-import * as path7 from "node:path";
-function canonicalProjectRoot(absRoot) {
-  const checkoutRoot = path7.resolve(absRoot);
-  const dotGit = path7.join(checkoutRoot, ".git");
-  try {
-    if (!fs5.statSync(dotGit).isFile()) return checkoutRoot;
-    const gitDirLine = fs5.readFileSync(dotGit, "utf8").trim();
-    const match = /^gitdir:\s*(.+)$/i.exec(gitDirLine);
-    if (!match?.[1]) return checkoutRoot;
-    const gitDir = path7.resolve(checkoutRoot, match[1].trim());
-    const commonDirFile = path7.join(gitDir, "commondir");
-    if (!fs5.statSync(commonDirFile).isFile()) return checkoutRoot;
-    const commonDir = path7.resolve(gitDir, fs5.readFileSync(commonDirFile, "utf8").trim());
-    if (path7.basename(commonDir).toLowerCase() !== ".git") return checkoutRoot;
-    return path7.dirname(commonDir);
-  } catch {
-    return checkoutRoot;
-  }
-}
-function projectHash(absRoot) {
-  return createHash2("sha256").update(canonicalProjectRoot(absRoot)).digest("hex").slice(0, 12);
-}
-function projectSlug(absRoot) {
-  const identityRoot = canonicalProjectRoot(absRoot);
-  const base = slugify2(path7.basename(identityRoot));
-  const hash = createHash2("sha256").update(identityRoot).digest("hex").slice(0, 6);
-  return `${base}-${hash}`;
-}
-function slugify2(name) {
-  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "project";
-}
-function safeProfileName(name) {
-  const safe = (name ?? "").replace(/[/\\:]/g, "_").replace(/\.\./g, "_").trim();
-  return safe || "default";
-}
-function activeProfileName(globalRoot) {
-  try {
-    const parsed = JSON.parse(fs5.readFileSync(path7.join(globalRoot, "config.json"), "utf8"));
-    return safeProfileName(typeof parsed.activeProfile === "string" ? parsed.activeProfile : void 0);
-  } catch {
-    return "default";
-  }
-}
-function wstackGlobalRoot() {
-  const fromEnv = process.env["WRONGSTACK_HOME"];
-  if (fromEnv && fromEnv.trim().length > 0) return path7.resolve(fromEnv);
-  return path7.join(os.homedir(), ".wrongstack");
-}
-function resolveWstackPaths(opts) {
-  const globalRoot = opts.globalRoot ?? (opts.userHome ? path7.join(opts.userHome, ".wrongstack") : wstackGlobalRoot());
-  const homeDir = opts.userHome ?? os.homedir();
-  const profileName = safeProfileName(opts.profileName ?? activeProfileName(globalRoot));
-  const profileDir = path7.join(globalRoot, "profiles", profileName);
-  const hash = projectHash(opts.projectRoot);
-  const slug = projectSlug(opts.projectRoot);
-  const projectDir = path7.join(globalRoot, "projects", slug);
-  return {
-    globalRoot,
-    profileName,
-    profileDir,
-    projectRoot: opts.projectRoot,
-    homeDir,
-    configDir: profileDir,
-    globalConfig: path7.join(globalRoot, "config.json"),
-    profilesDir: path7.join(globalRoot, "profiles"),
-    profileConfig: (name) => {
-      return path7.join(globalRoot, "profiles", safeProfileName(name), "config.json");
-    },
-    profileStatuslineConfig: (name) => {
-      return path7.join(globalRoot, "profiles", safeProfileName(name), "statusline.json");
-    },
-    profileModeConfig: (name) => {
-      return path7.join(globalRoot, "profiles", safeProfileName(name), "mode.json");
-    },
-    profileProviderStatus: (name) => {
-      return path7.join(globalRoot, "profiles", safeProfileName(name), "provider-status.json");
-    },
-    profileUpdateCache: (name) => {
-      return path7.join(globalRoot, "profiles", safeProfileName(name), "update-cache.json");
-    },
-    secretsKey: path7.join(globalRoot, ".key"),
-    globalMemory: path7.join(profileDir, "memory.md"),
-    globalSkills: path7.join(profileDir, "skills"),
-    globalClaudeSkills: path7.join(homeDir, ".claude", "skills"),
-    globalDesignKits: path7.join(profileDir, "design-kits"),
-    globalPrompts: path7.join(profileDir, "prompts"),
-    globalInstructions: path7.join(profileDir, "instructions"),
-    promptUsage: path7.join(profileDir, "prompt-usage.json"),
-    cacheDir: path7.join(globalRoot, "cache"),
-    modelsCache: path7.join(globalRoot, "cache", "models.dev.json"),
-    modelsOverlayCache: path7.join(globalRoot, "cache", "models-overlay.json"),
-    historyFile: path7.join(profileDir, "history"),
-    logFile: path7.join(globalRoot, "logs", "wrongstack.log"),
-    projectDir,
-    projectCodebaseIndex: path7.join(projectDir, "codebase-index"),
-    projectMemory: path7.join(projectDir, "memory.md"),
-    projectSessions: path7.join(projectDir, "sessions"),
-    projectTrust: path7.join(projectDir, "trust.json"),
-    projectMeta: path7.join(projectDir, "meta.json"),
-    projectLocalConfig: path7.join(projectDir, "config.local.json"),
-    inProjectConfig: path7.join(opts.projectRoot, ".wrongstack", "config.json"),
-    inProjectAgentsFile: path7.join(opts.projectRoot, ".wrongstack", "AGENTS.md"),
-    inProjectSkills: path7.join(opts.projectRoot, ".wrongstack", "skills"),
-    inProjectClaudeSkills: path7.join(opts.projectRoot, ".claude", "skills"),
-    inProjectPrompts: path7.join(opts.projectRoot, ".wrongstack", "prompts"),
-    inProjectInstructions: path7.join(opts.projectRoot, ".wrongstack", "instructions"),
-    inProjectDesignKits: path7.join(opts.projectRoot, ".wrongstack", "design-kits"),
-    inProjectWorktrees: path7.join(opts.projectRoot, ".wrongstack", "worktrees"),
-    projectHash: hash,
-    projectSlug: slug,
-    projectGoal: path7.join(projectDir, "goal.json"),
-    projectInputHistory: path7.join(projectDir, "input-history.json"),
-    projectSpecs: path7.join(projectDir, "specs"),
-    projectTaskGraphs: path7.join(projectDir, "task-graphs"),
-    projectSddSession: path7.join(projectDir, "sdd-session.json"),
-    projectPlan: path7.join(projectDir, "plan.json"),
-    projectAutophase: path7.join(projectDir, "autophase"),
-    projectSddBoards: path7.join(projectDir, "sdd-boards"),
-    syncConfig: path7.join(profileDir, "sync.json"),
-    configHistoryDir: path7.join(globalRoot, "config-history"),
-    projectStatus: (projectHash2) => path7.join(globalRoot, "projects", projectHash2, "status.json")
-  };
-}
-
-// src/utils/heap-watchdog.ts
-import * as fsp2 from "node:fs/promises";
-import * as path8 from "node:path";
-import * as v8 from "node:v8";
-var MB = 1024 * 1024;
-function defaultHeapLogPath() {
-  return path8.join(wstackGlobalRoot(), "logs", "heap.jsonl");
-}
-function takeHeapSample() {
-  const m = process.memoryUsage();
-  const limit = v8.getHeapStatistics().heap_size_limit || 0;
+// src/utils/win32-cmd.ts
+var WIN32_CMD_META = /[&|<>"\r\n\0]/;
+function buildWin32CmdShimInvocation(command, args = []) {
+  assertSafeWin32CmdArgs([command, ...args]);
+  const line = ["call", quoteWin32CmdArg(command), ...args.map(quoteWin32CmdArg)].join(" ");
   return {
-    ts: (/* @__PURE__ */ new Date()).toISOString(),
-    rss: m.rss,
-    heapUsed: m.heapUsed,
-    heapTotal: m.heapTotal,
-    external: m.external,
-    heapLimit: limit,
-    load: limit > 0 ? m.heapUsed / limit : 0
+    command: process.env["COMSPEC"] ?? "cmd.exe",
+    args: ["/d", "/c", line],
+    windowsVerbatimArguments: true
   };
 }
-function startHeapWatchdog(opts = {}) {
-  const sampleEveryMs = opts.sampleEveryMs ?? 6e4;
-  const logEveryMs = opts.logEveryMs ?? 3e5;
-  const logPath = opts.logPath ?? defaultHeapLogPath();
-  const warnAt = opts.warnAt ?? 0.6;
-  const criticalAt = opts.criticalAt ?? 0.85;
-  const REARM_MARGIN = 0.05;
-  let warnArmed = true;
-  let criticalArmed = true;
-  let lastLogAt = 0;
-  let writeInFlight = false;
-  let pendingLine;
-  let drainPromise;
-  let stopped = false;
-  let dirReady = false;
-  const writeDiagnosticLine = opts.writeDiagnosticLine ?? (async (targetPath, line) => {
-    if (!dirReady) {
-      await fsp2.mkdir(path8.dirname(targetPath), { recursive: true });
-      dirReady = true;
-    }
-    await fsp2.appendFile(targetPath, `${line}
-`, "utf8");
-  });
-  const drainWrites = async (firstLine) => {
-    let line = firstLine;
-    while (line !== void 0) {
-      try {
-        await writeDiagnosticLine(logPath, line);
-      } catch {
-      }
-      line = pendingLine;
-      pendingLine = void 0;
-    }
-    writeInFlight = false;
-  };
-  const append = (line) => {
-    if (stopped) return;
-    if (writeInFlight) {
-      pendingLine = line;
-      return;
-    }
-    writeInFlight = true;
-    drainPromise = drainWrites(line);
-  };
-  const tick = () => {
-    let userTimings = 0;
-    try {
-      userTimings = performance.getEntriesByType("mark").length + performance.getEntriesByType("measure").length;
-      if (userTimings > 0) {
-        performance.clearMarks();
-        performance.clearMeasures();
-      }
-    } catch {
-    }
-    const s = takeHeapSample();
-    if (s.load >= criticalAt && criticalArmed) {
-      criticalArmed = false;
-      warnArmed = false;
-      opts.onWarn?.(
-        "critical",
-        `Heap critical: ${Math.round(s.heapUsed / MB)} MB of ~${Math.round(s.heapLimit / MB)} MB V8 limit (${Math.round(s.load * 100)}%). An out-of-memory crash is likely soon \u2014 finish/checkpoint work and restart the session. Diagnostics: ${logPath}`,
-        s
-      );
-    } else if (s.load >= warnAt && warnArmed) {
-      warnArmed = false;
-      opts.onWarn?.(
-        "warn",
-        `Heap high: ${Math.round(s.heapUsed / MB)} MB of ~${Math.round(s.heapLimit / MB)} MB V8 limit (${Math.round(s.load * 100)}%). Memory diagnostics are being recorded to ${logPath}`,
-        s
+function assertSafeWin32CmdArgs(args) {
+  for (const arg of args) {
+    if (typeof arg === "string" && WIN32_CMD_META.test(arg)) {
+      throw new Error(
+        'win32 cmd shim spawn: argument contains a shell metacharacter (one of & | < > ", or a newline) that could enable command injection through the .cmd/.bat wrapper - refusing to run. Offending argument: ' + JSON.stringify(arg)
       );
     }
-    if (!warnArmed && s.load < warnAt - REARM_MARGIN) warnArmed = true;
-    if (!criticalArmed && s.load < criticalAt - REARM_MARGIN) criticalArmed = true;
-    const due = Date.now() - lastLogAt >= logEveryMs;
-    const crossed = s.load >= warnAt;
-    if (due || crossed) {
-      lastLogAt = Date.now();
-      let extras = {};
-      try {
-        extras = opts.collectStats?.() ?? {};
-      } catch {
-      }
-      append(JSON.stringify({ pid: process.pid, ...s, userTimings, ...extras }));
-    }
-  };
-  const timer = setInterval(tick, sampleEveryMs);
-  timer.unref?.();
-  tick();
-  return async () => {
-    stopped = true;
-    clearInterval(timer);
-    await drainPromise;
-  };
+  }
+}
+function quoteWin32CmdArg(arg) {
+  return `"${arg}"`;
 }
 export {
+  ALLOWED_IMAGE_MEDIA_TYPES,
   COMPLETED_WORK_LEDGER_MARKER,
   DEFAULT_TOOL_DESCRIPTION_MODE,
   DEFAULT_TOOL_RESULT_RENDER_MODE,
@@ -4550,11 +5408,14 @@ export {
   IncomingImageError,
   MAX_INCOMING_IMAGES,
   MAX_INCOMING_IMAGE_BYTES,
+  MAX_PATH_SEGMENT_LENGTH,
   PROJECT_IDENTITY_RELATIVE_PATH,
   PROJECT_IDENTITY_VERSION,
   PROJECT_ID_PREFIX,
   SageCachePragmas,
   TerminalLifecycle,
+  WIRE_TOOL_NAME_MAX_LENGTH,
+  WIRE_TOOL_NAME_PATTERN,
   activeProfileName,
   applyToolDescriptionModeToTool,
   applyToolDescriptionModes,
@@ -4565,12 +5426,14 @@ export {
   atomicReplaceWithWriter,
   atomicWrite,
   backupConfigFile,
+  base64DecodedBytes,
   buildChildEnv,
   buildCompletedWorkLedgerBlock,
   buildContextEvidenceDigest,
   buildSgrSequence,
   buildTitleSequence,
   buildUserContentBlocks,
+  buildWin32CmdShimInvocation,
   canonicalProjectRoot,
   checkConnectivity,
   checkUnixSocketPath,
@@ -4596,6 +5459,12 @@ export {
   ensureDir,
   ensureProjectGitignore,
   ensureProjectIdentity,
+  envBool,
+  envBoolOptional,
+  envEnum,
+  envFloat,
+  envInt,
+  envString,
   escapeGlobSubject,
   estimateMessageTokens,
   estimateRequestTokens,
@@ -4621,6 +5490,8 @@ export {
   hasMeaningfulContent,
   hasOpenTodos,
   indexParallelBatchSize,
+  installCrashShield,
+  isAllowedImageMediaType,
   isFrugalPerf,
   isJsonObject,
   isPathSubjectKey,
@@ -4629,12 +5500,18 @@ export {
   isPrivateIPv4,
   isPrivateIPv6,
   isProjectId,
+  isSafePathSegment,
   isStdinTTY,
   isUlid,
+  isValidImageBase64,
   jsonObjectFileExists,
   markAssistantReferencedEvidence,
   matchAny,
+  matchAnyCommand,
+  matchCommandGlob,
   matchGlob,
+  mcpQualifiedToolName,
+  mcpServerToolPrefix,
   mergeCustomModelDefs,
   mergeModelsPayload,
   normalizePathSubject,
@@ -4663,6 +5540,7 @@ export {
   repeatedReadPressure,
   resetCalibration,
   resetConnectivityCache,
+  resolveContainedPath,
   resolveToolDescriptionMode,
   resolveToolResultRenderMode,
   resolveWstackPaths,
@@ -4672,6 +5550,7 @@ export {
   safeStringify,
   sanitizeJsonString,
   sanitizeNodeOptions,
+  sanitizeWireToolName,
   sessionScopedPath,
   setJsonPath,
   setJsonPathInFile,
@@ -4682,9 +5561,10 @@ export {
   setToolResultRenderMode,
   simplifyToolDescription,
   sleep,
-  slugify,
+  slugify2 as slugify,
   sqliteCachePragmas,
   startHeapWatchdog,
+  startSharedHeapWatchdog,
   stripAnsi,
   stripCodeFences,
   subjectForToolInput,