@wrongstack/core 0.313.0 → 0.316.1

package/dist/chunk-J2WRWR37.js

@@ -0,0 +1,1104 @@
+import {
+  SYSTEM_BLOCK_SOURCE,
+  buildLiveNextStepsGateBlock
+} from "./chunk-M27LIEKV.js";
+import {
+  color,
+  writeErr
+} from "./chunk-4VWO3ZXL.js";
+import {
+  buildCompletedWorkLedgerBlock
+} from "./chunk-ZHZ2Y2DH.js";
+import {
+  estimateTextTokens,
+  estimateToolDefTokens,
+  estimateToolInputTokens,
+  estimateToolResultTokens
+} from "./chunk-HMLIGAU7.js";
+import {
+  expectDefined
+} from "./chunk-PFZO3C6H.js";
+
+// src/utils/assert-never.ts
+function assertNever(x, message) {
+  const err = new Error(
+    message ?? `Unhandled case: ${JSON.stringify(x)}`
+  );
+  err.name = "AssertNeverError";
+  throw err;
+}
+
+// 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);
+  if (typeof timer.unref === "function") timer.unref();
+  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-breakdown.ts
+var SYSTEM_BLOCK_SOURCES = [
+  "identity",
+  "tool-usage",
+  "environment",
+  "skills",
+  "mode",
+  "plan",
+  "leader-after-task",
+  "contributor",
+  "ledger",
+  "glossary",
+  "peers",
+  "nextsteps",
+  "other"
+];
+function emptyBySource() {
+  const out = {};
+  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;
+    }
+  }
+  let histText = 0;
+  let histToolInputs = 0;
+  let histToolResults = 0;
+  let histThinking = 0;
+  let histOther = 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":
+          histToolInputs += estimateToolInputTokens(b.input);
+          break;
+        case "tool_result":
+          histToolResults += estimateToolResultTokens(b.content);
+          break;
+        case "thinking": {
+          let str;
+          try {
+            str = JSON.stringify(b) ?? "";
+          } catch {
+            str = String(b);
+          }
+          histThinking += estimateTextTokens(str);
+          break;
+        }
+        default: {
+          let str;
+          try {
+            str = JSON.stringify(b) ?? "";
+          } catch {
+            str = String(b);
+          }
+          histOther += estimateTextTokens(str);
+        }
+      }
+    }
+  }
+  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 + histToolInputs + histToolResults + histThinking + histOther;
+  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,
+      toolInputs: histToolInputs,
+      toolResults: histToolResults,
+      thinking: histThinking,
+      other: histOther,
+      messageCount: ctx.messages.length
+    },
+    volatile: { ledger, nextsteps, total: volatileTotal },
+    total,
+    effectiveMaxContext,
+    usedPct: effectiveMaxContext > 0 ? total / effectiveMaxContext : 0,
+    warnings
+  };
+}
+
+// src/utils/crash-shield.ts
+var CRASH_STORM_WINDOW_MS = 6e4;
+var CRASH_STORM_LIMIT = 20;
+var fatalSalvageHooks = [];
+function addFatalSalvageHook(hook) {
+  fatalSalvageHooks.push(hook);
+  return () => {
+    const idx = fatalSalvageHooks.indexOf(hook);
+    if (idx >= 0) fatalSalvageHooks.splice(idx, 1);
+  };
+}
+function runFatalSalvageSync() {
+  for (const hook of [...fatalSalvageHooks]) {
+    try {
+      hook();
+    } catch {
+    }
+  }
+}
+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 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 {
+    }
+  };
+  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`
+        )
+      );
+      runFatalSalvageSync();
+      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
+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.replace(/\r\n/g, "\n").split("\n");
+  const b = newText.replace(/\r\n/g, "\n").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/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, resolve } from "node:path";
+var GLOB_CHARS = /* @__PURE__ */ new Set(["*", "?", "["]);
+var IS_WINDOWS = typeof process !== "undefined" && 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 === "[") {
+      const closeIndex = pat.indexOf("]", i + 1);
+      if (closeIndex === -1) {
+        re += "\\[";
+        i++;
+        continue;
+      }
+      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 normalized = pattern.replace(/\\/g, "/");
+  const results = /* @__PURE__ */ new Set();
+  const abs = isAbsolute(pattern);
+  const base = baseDir(pattern);
+  const baseNorm = base.replace(/\\/g, "/");
+  const relPat = base === "." ? normalized : normalized.slice(baseNorm.length + 1);
+  async function walk(dir, pat) {
+    let entries;
+    try {
+      entries = await fsp.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    if (pat.startsWith("**/")) {
+      const rest = pat.slice(3);
+      await walk(dir, rest);
+      for (const e of entries) {
+        if (e.isDirectory()) {
+          const subDir = `${dir}${SEP}${e.name}`;
+          await walk(subDir, pat);
+        }
+      }
+      return;
+    }
+    if (pat === "**") {
+      for (const e of entries) {
+        const full = `${dir}${SEP}${e.name}`;
+        results.add(abs ? resolve(full) : full);
+        if (e.isDirectory()) {
+          await walk(full, "**");
+        }
+      }
+      return;
+    }
+    const firstSlash = pat.indexOf("/");
+    if (firstSlash < 0) {
+      const re = globToRegex(pat);
+      for (const e of entries) {
+        if (re.test(e.name)) {
+          const full = `${dir}${SEP}${e.name}`;
+          results.add(abs ? resolve(full) : full);
+        }
+      }
+      return;
+    }
+    const currentSeg = pat.slice(0, firstSlash);
+    const remainingPat = pat.slice(firstSlash + 1);
+    if (isGlob(currentSeg)) {
+      const re = globToRegex(currentSeg);
+      for (const e of entries) {
+        if (e.isDirectory() && re.test(e.name)) {
+          const subDir = `${dir}${SEP}${e.name}`;
+          await walk(subDir, remainingPat);
+        }
+      }
+    } else {
+      for (const e of entries) {
+        if (e.isDirectory() && e.name === currentSeg) {
+          const subDir = `${dir}${SEP}${e.name}`;
+          await walk(subDir, remainingPat);
+        }
+      }
+    }
+  }
+  await walk(base === "." ? "." : base, relPat);
+  return [...results];
+}
+
+// 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 (!isAllowedImageMediaType(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 (!isValidImageBase64(base64)) {
+      throw new IncomingImageError(`Image ${i + 1}: data is not valid base64.`);
+    }
+    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.`
+      );
+    }
+    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/merge-custom-models.ts
+function mergeCustomModelDefs(providerCustomModels, configModels) {
+  const out = {};
+  if (providerCustomModels) {
+    for (const [id, def] of Object.entries(providerCustomModels)) {
+      out[id] = { ...def };
+    }
+  }
+  if (configModels) {
+    for (const [id, def] of Object.entries(configModels)) {
+      out[id] = { ...def };
+    }
+  }
+  if (Object.keys(out).length === 0) return void 0;
+  return out;
+}
+
+// src/utils/newline-normalize.ts
+function detectNewlineStyle(text) {
+  if (typeof text !== "string") return "lf";
+  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++;
+    }
+  }
+  if (crlf > lf && crlf > cr) return "crlf";
+  if (cr > lf && cr > crlf) return "cr";
+  return "lf";
+}
+function toStyle(text, style) {
+  if (typeof text !== "string") return "";
+  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) {
+  if (typeof text !== "string") return "";
+  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+
+// src/utils/path-segment.ts
+import * as path from "node:path";
+var MAX_PATH_SEGMENT_LENGTH = 256;
+function isSafePathSegment(value) {
+  if (typeof value !== "string" || 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 = path.resolve(root);
+  const candidate = path.resolve(resolvedRoot, ...segments);
+  if (candidate === resolvedRoot) return null;
+  if (!candidate.startsWith(resolvedRoot + path.sep)) return null;
+  return candidate;
+}
+
+// src/utils/project-watch.ts
+import * as fs from "node:fs";
+import * as path2 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 = path2.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 = fs.watch(
+      path2.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
+import {
+  capSubject,
+  compileUserRegex,
+  MAX_SUBJECT_LEN
+} from "@wrongstack/primitives";
+
+// src/utils/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+
+// src/utils/slug.ts
+function slugify(name, fallback = "prompt", maxLen = 64) {
+  if (typeof name !== "string") return fallback;
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, maxLen).replace(/-+$/g, "") || fallback;
+}
+
+// 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 {
+    total: tasks.length,
+    pending,
+    inProgress,
+    blocked,
+    failed,
+    review,
+    completed,
+    percentComplete: tasks.length > 0 ? Math.round(completed / tasks.length * 100) : 0,
+    estimatedHours,
+    actualHours
+  };
+}
+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 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 lines.join("\n");
+}
+
+// src/utils/terminal-sanitize.ts
+var ANSI_RE = /\x1b\[[0-?]*[ -/]*[@-~]/g;
+var ANSI_OSC_RE = /\x1b\][\s\S]*?(?:\x07|\x1b\\)/g;
+var ANSI_CONTROL_STRING_RE = /\x1b[P^_X][\s\S]*?\x1b\\/g;
+var ANSI_ESCAPE_RE = /\x1b[ -/]*[@-~]/g;
+var BIDI_AND_ZERO_WIDTH_RE = /[​-‏‪-‮⁦-⁩]/g;
+function sanitizeTerminalText(value, tabWidth = 2) {
+  const tab = " ".repeat(Math.max(1, Math.min(8, Math.floor(tabWidth))));
+  const withoutEscapes = value.replace(ANSI_OSC_RE, "").replace(ANSI_CONTROL_STRING_RE, "").replace(ANSI_RE, "").replace(ANSI_ESCAPE_RE, "").replace(BIDI_AND_ZERO_WIDTH_RE, "").replace(/\t/g, tab).replace(/\r/g, "");
+  let safe = "";
+  for (const char of withoutEscapes) {
+    const code = char.codePointAt(0) ?? 0;
+    if (char === "\n" || code >= 32 && code !== 127 && !(code >= 128 && code <= 159)) {
+      safe += char;
+    }
+  }
+  return safe;
+}
+function sanitizeTerminalPreview(value, opts = {}) {
+  const maxLines = opts.maxLines ?? 40;
+  const maxChars = opts.maxChars ?? 8e3;
+  const safe = sanitizeTerminalText(value, opts.tabWidth);
+  let truncated = false;
+  let clipped = safe;
+  if (clipped.length > maxChars) {
+    clipped = clipped.slice(0, maxChars);
+    truncated = true;
+  }
+  const lines = clipped.split("\n");
+  if (lines.length > maxLines) {
+    clipped = lines.slice(0, maxLines).join("\n");
+    truncated = true;
+  }
+  return { text: clipped, truncated };
+}
+
+// src/utils/tool-result-render-mode.ts
+var DEFAULT_TOOL_RESULT_RENDER_MODE = "extend";
+function normalizeToolResultRenderMode(value) {
+  if (typeof value !== "string") return void 0;
+  const raw = value.trim().toLowerCase();
+  if (raw === "extend" || raw === "extended" || raw === "full") return "extend";
+  if (raw === "simple" || raw === "short" || raw === "brief") return "simple";
+  return void 0;
+}
+function resolveToolResultRenderMode(modes, toolName) {
+  return normalizeToolResultRenderMode(modes?.[toolName]) ?? DEFAULT_TOOL_RESULT_RENDER_MODE;
+}
+function setToolResultRenderMode(registry2, name, mode) {
+  if (typeof registry2.setResultRenderMode === "function") {
+    return registry2.setResultRenderMode(name, mode);
+  }
+  return false;
+}
+function getToolResultRenderMode(registry2, name) {
+  return registry2.getResultRenderMode?.(name) ?? DEFAULT_TOOL_RESULT_RENDER_MODE;
+}
+function applyToolResultRenderModes(registry2, modes) {
+  if (typeof registry2.applyResultRenderModes === "function") {
+    return registry2.applyResultRenderModes(modes);
+  }
+  const entries = Object.entries(modes ?? {});
+  const missing = [];
+  let applied = 0;
+  for (const [name, rawMode] of entries) {
+    const mode = normalizeToolResultRenderMode(rawMode);
+    if (!mode) continue;
+    if (setToolResultRenderMode(registry2, name, mode)) applied++;
+    else missing.push(name);
+  }
+  return { applied, missing };
+}
+
+// src/utils/walk-ignore.ts
+var DEFAULT_WALK_IGNORE_DIRS = Object.freeze([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  ".turbo",
+  "coverage",
+  ".nyc_output",
+  "__snapshots__",
+  "__pycache__",
+  ".venv",
+  "venv",
+  "target",
+  ".cache",
+  ".parcel-cache",
+  ".pnpm-store",
+  ".gradle"
+]);
+var DEFAULT_WALK_IGNORE_SET = new Set(DEFAULT_WALK_IGNORE_DIRS);
+
+export {
+  watchProjectTree,
+  DEFAULT_WALK_IGNORE_DIRS,
+  DEFAULT_WALK_IGNORE_SET,
+  assertNever,
+  checkConnectivity,
+  resetConnectivityCache,
+  getContextBreakdown,
+  addFatalSalvageHook,
+  runFatalSalvageSync,
+  installCrashShield,
+  unifiedDiff,
+  envBool,
+  envBoolOptional,
+  envInt,
+  envFloat,
+  envString,
+  envEnum,
+  expandGlob,
+  MAX_INCOMING_IMAGES,
+  MAX_INCOMING_IMAGE_BYTES,
+  ALLOWED_IMAGE_MEDIA_TYPES,
+  isAllowedImageMediaType,
+  isValidImageBase64,
+  base64DecodedBytes,
+  IncomingImageError,
+  parseIncomingImages,
+  buildUserContentBlocks,
+  mergeCustomModelDefs,
+  detectNewlineStyle,
+  toStyle,
+  normalizeToLf,
+  MAX_PATH_SEGMENT_LENGTH,
+  isSafePathSegment,
+  resolveContainedPath,
+  capSubject,
+  compileUserRegex,
+  MAX_SUBJECT_LEN,
+  sleep,
+  slugify,
+  computeTaskItemProgress,
+  formatTaskProgress,
+  formatTaskList,
+  sanitizeTerminalText,
+  sanitizeTerminalPreview,
+  DEFAULT_TOOL_RESULT_RENDER_MODE,
+  normalizeToolResultRenderMode,
+  resolveToolResultRenderMode,
+  setToolResultRenderMode,
+  getToolResultRenderMode,
+  applyToolResultRenderModes
+};
+//# sourceMappingURL=chunk-J2WRWR37.js.map