greprag 5.48.0 → 5.49.2

package/dist/opencode-plugin.bundle.js

@@ -0,0 +1,2447 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/opencode-plugin.ts
+var crypto2 = __toESM(require("crypto"));
+var fs2 = __toESM(require("fs"));
+var os = __toESM(require("os"));
+var path2 = __toESM(require("path"));
+
+// src/opencode-plugin-helpers.ts
+var crypto = __toESM(require("crypto"));
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+
+// src/proc.ts
+var import_child_process = require("child_process");
+function safeExecSync(command, options) {
+  return (0, import_child_process.execSync)(command, { windowsHide: true, ...options });
+}
+function safeSpawn(command, argsOrOptions, maybeOptions) {
+  if (Array.isArray(argsOrOptions)) {
+    return (0, import_child_process.spawn)(command, argsOrOptions, { windowsHide: true, ...maybeOptions });
+  }
+  return (0, import_child_process.spawn)(command, { windowsHide: true, ...argsOrOptions });
+}
+
+// src/opencode-plugin-helpers.ts
+var HOME = process.env.HOME || process.env.USERPROFILE || "";
+function readAnchorFile(filePath) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    if (!raw || typeof raw !== "object")
+      return null;
+    const notify = raw.inbox_notify;
+    const inboxNotify = notify === "off" || notify === "session_start_only" ? notify : "every_turn";
+    return {
+      projectId: typeof raw.project_id === "string" ? raw.project_id : void 0,
+      projectName: typeof raw.project_name === "string" ? raw.project_name : void 0,
+      memoryCapture: raw.memory_capture !== false,
+      sessionStartRecap: raw.session_start_recap !== false,
+      inboxNotify
+    };
+  } catch {
+    return null;
+  }
+}
+function findExistingAnchorFile(startDir) {
+  const globalAnchorPath = path.join(HOME, ".greprag", "project.json");
+  const legacyGlobalAnchorPath = path.join(HOME, ".claude", "project.json");
+  let dir = path.resolve(startDir);
+  while (true) {
+    for (const subdir of [".greprag", ".claude", ".opencode"]) {
+      const candidate = path.join(dir, subdir, "project.json");
+      if (candidate !== globalAnchorPath && candidate !== legacyGlobalAnchorPath && fs.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+}
+function formatUuid(hashHex) {
+  return [
+    hashHex.slice(0, 8),
+    hashHex.slice(8, 12),
+    "4" + hashHex.slice(13, 16),
+    "8" + hashHex.slice(17, 20),
+    hashHex.slice(20, 32)
+  ].join("-");
+}
+function computeGitDerivedProjectId(cwd) {
+  try {
+    const out = safeExecSync("git rev-list --max-parents=0 HEAD", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const roots = out.trim().split(/\s+/).filter(Boolean).sort();
+    if (roots.length === 0)
+      return null;
+    const hash = crypto.createHash("sha256").update(roots.join("\n")).digest("hex");
+    return formatUuid(hash);
+  } catch {
+    return null;
+  }
+}
+function deterministicProjectId(cwd) {
+  const normalized = path.resolve(cwd).toLowerCase();
+  const hash = crypto.createHash("sha256").update(normalized).digest("hex");
+  return formatUuid(hash);
+}
+function isEphemeralCwd(cwd) {
+  const norm = path.resolve(cwd).replace(/\\/g, "/").toLowerCase();
+  if (norm.includes("/appdata/roaming/claude/local-agent-mode-sessions/"))
+    return true;
+  if (norm.includes("/appdata/local/claude/local-agent-mode-sessions/"))
+    return true;
+  if (norm.startsWith("/tmp/"))
+    return true;
+  if (norm.startsWith("/var/tmp/"))
+    return true;
+  if (norm.startsWith("/private/tmp/"))
+    return true;
+  return false;
+}
+function readAnchor(worktree) {
+  const filePath = findExistingAnchorFile(worktree);
+  const file = filePath ? readAnchorFile(filePath) : null;
+  const root = path.resolve(worktree);
+  if (file && file.projectId && file.projectName) {
+    return {
+      projectId: file.projectId,
+      projectName: file.projectName,
+      memoryCapture: file.memoryCapture,
+      sessionStartRecap: file.sessionStartRecap,
+      inboxNotify: file.inboxNotify
+    };
+  }
+  const gitId = computeGitDerivedProjectId(worktree);
+  if (gitId) {
+    return {
+      projectId: gitId,
+      projectName: file?.projectName || path.basename(root).toLowerCase(),
+      memoryCapture: file?.memoryCapture ?? true,
+      sessionStartRecap: file?.sessionStartRecap ?? true,
+      inboxNotify: file?.inboxNotify ?? "every_turn"
+    };
+  }
+  if (isEphemeralCwd(worktree)) {
+    const canonicalGlobal = path.join(HOME, ".greprag", "project.json");
+    const legacyGlobal = path.join(HOME, ".claude", "project.json");
+    const globalPath = fs.existsSync(canonicalGlobal) ? canonicalGlobal : legacyGlobal;
+    const globalFile = fs.existsSync(globalPath) ? readAnchorFile(globalPath) : null;
+    if (globalFile && globalFile.projectId && globalFile.projectName) {
+      return {
+        projectId: globalFile.projectId,
+        projectName: globalFile.projectName,
+        memoryCapture: globalFile.memoryCapture,
+        sessionStartRecap: globalFile.sessionStartRecap,
+        inboxNotify: globalFile.inboxNotify
+      };
+    }
+  }
+  return {
+    projectId: deterministicProjectId(worktree),
+    projectName: file?.projectName || path.basename(root).toLowerCase(),
+    memoryCapture: file?.memoryCapture ?? true,
+    sessionStartRecap: file?.sessionStartRecap ?? true,
+    inboxNotify: file?.inboxNotify ?? "every_turn"
+  };
+}
+function isPidAlive(pid) {
+  if (!Number.isFinite(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var RELAY_LOCK_PREFIX = "relay.";
+var RELAY_STALE_MS = 3e4;
+function relayLockPath(sessionId) {
+  const eight = sessionId.replace(/[^0-9a-f]/gi, "").slice(0, 8) || "unknown";
+  return path.join(HOME, ".greprag", `${RELAY_LOCK_PREFIX}${eight}.pid`);
+}
+function tryClaimRelayLock(lockPath) {
+  try {
+    const fd = fs.openSync(lockPath, "wx");
+    return { ok: true, fd };
+  } catch (err) {
+    if (err.code !== "EEXIST") {
+      return { ok: false, reason: "lock-create-failed" };
+    }
+    try {
+      const stat = fs.statSync(lockPath);
+      const ageMs = Date.now() - stat.mtimeMs;
+      let pidAlive = false;
+      try {
+        const pid = parseInt(fs.readFileSync(lockPath, "utf-8").trim(), 10);
+        pidAlive = pid > 0 && isPidAlive(pid);
+      } catch {
+      }
+      if (ageMs < RELAY_STALE_MS && pidAlive) {
+        return { ok: false, reason: "busy" };
+      }
+      try {
+        fs.unlinkSync(lockPath);
+      } catch {
+      }
+      const fd = fs.openSync(lockPath, "wx");
+      return { ok: true, fd };
+    } catch (err2) {
+      return { ok: false, reason: "lock-stale-replace-failed" };
+    }
+  }
+}
+var HOURLY_CAP = 3;
+function stripRecapNoise(content, type) {
+  const target = type === "daily" ? "Shipped:" : "Open:";
+  const lines = content.split("\n");
+  const cutAt = lines.findIndex((line) => line.trim().startsWith(target));
+  const kept = cutAt === -1 ? lines : lines.slice(0, cutAt);
+  while (kept.length > 0 && kept[kept.length - 1].trim() === "")
+    kept.pop();
+  return kept.join("\n");
+}
+function fmtHoursAgo(windowEndIso, now) {
+  const diffMs = now.getTime() - new Date(windowEndIso).getTime();
+  const diffMin = Math.floor(diffMs / 6e4);
+  if (diffMin < 1)
+    return "just now";
+  if (diffMin < 60)
+    return `${diffMin} min ago`;
+  const diffHrs = Math.round(diffMs / 36e5);
+  return diffHrs === 1 ? "1 hour ago" : `${diffHrs} hours ago`;
+}
+async function buildRecapBody(apiUrl, apiKey, anchor, now = /* @__PURE__ */ new Date()) {
+  if (!anchor.projectId)
+    return "";
+  const hourlyFromIso = new Date(now.getTime() - 2 * 864e5).toISOString();
+  const toIso = now.toISOString();
+  const hourlyCutoffMs = now.getTime() - 24 * 36e5;
+  const url = `${apiUrl}/v1/memory/by-period?projectId=${encodeURIComponent(anchor.projectId)}&from=${encodeURIComponent(hourlyFromIso)}&to=${encodeURIComponent(toIso)}&type=hourly&limit=50`;
+  let hourlies = [];
+  try {
+    const res = await fetch(url, { headers: { "Authorization": `Bearer ${apiKey}` } });
+    if (res.ok) {
+      const data = await res.json();
+      hourlies = data.memories || [];
+    }
+  } catch {
+  }
+  const recent = hourlies.filter((h) => h.windowEnd && new Date(h.windowEnd).getTime() >= hourlyCutoffMs).slice(-HOURLY_CAP);
+  if (recent.length === 0)
+    return "";
+  const parts = [];
+  parts.push(`[GrepRAG memory: ${anchor.projectName}]`);
+  parts.push("");
+  parts.push("Recent sessions:");
+  for (const h of recent) {
+    if (!h.windowEnd)
+      continue;
+    parts.push("");
+    parts.push(`${fmtHoursAgo(h.windowEnd, now)}:`);
+    parts.push(stripRecapNoise(h.content.trim(), "hourly"));
+  }
+  return parts.join("\n");
+}
+
+// src/crush/crush-types.ts
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function makePassthrough(content, sourceType, reason, units = 0) {
+  return {
+    output: content,
+    stats: {
+      sourceType,
+      originalChars: content.length,
+      compressedChars: content.length,
+      compressionRatio: 1,
+      originalUnits: units,
+      keptUnits: units,
+      passthrough: true,
+      passthroughReason: reason
+    }
+  };
+}
+
+// src/crush/adaptive-sizer.ts
+function fnv1a(s, seed) {
+  let h = (2166136261 ^ seed) >>> 0;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+function simhash(s) {
+  const votes1 = new Array(32).fill(0);
+  const votes2 = new Array(32).fill(0);
+  const text = s.length < 4 ? s + " ".repeat(4 - s.length) : s;
+  for (let i = 0; i + 4 <= text.length; i++) {
+    const gram = text.slice(i, i + 4);
+    const h1 = fnv1a(gram, 0);
+    const h2 = fnv1a(gram, 2654435769);
+    for (let b = 0; b < 32; b++) {
+      votes1[b] += h1 >>> b & 1 ? 1 : -1;
+      votes2[b] += h2 >>> b & 1 ? 1 : -1;
+    }
+  }
+  let out = "";
+  for (let b = 0; b < 32; b++)
+    out += votes1[b] >= 0 ? "1" : "0";
+  for (let b = 0; b < 32; b++)
+    out += votes2[b] >= 0 ? "1" : "0";
+  return out;
+}
+function countUniqueSimhash(items) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of items)
+    seen.add(simhash(item));
+  return seen.size;
+}
+function computeUniqueBigramCurve(items) {
+  const seen = /* @__PURE__ */ new Set();
+  const curve = [];
+  for (const item of items) {
+    const words = item.split(/\s+/).filter((w) => w.length > 0);
+    if (words.length === 0) {
+      seen.add(" ");
+    } else if (words.length === 1) {
+      seen.add(words[0] + " ");
+    } else {
+      for (let i = 0; i + 1 < words.length; i++) {
+        seen.add(words[i] + " " + words[i + 1]);
+      }
+    }
+    curve.push(seen.size);
+  }
+  return curve;
+}
+function findKnee(curve) {
+  const n = curve.length;
+  if (n < 3)
+    return null;
+  const yMin = curve[0];
+  const yMax = curve[n - 1];
+  if (Math.abs(yMax - yMin) < Number.EPSILON)
+    return 1;
+  const xRange = n - 1;
+  const yRange = yMax - yMin;
+  let maxDiff = -1;
+  let kneeIdx = null;
+  for (let i = 0; i < n; i++) {
+    const xNorm = i / xRange;
+    const yNorm = (curve[i] - yMin) / yRange;
+    const diff = yNorm - xNorm;
+    if (diff > maxDiff) {
+      maxDiff = diff;
+      kneeIdx = i;
+    }
+  }
+  if (maxDiff < 0.05)
+    return null;
+  return kneeIdx === null ? null : kneeIdx + 1;
+}
+function computeOptimalK(items, bias, minK, maxK) {
+  const n = items.length;
+  const effectiveMax = maxK ?? n;
+  if (n <= 8)
+    return n;
+  const uniqueCount = countUniqueSimhash(items);
+  if (uniqueCount <= 3) {
+    return Math.min(Math.max(minK, uniqueCount), effectiveMax);
+  }
+  const curve = computeUniqueBigramCurve(items);
+  let knee = findKnee(curve);
+  const diversityRatio = uniqueCount / n;
+  if (knee === null) {
+    const keepFraction = 0.3 + 0.7 * diversityRatio;
+    knee = Math.max(minK, Math.floor(n * keepFraction));
+  } else if (diversityRatio > 0.7) {
+    const floor = Math.max(minK, Math.floor(n * (0.3 + 0.7 * diversityRatio)));
+    knee = Math.max(knee, floor);
+  }
+  let k = Math.max(minK, Math.floor(knee * bias));
+  k = Math.min(k, effectiveMax);
+  return Math.max(minK, Math.min(k, effectiveMax));
+}
+
+// src/crush/crush-keywords.ts
+var ERROR_KEYWORDS = [
+  "error",
+  "exception",
+  "fail",
+  "failed",
+  "failure",
+  "fatal",
+  "critical",
+  "crash",
+  "panic",
+  "abort",
+  "timeout",
+  "denied",
+  "rejected"
+];
+var JSON_ERROR_KEYWORDS = [
+  "error",
+  "exception",
+  "failed",
+  "failure",
+  "critical",
+  "fatal",
+  "crash",
+  "panic",
+  "abort",
+  "timeout",
+  "denied",
+  "rejected"
+];
+var WARNING_KEYWORDS = ["warn", "warning"];
+var IMPORTANCE_KEYWORDS = [
+  "important",
+  "note",
+  "todo",
+  "fixme",
+  "hack",
+  "xxx",
+  "bug",
+  "fix"
+];
+function isWordChar(ch) {
+  return /[A-Za-z0-9_]/.test(ch);
+}
+function containsKeyword(line, keyword) {
+  const haystack = line.toLowerCase();
+  const needle = keyword.toLowerCase();
+  let from = 0;
+  for (; ; ) {
+    const idx = haystack.indexOf(needle, from);
+    if (idx === -1)
+      return false;
+    const leftOk = idx === 0 || !isWordChar(haystack[idx - 1]);
+    const right = idx + needle.length;
+    const rightOk = right === haystack.length || !isWordChar(haystack[right]);
+    if (leftOk && rightOk)
+      return true;
+    from = idx + 1;
+  }
+}
+function containsAnyKeyword(line, keywords) {
+  return keywords.some((kw) => containsKeyword(line, kw));
+}
+function classifyImportance(line) {
+  if (containsAnyKeyword(line, ERROR_KEYWORDS))
+    return "error";
+  if (containsAnyKeyword(line, WARNING_KEYWORDS))
+    return "warning";
+  if (containsAnyKeyword(line, IMPORTANCE_KEYWORDS))
+    return "importance";
+  return null;
+}
+
+// src/crush/search-compressor.ts
+var DEFAULT_SEARCH_CONFIG = {
+  maxMatchesPerFile: 5,
+  alwaysKeepFirst: true,
+  alwaysKeepLast: true,
+  maxTotalMatches: 30,
+  maxFiles: 15,
+  contextKeywords: [],
+  boostErrors: true,
+  bias: 1
+};
+function parseMatchLine(line) {
+  const isDrivePrefixed = line.length >= 3 && /[A-Za-z]/.test(line[0]) && line[1] === ":" && (line[2] === "\\" || line[2] === "/");
+  let i = isDrivePrefixed ? 2 : 0;
+  for (; i < line.length; i++) {
+    const ch = line[i];
+    if (ch !== ":" && ch !== "-")
+      continue;
+    const prev = line[i - 1];
+    if (i > 0 && (prev === ":" || prev === "-"))
+      continue;
+    const digitsStart = i + 1;
+    let j = digitsStart;
+    while (j < line.length && line[j] >= "0" && line[j] <= "9")
+      j++;
+    if (j > digitsStart && j < line.length && (line[j] === ":" || line[j] === "-")) {
+      if (i === 0)
+        return null;
+      const lineNumber = parseInt(line.slice(digitsStart, j), 10);
+      if (!Number.isFinite(lineNumber))
+        return null;
+      return { file: line.slice(0, i), lineNumber, content: line.slice(j + 1) };
+    }
+  }
+  return null;
+}
+function parseSearchResults(content) {
+  const out = /* @__PURE__ */ new Map();
+  for (const raw of content.split("\n")) {
+    const line = raw.trim();
+    if (!line)
+      continue;
+    const parsed = parseMatchLine(line);
+    if (!parsed)
+      continue;
+    let fm = out.get(parsed.file);
+    if (!fm) {
+      fm = { file: parsed.file, matches: [] };
+      out.set(parsed.file, fm);
+    }
+    fm.matches.push({ ...parsed, score: 0 });
+  }
+  return out;
+}
+function scoreMatches(files, query, config) {
+  const queryWords = query.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
+  for (const fm of files.values()) {
+    for (const m of fm.matches) {
+      let score = 0;
+      const lower = m.content.toLowerCase();
+      for (const w of queryWords) {
+        if (lower.includes(w))
+          score += 0.3;
+      }
+      if (config.boostErrors) {
+        const cat = classifyImportance(m.content);
+        if (cat === "error")
+          score += 0.5;
+        else if (cat === "warning")
+          score += 0.4;
+        else if (cat === "importance")
+          score += 0.3;
+      }
+      for (const kw of config.contextKeywords) {
+        if (lower.includes(kw.toLowerCase()))
+          score += 0.4;
+      }
+      m.score = Math.min(score, 1);
+    }
+  }
+}
+function totalScore(fm) {
+  return fm.matches.reduce((s, m) => s + m.score, 0);
+}
+function selectMatches(files, config) {
+  let byScore = [...files.values()].sort((a, b) => totalScore(b) - totalScore(a));
+  if (byScore.length > config.maxFiles)
+    byScore = byScore.slice(0, config.maxFiles);
+  const allMatchStrings = byScore.flatMap(
+    (fm) => fm.matches.map((m) => `${m.file}:${m.lineNumber}:${m.content}`)
+  );
+  const adaptiveTotal = computeOptimalK(allMatchStrings, config.bias, 5, config.maxTotalMatches);
+  const selected = /* @__PURE__ */ new Map();
+  let totalSelected = 0;
+  for (const fm of byScore) {
+    if (totalSelected >= adaptiveTotal)
+      continue;
+    const sorted = [...fm.matches].sort((a, b) => b.score - a.score || a.lineNumber - b.lineNumber);
+    const fileSelected = [];
+    const seen = /* @__PURE__ */ new Set();
+    const remainingCap = Math.min(config.maxMatchesPerFile, adaptiveTotal - totalSelected);
+    const pushUnique = (m) => {
+      const key = `${m.lineNumber}
${m.content}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        fileSelected.push(m);
+      }
+    };
+    if (config.alwaysKeepFirst && fm.matches.length > 0 && fileSelected.length < remainingCap) {
+      pushUnique(fm.matches[0]);
+    }
+    if (config.alwaysKeepLast && fm.matches.length > 1 && fileSelected.length < remainingCap) {
+      pushUnique(fm.matches[fm.matches.length - 1]);
+    }
+    for (const m of sorted) {
+      if (fileSelected.length >= remainingCap)
+        break;
+      pushUnique(m);
+    }
+    fileSelected.sort((a, b) => a.lineNumber - b.lineNumber);
+    totalSelected += fileSelected.length;
+    selected.set(fm.file, { file: fm.file, matches: fileSelected });
+  }
+  return selected;
+}
+function formatOutput(selected, original) {
+  const lines = [];
+  for (const [file, fm] of selected) {
+    for (const m of fm.matches) {
+      lines.push(`${m.file}:${m.lineNumber}:${m.content}`);
+    }
+    const orig = original.get(file);
+    if (orig && orig.matches.length > fm.matches.length) {
+      lines.push(`[... and ${orig.matches.length - fm.matches.length} more matches in ${file}]`);
+    }
+  }
+  return lines.join("\n");
+}
+function crushSearch(content, query = "", config = {}) {
+  const cfg = { ...DEFAULT_SEARCH_CONFIG, ...config };
+  const parsed = parseSearchResults(content);
+  const originalCount = [...parsed.values()].reduce((s, fm) => s + fm.matches.length, 0);
+  if (originalCount === 0) {
+    return makePassthrough(content, "search", "no parseable matches");
+  }
+  scoreMatches(parsed, query, cfg);
+  const selected = selectMatches(parsed, cfg);
+  const output = formatOutput(selected, parsed);
+  const keptCount = [...selected.values()].reduce((s, fm) => s + fm.matches.length, 0);
+  return {
+    output,
+    stats: {
+      sourceType: "search",
+      originalChars: content.length,
+      compressedChars: output.length,
+      compressionRatio: output.length / Math.max(content.length, 1),
+      originalUnits: originalCount,
+      keptUnits: keptCount,
+      passthrough: false
+    }
+  };
+}
+
+// src/crush/log-compressor.ts
+var DEFAULT_LOG_CONFIG = {
+  maxErrors: 10,
+  errorContextLines: 3,
+  keepFirstError: true,
+  keepLastError: true,
+  maxStackTraces: 3,
+  stackTraceMaxLines: 20,
+  maxWarnings: 5,
+  dedupeWarnings: true,
+  keepSummaryLines: true,
+  maxTotalLines: 100,
+  minLinesToCompress: 50,
+  bias: 1
+};
+var LEVEL_PATTERNS = [
+  ["error", /\b(?:ERROR|error|Error|FATAL|fatal|Fatal|CRITICAL|critical)\b/],
+  ["fail", /\b(?:FAIL|FAILED|fail|failed|Fail|Failed)\b/],
+  ["warn", /\b(?:WARN|WARNING|warn|warning|Warn|Warning)\b/],
+  ["info", /\b(?:INFO|info|Info)\b/],
+  ["debug", /\b(?:DEBUG|debug|Debug)\b/],
+  ["trace", /\b(?:TRACE|trace|Trace)\b/]
+];
+function classifyLevel(line) {
+  for (const [level, re] of LEVEL_PATTERNS) {
+    if (re.test(line))
+      return level;
+  }
+  return "unknown";
+}
+function hasLineColSuffix(s) {
+  return /:\d+:\d/.test(s);
+}
+function traceFlavorFor(line) {
+  const t = line.trimStart();
+  if (t.startsWith("Traceback (most recent call last)"))
+    return "python";
+  if (t.startsWith('File "') && t.includes('", line ') && /\d$/.test(t))
+    return "python";
+  if (t.startsWith("at ") && t.includes("(") && t.includes(")") && hasLineColSuffix(t))
+    return "js";
+  if (t.startsWith("at ") && t.includes("(")) {
+    const body = t.slice(3, t.indexOf("("));
+    if (body.length > 0 && /^[A-Za-z0-9._$]+$/.test(body))
+      return "java";
+  }
+  if (t.startsWith("--> ") && hasLineColSuffix(t))
+    return "rust";
+  if (/^\s*\d+:\s*0x[0-9a-fA-F]/.test(line))
+    return "go";
+  return null;
+}
+function traceTerminates(flavor, line) {
+  const t = line.trimStart();
+  switch (flavor) {
+    case "python": {
+      const indentedOrBlank = line.startsWith(" ") || line.startsWith("	") || line.length === 0;
+      const continuation = t.startsWith("Traceback") || t.startsWith("File ") || t.startsWith("During handling") || t.startsWith("The above exception");
+      if (indentedOrBlank || continuation)
+        return false;
+      return !/^[A-Z]/.test(t);
+    }
+    case "js":
+    case "java":
+      return !t.startsWith("at ") && line.length > 0;
+    case "rust":
+      return !t.startsWith("--> ") && line.length > 0;
+    case "go":
+      return !/^\d/.test(t) && line.length > 0;
+  }
+}
+function isSummaryLine(line) {
+  if (line.startsWith("===") || line.startsWith("---"))
+    return true;
+  const m = line.match(/^(\d+) /);
+  if (m) {
+    const rest = line.slice(m[1].length + 1);
+    if (/^(passed|failed|skipped|error|warning)/.test(rest))
+      return true;
+  }
+  for (const prefix of ["Test ", "Tests ", "Tests:", "Test:", "Suite ", "Suites ", "Suites:", "Suite:"]) {
+    if (line.startsWith(prefix)) {
+      const rest = line.slice(prefix.length).trimStart();
+      return rest.length > 0 && rest[0] >= "0" && rest[0] <= "9";
+    }
+  }
+  if (/^(TOTAL|Total|Summary)/.test(line))
+    return true;
+  if (/^(Build|Compile|Test)/.test(line) && /(succeeded|failed|complete)/.test(line))
+    return true;
+  return false;
+}
+function scoreLogLine(line) {
+  let levelScore;
+  switch (line.level) {
+    case "error":
+    case "fail":
+      levelScore = 1;
+      break;
+    case "warn":
+      levelScore = 0.5;
+      break;
+    case "debug":
+      levelScore = 0.05;
+      break;
+    case "trace":
+      levelScore = 0.02;
+      break;
+    default:
+      levelScore = 0.1;
+  }
+  const stackBoost = line.isStackTrace ? 0.3 : 0;
+  const summaryBoost = line.isSummary ? 0.4 : 0;
+  return Math.min(levelScore + stackBoost + summaryBoost, 1);
+}
+function parseLogLines(lines, config) {
+  const out = [];
+  let active = null;
+  let traceLines = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    const entry = {
+      lineNumber: i,
+      content: raw,
+      level: classifyLevel(raw),
+      isStackTrace: false,
+      isSummary: isSummaryLine(raw),
+      score: 0
+    };
+    if (active !== null) {
+      if (traceLines >= config.stackTraceMaxLines || traceTerminates(active, raw)) {
+        active = null;
+        traceLines = 0;
+        const next = traceFlavorFor(raw);
+        if (next) {
+          active = next;
+          traceLines = 1;
+          entry.isStackTrace = true;
+        }
+      } else {
+        entry.isStackTrace = true;
+        traceLines++;
+      }
+    } else {
+      const flavor = traceFlavorFor(raw);
+      if (flavor) {
+        active = flavor;
+        traceLines = 1;
+        entry.isStackTrace = true;
+      }
+    }
+    entry.score = scoreLogLine(entry);
+    out.push(entry);
+  }
+  return out;
+}
+function normalizeForDedupe(content) {
+  const splitAt = content.search(/[:=]/);
+  const at = splitAt === -1 ? content.length : splitAt;
+  const prefix = content.slice(0, at);
+  const suffix = content.slice(at).replace(/0x[0-9a-fA-F]+/g, "ADDR").replace(/\d+/g, "N").replace(/\/[\w/]+\//g, "/PATH/");
+  return prefix + suffix;
+}
+function dedupeSimilar(lines) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const line of lines) {
+    const key = normalizeForDedupe(line.content);
+    if (!seen.has(key)) {
+      seen.add(key);
+      out.push(line);
+    }
+  }
+  return out;
+}
+function selectWithFirstLast(lines, maxCount, config) {
+  if (lines.length <= maxCount)
+    return [...lines];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (l) => {
+    if (!seen.has(l.lineNumber)) {
+      seen.add(l.lineNumber);
+      out.push(l);
+    }
+  };
+  if (config.keepFirstError)
+    push(lines[0]);
+  if (config.keepLastError)
+    push(lines[lines.length - 1]);
+  const byScore = [...lines].sort((a, b) => b.score - a.score || a.lineNumber - b.lineNumber);
+  for (const l of byScore) {
+    if (out.length >= maxCount)
+      break;
+    push(l);
+  }
+  return out;
+}
+function selectLines(logLines, config) {
+  const adaptiveMax = computeOptimalK(
+    logLines.map((l) => l.content),
+    config.bias,
+    10,
+    config.maxTotalLines
+  );
+  const errors = [];
+  const fails = [];
+  let warnings = [];
+  const summaries = [];
+  const stackTraces = [];
+  let currentStack = [];
+  for (const line of logLines) {
+    if (line.level === "error")
+      errors.push(line);
+    else if (line.level === "fail")
+      fails.push(line);
+    else if (line.level === "warn")
+      warnings.push(line);
+    if (line.isStackTrace) {
+      currentStack.push(line);
+    } else if (currentStack.length > 0) {
+      stackTraces.push(currentStack);
+      currentStack = [];
+    }
+    if (line.isSummary)
+      summaries.push(line);
+  }
+  if (currentStack.length > 0)
+    stackTraces.push(currentStack);
+  const selected = /* @__PURE__ */ new Map();
+  const add = (l) => selected.set(l.lineNumber, l);
+  for (const l of selectWithFirstLast(errors, config.maxErrors, config))
+    add(l);
+  for (const l of selectWithFirstLast(fails, config.maxErrors, config))
+    add(l);
+  if (config.dedupeWarnings)
+    warnings = dedupeSimilar(warnings);
+  for (const l of warnings.slice(0, config.maxWarnings))
+    add(l);
+  for (const stack of stackTraces.slice(0, config.maxStackTraces)) {
+    for (const l of stack.slice(0, config.stackTraceMaxLines))
+      add(l);
+  }
+  if (config.keepSummaryLines) {
+    for (const l of summaries)
+      add(l);
+  }
+  const anchorIndices = [...selected.keys()];
+  for (const idx of anchorIndices) {
+    const lo = Math.max(0, idx - config.errorContextLines);
+    const hi = Math.min(logLines.length, idx + config.errorContextLines + 1);
+    for (let i = lo; i < hi; i++) {
+      if (!selected.has(i))
+        add(logLines[i]);
+    }
+  }
+  let ordered = [...selected.values()].sort((a, b) => a.lineNumber - b.lineNumber);
+  if (ordered.length > adaptiveMax) {
+    ordered.sort((a, b) => b.score - a.score || a.lineNumber - b.lineNumber);
+    ordered = ordered.slice(0, adaptiveMax);
+    ordered.sort((a, b) => a.lineNumber - b.lineNumber);
+  }
+  return ordered;
+}
+function formatLogOutput(selected, allLines) {
+  const count = (level) => allLines.filter((l) => l.level === level).length;
+  const output = selected.map((l) => l.content);
+  const omitted = allLines.length - selected.length;
+  if (omitted > 0) {
+    const parts = [];
+    for (const [label, level] of [
+      ["ERROR", "error"],
+      ["FAIL", "fail"],
+      ["WARN", "warn"],
+      ["INFO", "info"]
+    ]) {
+      const n = count(level);
+      if (n > 0)
+        parts.push(`${n} ${label}`);
+    }
+    if (parts.length > 0) {
+      output.push(`[${omitted} lines omitted: ${parts.join(", ")}]`);
+    } else {
+      output.push(`[${omitted} lines omitted]`);
+    }
+  }
+  return output.join("\n");
+}
+function crushLog(content, config = {}) {
+  const cfg = { ...DEFAULT_LOG_CONFIG, ...config };
+  const lines = content.split("\n");
+  if (lines.length < cfg.minLinesToCompress) {
+    return makePassthrough(content, "log", "below min line count", lines.length);
+  }
+  const logLines = parseLogLines(lines, cfg);
+  const selected = selectLines(logLines, cfg);
+  const output = formatLogOutput(selected, logLines);
+  return {
+    output,
+    stats: {
+      sourceType: "log",
+      originalChars: content.length,
+      compressedChars: output.length,
+      compressionRatio: output.length / Math.max(content.length, 1),
+      originalUnits: lines.length,
+      keptUnits: selected.length,
+      passthrough: false
+    }
+  };
+}
+
+// src/crush/json-detectors.ts
+function classifyArray(items) {
+  if (items.length === 0)
+    return "empty";
+  let hasBool = false, hasNumber = false, hasString = false, hasObject = false, hasArray = false, hasNull = false;
+  for (const item of items) {
+    if (item === null)
+      hasNull = true;
+    else if (typeof item === "boolean")
+      hasBool = true;
+    else if (typeof item === "number")
+      hasNumber = true;
+    else if (typeof item === "string")
+      hasString = true;
+    else if (Array.isArray(item))
+      hasArray = true;
+    else
+      hasObject = true;
+  }
+  if (hasBool && !hasNumber && !hasString && !hasObject && !hasArray && !hasNull)
+    return "bool_array";
+  if (hasObject && !hasBool && !hasNumber && !hasString && !hasArray && !hasNull)
+    return "dict_array";
+  if (hasString && !hasBool && !hasNumber && !hasObject && !hasArray && !hasNull)
+    return "string_array";
+  if (hasNumber && !hasBool && !hasString && !hasObject && !hasArray && !hasNull)
+    return "number_array";
+  if (hasArray && !hasBool && !hasNumber && !hasString && !hasObject && !hasNull)
+    return "nested_array";
+  return "mixed_array";
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function stringifyScalar(v) {
+  if (typeof v === "string")
+    return v;
+  return JSON.stringify(v);
+}
+function detectSequentialPattern(values) {
+  if (values.length < 5)
+    return false;
+  const nums = [];
+  let hadNonStringNumeric = false;
+  for (const v of values) {
+    if (typeof v === "number") {
+      nums.push(v);
+      hadNonStringNumeric = true;
+    } else if (typeof v === "string" && /^[+-]?\d+$/.test(v.trim())) {
+      nums.push(parseInt(v.trim(), 10));
+    }
+  }
+  if (nums.length < 5)
+    return false;
+  if (!hadNonStringNumeric)
+    return false;
+  const sorted = [...nums].sort((a, b) => a - b);
+  const diffs = [];
+  for (let i = 1; i < sorted.length; i++)
+    diffs.push(sorted[i] - sorted[i - 1]);
+  if (diffs.length === 0)
+    return false;
+  const avg = diffs.reduce((s, d) => s + d, 0) / diffs.length;
+  if (avg < 0.5 || avg > 2)
+    return false;
+  const consistent = diffs.filter((d) => d >= 0.5 && d <= 2).length;
+  return consistent / diffs.length > 0.8;
+}
+function detectRareStatusValues(items, commonFields) {
+  const outliers = [];
+  const sortedFields = [...commonFields].sort();
+  for (const field of sortedFields) {
+    const values = [];
+    for (const item of items) {
+      if (isPlainObject(item) && field in item)
+        values.push(item[field]);
+    }
+    const uniqueValues = /* @__PURE__ */ new Set();
+    for (const v of values) {
+      if (v !== null)
+        uniqueValues.add(stringifyScalar(v));
+    }
+    if (uniqueValues.size < 2 || uniqueValues.size > 50)
+      continue;
+    const counts = /* @__PURE__ */ new Map();
+    for (const v of values) {
+      const key = v === null ? "__none__" : stringifyScalar(v);
+      counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    if (counts.size === 0)
+      continue;
+    const sortedCounts = [...counts.entries()].sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : 1));
+    const threshold = Math.ceil(values.length * 0.8);
+    let cumulative = 0;
+    const topK = /* @__PURE__ */ new Set();
+    for (const [value, count] of sortedCounts) {
+      cumulative += count;
+      topK.add(value);
+      if (cumulative >= threshold)
+        break;
+    }
+    if (topK.size > 5)
+      continue;
+    for (let i = 0; i < items.length; i++) {
+      const item = items[i];
+      if (!isPlainObject(item) || !(field in item))
+        continue;
+      const v = item[field];
+      const key = v === null ? "__none__" : stringifyScalar(v);
+      if (!topK.has(key))
+        outliers.push(i);
+    }
+  }
+  return outliers;
+}
+function detectStructuralOutliers(items) {
+  if (items.length < 5)
+    return [];
+  const fieldCounts = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    if (!isPlainObject(item))
+      continue;
+    for (const key of Object.keys(item)) {
+      fieldCounts.set(key, (fieldCounts.get(key) ?? 0) + 1);
+    }
+  }
+  const n = items.length;
+  const commonFields = /* @__PURE__ */ new Set();
+  const rareFields = /* @__PURE__ */ new Set();
+  for (const [field, count] of fieldCounts) {
+    if (count >= n * 0.8)
+      commonFields.add(field);
+    if (count < n * 0.2)
+      rareFields.add(field);
+  }
+  const outliers = /* @__PURE__ */ new Set();
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    if (!isPlainObject(item))
+      continue;
+    if (Object.keys(item).some((k) => rareFields.has(k)))
+      outliers.add(i);
+  }
+  for (const idx of detectRareStatusValues(items, commonFields))
+    outliers.add(idx);
+  return [...outliers].sort((a, b) => a - b);
+}
+function detectErrorItems(items) {
+  const out = [];
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    if (!isPlainObject(item))
+      continue;
+    const serialized = JSON.stringify(item).toLowerCase();
+    if (JSON_ERROR_KEYWORDS.some((kw) => serialized.includes(kw)))
+      out.push(i);
+  }
+  return out;
+}
+
+// src/crush/json-crusher.ts
+var DEFAULT_JSON_CONFIG = {
+  minItemsToAnalyze: 10,
+  maxItemsAfterCrush: 15,
+  firstFraction: 0.3,
+  lastFraction: 0.15,
+  bias: 1
+};
+function computeKSplit(kTotal, firstFraction, lastFraction) {
+  if (kTotal <= 1)
+    return { first: kTotal, last: 0 };
+  const first = Math.max(1, Math.round(kTotal * firstFraction));
+  const last = Math.max(1, Math.round(kTotal * lastFraction));
+  if (first + last > kTotal)
+    return { first: Math.max(1, kTotal - 1), last: kTotal > 1 ? 1 : 0 };
+  return { first, last };
+}
+function sequentialIdField(items) {
+  const first = items[0];
+  if (typeof first !== "object" || first === null || Array.isArray(first))
+    return null;
+  for (const key of Object.keys(first)) {
+    if (!/^(id|.*_id|index|seq|n)$/i.test(key))
+      continue;
+    const values = items.map(
+      (it) => typeof it === "object" && it !== null && !Array.isArray(it) ? it[key] ?? null : null
+    );
+    if (detectSequentialPattern(values))
+      return key;
+  }
+  return null;
+}
+function omittedMarker(droppedCount, items, droppedIndices) {
+  const idField = sequentialIdField(items);
+  if (idField && droppedIndices.length > 0) {
+    const firstDropped = items[droppedIndices[0]];
+    const lastDropped = items[droppedIndices[droppedIndices.length - 1]];
+    const idOf = (v) => typeof v === "object" && v !== null && !Array.isArray(v) ? v[idField] ?? null : null;
+    const lo = idOf(firstDropped);
+    const hi = idOf(lastDropped);
+    if (lo !== null && hi !== null) {
+      return `[... ${droppedCount} items omitted (${idField} ${lo}..${hi}) ...]`;
+    }
+  }
+  return `[... ${droppedCount} items omitted ...]`;
+}
+function crushDictArray(items, config) {
+  const n = items.length;
+  const serialized = items.map((it) => JSON.stringify(it));
+  const budget = computeOptimalK(serialized, config.bias, 5, config.maxItemsAfterCrush);
+  const keep = /* @__PURE__ */ new Set();
+  for (const idx of detectErrorItems(items))
+    keep.add(idx);
+  for (const idx of detectStructuralOutliers(items))
+    keep.add(idx);
+  const remaining = Math.max(0, budget - keep.size);
+  if (remaining > 0) {
+    const { first, last } = computeKSplit(remaining, config.firstFraction, config.lastFraction);
+    for (let i = 0; i < Math.min(first, n); i++)
+      keep.add(i);
+    for (let i = Math.max(0, n - last); i < n; i++)
+      keep.add(i);
+    let leftover = budget - keep.size;
+    if (leftover > 0) {
+      const step = Math.max(1, Math.floor(n / (leftover + 1)));
+      for (let i = step; i < n && leftover > 0; i += step) {
+        if (!keep.has(i)) {
+          keep.add(i);
+          leftover--;
+        }
+      }
+    }
+  }
+  if (keep.size >= n) {
+    return { items: [...items], originalCount: n, keptCount: n, crushed: false };
+  }
+  const keptIndices = [...keep].sort((a, b) => a - b);
+  const droppedIndices = [];
+  for (let i = 0; i < n; i++) {
+    if (!keep.has(i))
+      droppedIndices.push(i);
+  }
+  const out = [];
+  let markerPlaced = false;
+  for (let i = 0; i < n; i++) {
+    if (keep.has(i)) {
+      out.push(items[i]);
+    } else if (!markerPlaced) {
+      out.push(omittedMarker(droppedIndices.length, items, droppedIndices));
+      markerPlaced = true;
+    }
+  }
+  return { items: out, originalCount: n, keptCount: keptIndices.length, crushed: true };
+}
+function crushScalarArray(items, config) {
+  const n = items.length;
+  const serialized = items.map((it) => JSON.stringify(it));
+  const budget = computeOptimalK(serialized, config.bias, 5, config.maxItemsAfterCrush);
+  if (budget >= n) {
+    return { items: [...items], originalCount: n, keptCount: n, crushed: false };
+  }
+  const keep = /* @__PURE__ */ new Set();
+  const numbers = items.every((it) => typeof it === "number") ? items : null;
+  if (numbers) {
+    const mean = numbers.reduce((s, v) => s + v, 0) / n;
+    const variance = numbers.reduce((s, v) => s + (v - mean) ** 2, 0) / n;
+    const std = Math.sqrt(variance);
+    if (std > 0) {
+      for (let i = 0; i < n; i++) {
+        if (Math.abs(numbers[i] - mean) > 2 * std)
+          keep.add(i);
+      }
+    }
+  }
+  if (!numbers) {
+    for (let i = 0; i < n; i++) {
+      const it = items[i];
+      if (typeof it === "string") {
+        const lower = it.toLowerCase();
+        if (/(error|exception|failed|failure|fatal|panic|timeout)/.test(lower))
+          keep.add(i);
+      }
+    }
+  }
+  const remaining = Math.max(0, budget - keep.size);
+  if (remaining > 0) {
+    const { first, last } = computeKSplit(remaining, config.firstFraction, config.lastFraction);
+    for (let i = 0; i < Math.min(first, n); i++)
+      keep.add(i);
+    for (let i = Math.max(0, n - last); i < n; i++)
+      keep.add(i);
+  }
+  if (keep.size >= n) {
+    return { items: [...items], originalCount: n, keptCount: n, crushed: false };
+  }
+  const out = [];
+  let dropped = 0;
+  let markerAt = -1;
+  for (let i = 0; i < n; i++) {
+    if (keep.has(i)) {
+      out.push(items[i]);
+    } else {
+      dropped++;
+      if (markerAt === -1) {
+        markerAt = out.length;
+        out.push("");
+      }
+    }
+  }
+  if (markerAt >= 0)
+    out[markerAt] = `[... ${dropped} items omitted ...]`;
+  return { items: out, originalCount: n, keptCount: n - dropped, crushed: true };
+}
+function walkAndCrush(value, config, totals) {
+  if (Array.isArray(value)) {
+    const recursed = value.map((v) => walkAndCrush(v, config, totals));
+    if (recursed.length < config.minItemsToAnalyze)
+      return recursed;
+    const kind = classifyArray(recursed);
+    let outcome = null;
+    if (kind === "dict_array")
+      outcome = crushDictArray(recursed, config);
+    else if (kind === "string_array" || kind === "number_array")
+      outcome = crushScalarArray(recursed, config);
+    if (outcome && outcome.crushed) {
+      totals.original += outcome.originalCount;
+      totals.kept += outcome.keptCount;
+      totals.crushedArrays++;
+      return outcome.items;
+    }
+    totals.original += recursed.length;
+    totals.kept += recursed.length;
+    return recursed;
+  }
+  if (typeof value === "object" && value !== null) {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = walkAndCrush(v, config, totals);
+    }
+    return out;
+  }
+  return value;
+}
+function crushJson(content, config = {}) {
+  const cfg = { ...DEFAULT_JSON_CONFIG, ...config };
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return makePassthrough(content, "json", "not valid JSON");
+  }
+  const totals = { original: 0, kept: 0, crushedArrays: 0 };
+  const crushedValue = walkAndCrush(parsed, cfg, totals);
+  if (totals.crushedArrays === 0) {
+    return makePassthrough(content, "json", "no qualifying arrays", totals.original);
+  }
+  const output = JSON.stringify(crushedValue);
+  return {
+    output,
+    stats: {
+      sourceType: "json",
+      originalChars: content.length,
+      compressedChars: output.length,
+      compressionRatio: output.length / Math.max(content.length, 1),
+      originalUnits: totals.original,
+      keptUnits: totals.kept,
+      passthrough: false
+    }
+  };
+}
+
+// src/crush/code-compressor.ts
+var DEFAULT_CODE_CONFIG = {
+  minLines: 8,
+  maxBodyLines: 3
+};
+function detectCodeLanguage(content) {
+  const braces = (content.match(/[{}]/g) || []).length;
+  let pyDef = 0;
+  let colonBlock = 0;
+  for (const raw of content.split("\n")) {
+    const t = raw.trim();
+    if (/^(?:async\s+def|def)\s+\w+\s*\(/.test(t))
+      pyDef++;
+    if (/:\s*(?:#.*)?$/.test(t) && /^(?:def|class|if|elif|else|for|while|try|except|finally|with|async\s+def|match|case)\b/.test(t)) {
+      colonBlock++;
+    }
+  }
+  if (pyDef > 0 && braces <= pyDef)
+    return "python";
+  if (braces === 0 && colonBlock > 0)
+    return "python";
+  return "cfamily";
+}
+var DECL_RE = /^\s*(?:export\s+|default\s+|pub\s+|public\s+|private\s+|protected\s+|static\s+|final\s+|abstract\s+|async\s+)*(?:import\b|from\s+\S+\s+import\b|require\s*\(|use\s+\w|#include\b|package\s+\w|using\s+\w|namespace\s+\w|function\b|func\s+\w|fn\s+\w|def\s+\w|class\s+\w|interface\s+\w|type\s+\w+\s*[=<]|struct\s+\w|enum\s+\w|impl\b|trait\s+\w|const\s+\w|let\s+\w|var\s+\w|val\s+\w)|^\s*@\w[\w.]*\s*(?:\(|$)/;
+var LOG_LINE_RE = /^\s*(?:\[?\d{4}-\d\d-\d\d|\d\d:\d\d:\d\d|(?:INFO|DEBUG|WARN|WARNING|ERROR|TRACE|FATAL|CRITICAL)\b|npm (?:ERR!|WARN|info)|at\s+\S+\s*\(|Traceback\b|File ")/;
+function looksProse(t) {
+  if (/[{};=<>]/.test(t))
+    return false;
+  if (!/[.!?]['")]?$/.test(t))
+    return false;
+  return t.split(/\s+/).filter(Boolean).length >= 5;
+}
+function looksLikeCode(text) {
+  const lines = text.split("\n").filter((l) => l.trim() !== "").slice(0, 100);
+  const n = lines.length;
+  if (n < 4)
+    return false;
+  let decl = 0;
+  let struct = 0;
+  let log = 0;
+  let prose = 0;
+  for (const l of lines) {
+    const t = l.trim();
+    if (DECL_RE.test(l))
+      decl++;
+    if (/[{};]\s*$/.test(t) || /=>\s*\{?\s*$/.test(t) || /:\s*(?:#.*)?$/.test(t) && /^(?:def|class|if|elif|else|for|while|try|except|finally|with|async\s+def|match|case)\b/.test(t)) {
+      struct++;
+    }
+    if (LOG_LINE_RE.test(l))
+      log++;
+    if (looksProse(t))
+      prose++;
+  }
+  if (log / n >= 0.3)
+    return false;
+  if (prose / n >= 0.5)
+    return false;
+  if (decl < 2)
+    return false;
+  return (decl + struct) / n >= 0.4;
+}
+var CONTROL_HEAD_RE = /^(?:if|for|while|switch|catch|do|else|try|finally|with|when|return|throw|=>)\b/;
+function lineOpensFunc(line) {
+  const t = line.trim();
+  const brace = t.indexOf("{");
+  if (brace === -1)
+    return false;
+  const sig = t.slice(0, brace).trim();
+  if (sig === "")
+    return false;
+  if (sig.startsWith("}"))
+    return false;
+  if (CONTROL_HEAD_RE.test(sig))
+    return false;
+  if (/\bfunction\b/.test(sig))
+    return true;
+  if (/^(?:pub\s+|async\s+|public\s+|private\s+|protected\s+|static\s+|final\s+|export\s+|default\s+|unsafe\s+|inline\s+|virtual\s+|override\s+)*(?:func|fn)\b/.test(sig)) {
+    return true;
+  }
+  if (/=>\s*$/.test(sig))
+    return true;
+  if (/\)\s*(?::\s*[^{]+)?$/.test(sig) && (/\w\s*\(/.test(sig) || sig === ")"))
+    return true;
+  return false;
+}
+function braceEvents(line, st) {
+  const events = [];
+  let inBlock = st.inBlockComment;
+  let quote = null;
+  let i = 0;
+  const n = line.length;
+  while (i < n) {
+    const c = line[i];
+    const c2 = i + 1 < n ? line[i + 1] : "";
+    if (inBlock) {
+      if (c === "*" && c2 === "/") {
+        inBlock = false;
+        i += 2;
+        continue;
+      }
+      i++;
+      continue;
+    }
+    if (quote) {
+      if (c === "\\") {
+        i += 2;
+        continue;
+      }
+      if (c === quote)
+        quote = null;
+      i++;
+      continue;
+    }
+    if (c === "/" && c2 === "/")
+      break;
+    if (c === "/" && c2 === "*") {
+      inBlock = true;
+      i += 2;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === "`") {
+      quote = c;
+      i++;
+      continue;
+    }
+    if (c === "{") {
+      events.push("{");
+      i++;
+      continue;
+    }
+    if (c === "}") {
+      events.push("}");
+      i++;
+      continue;
+    }
+    i++;
+  }
+  return { events, st: { inBlockComment: inBlock } };
+}
+function leadingWhitespace(line) {
+  return line.slice(0, line.length - line.trimStart().length);
+}
+var CodeOutput = class {
+  constructor(commentPrefix) {
+    this.commentPrefix = commentPrefix;
+    this.lines = [];
+    this.kept = 0;
+    this.omitted = [];
+  }
+  keep(line) {
+    this.flush();
+    this.lines.push(line);
+    this.kept++;
+  }
+  drop(line) {
+    this.omitted.push(line);
+  }
+  flush() {
+    if (this.omitted.length === 0)
+      return;
+    const anchor = this.omitted.find((l) => l.trim() !== "") ?? this.omitted[0];
+    const indent = leadingWhitespace(anchor);
+    this.lines.push(`${indent}${this.commentPrefix} [${this.omitted.length} lines omitted]`);
+    this.omitted = [];
+  }
+};
+function compressBraces(lines, cfg, commentPrefix) {
+  const out = new CodeOutput(commentPrefix);
+  const stack = [];
+  let scan = { inBlockComment: false };
+  for (const line of lines) {
+    const innermost = innermostFunc(stack);
+    const insideFunc = innermost !== null;
+    const trimmed = line.trim();
+    const inComment = scan.inBlockComment;
+    const { events, st } = braceEvents(line, scan);
+    scan = st;
+    let firstPush = true;
+    let closedFunc = false;
+    const opensFunc = lineOpensFunc(line);
+    for (const ev of events) {
+      if (ev === "{") {
+        const kind = firstPush && opensFunc ? "func" : "other";
+        firstPush = false;
+        stack.push({ kind, budget: kind === "func" ? cfg.maxBodyLines : 0 });
+      } else {
+        const f = stack.pop();
+        if (f && f.kind === "func")
+          closedFunc = true;
+      }
+    }
+    let keep;
+    if (!insideFunc || inComment)
+      keep = true;
+    else if (closedFunc)
+      keep = true;
+    else if (trimmed === "")
+      keep = innermost.budget > 0;
+    else if (innermost.budget > 0) {
+      keep = true;
+      innermost.budget--;
+    } else
+      keep = false;
+    if (keep)
+      out.keep(line);
+    else
+      out.drop(line);
+  }
+  out.flush();
+  return out;
+}
+function innermostFunc(stack) {
+  for (let i = stack.length - 1; i >= 0; i--) {
+    if (stack[i].kind === "func")
+      return stack[i];
+  }
+  return null;
+}
+var PY_STRUCT_RE = /^(?:@|async\s+def\b|def\b|class\b|import\b|from\b)/;
+var PY_DEF_RE = /^(?:async\s+def|def)\b/;
+function compressPython(lines, cfg, commentPrefix) {
+  const out = new CodeOutput(commentPrefix);
+  const stack = [];
+  for (const line of lines) {
+    const stripped = line.trim();
+    if (stripped === "") {
+      const top = stack[stack.length - 1];
+      out_keepOrDrop(out, line, top ? top.budget > 0 : true);
+      continue;
+    }
+    const indent = leadingWhitespace(line).length;
+    while (stack.length && indent <= stack[stack.length - 1].indent)
+      stack.pop();
+    const inside = stack.length > 0;
+    let keep;
+    if (PY_STRUCT_RE.test(stripped))
+      keep = true;
+    else if (!inside)
+      keep = true;
+    else {
+      const top = stack[stack.length - 1];
+      if (top.budget > 0) {
+        keep = true;
+        top.budget--;
+      } else
+        keep = false;
+    }
+    out_keepOrDrop(out, line, keep);
+    if (PY_DEF_RE.test(stripped))
+      stack.push({ indent, budget: cfg.maxBodyLines });
+  }
+  out.flush();
+  return out;
+}
+function out_keepOrDrop(out, line, keep) {
+  if (keep)
+    out.keep(line);
+  else
+    out.drop(line);
+}
+function crushCode(content, config = {}) {
+  const cfg = { ...DEFAULT_CODE_CONFIG, ...config };
+  const lines = content.split("\n");
+  if (lines.length < cfg.minLines) {
+    return makePassthrough(content, "code", "below min line count", lines.length);
+  }
+  const lang = cfg.language ?? detectCodeLanguage(content);
+  const commentPrefix = cfg.commentPrefix ?? (lang === "python" ? "#" : "//");
+  const out = lang === "python" ? compressPython(lines, cfg, commentPrefix) : compressBraces(lines, cfg, commentPrefix);
+  if (out.kept >= lines.length) {
+    return makePassthrough(content, "code", "no compressible bodies", lines.length);
+  }
+  const output = out.lines.join("\n");
+  return {
+    output,
+    stats: {
+      sourceType: "code",
+      originalChars: content.length,
+      compressedChars: output.length,
+      compressionRatio: output.length / Math.max(content.length, 1),
+      originalUnits: lines.length,
+      keptUnits: out.kept,
+      passthrough: false
+    }
+  };
+}
+
+// src/opencode-plugin-crush.ts
+var CCR_MARKER_HASH_LEN = 16;
+function ccrMarker(hash) {
+  return `<<ccr:${hash.slice(0, CCR_MARKER_HASH_LEN)}>>`;
+}
+var CCR_MARKER_RE = /<<ccr:/;
+var FINAL_MARKER_OVERHEAD = 1 + "<<ccr:".length + CCR_MARKER_HASH_LEN + ">>".length;
+var DEFAULT_THRESHOLD_BYTES = 2048;
+function memoKey(content) {
+  let h1 = 2166136261;
+  let h2 = 5381;
+  for (let i = 0; i < content.length; i++) {
+    const c = content.charCodeAt(i);
+    h1 ^= c;
+    h1 = Math.imul(h1, 16777619);
+    h2 = Math.imul(h2, 33) + c | 0;
+  }
+  return `${content.length.toString(36)}:${(h1 >>> 0).toString(36)}:${(h2 >>> 0).toString(36)}`;
+}
+function classifyContent(text) {
+  const t = text.trimStart();
+  const head = t[0];
+  if (head === "{" || head === "[")
+    return "json";
+  const lines = t.split("\n", 21).map((l) => l.trim()).filter(Boolean).slice(0, 20);
+  if (lines.length) {
+    const matchLike = lines.filter((l) => /^.+?[:\-]\d+[:\-]/.test(l)).length;
+    if (matchLike / lines.length >= 0.6)
+      return "search";
+  }
+  if (looksLikeCode(t))
+    return "code";
+  return "log";
+}
+function runEngine(type, content) {
+  switch (type) {
+    case "search":
+      return crushSearch(content, "");
+    case "json":
+      return crushJson(content);
+    case "code":
+      return crushCode(content);
+    default:
+      return crushLog(content);
+  }
+}
+function crushField(content, stash, thresholdBytes = DEFAULT_THRESHOLD_BYTES) {
+  if (typeof content !== "string")
+    return null;
+  if (CCR_MARKER_RE.test(content))
+    return null;
+  if (Buffer.byteLength(content, "utf8") < thresholdBytes)
+    return null;
+  const type = classifyContent(content);
+  const result = runEngine(type, content);
+  if (result.stats.passthrough)
+    return null;
+  const crushed = result.output;
+  const finalTokens = Math.ceil((crushed.length + FINAL_MARKER_OVERHEAD) / 4);
+  if (finalTokens >= estimateTokens(content))
+    return null;
+  const hash = stash(content, type);
+  return `${crushed}
+${ccrMarker(hash)}`;
+}
+function crushAndApply(obj, key, stash, thresholdBytes, stats, memo) {
+  const content = obj[key];
+  if (typeof content !== "string")
+    return;
+  const bytes = Buffer.byteLength(content, "utf8");
+  if (bytes < thresholdBytes) {
+    stats.partsSkipped++;
+    return;
+  }
+  if (CCR_MARKER_RE.test(content)) {
+    stats.partsSkipped++;
+    return;
+  }
+  stats.bytesBefore += bytes;
+  let replacement;
+  if (memo) {
+    const k = memoKey(content);
+    if (memo.has(k)) {
+      replacement = memo.get(k) ?? null;
+      stats.memoHits++;
+    } else {
+      replacement = crushField(content, stash, thresholdBytes);
+      stats.crushFieldCalls++;
+      memo.set(k, replacement);
+    }
+  } else {
+    replacement = crushField(content, stash, thresholdBytes);
+    stats.crushFieldCalls++;
+  }
+  if (replacement === null) {
+    stats.partsReverted++;
+    stats.bytesAfter += bytes;
+    return;
+  }
+  obj[key] = replacement;
+  stats.partsCrushed++;
+  stats.bytesAfter += Buffer.byteLength(replacement, "utf8");
+}
+function processPart(part, stash, thresholdBytes, stats, memo) {
+  if (!part || typeof part !== "object")
+    return;
+  const p = part;
+  if (p.type === "text" && typeof p.text === "string") {
+    crushAndApply(p, "text", stash, thresholdBytes, stats, memo);
+    return;
+  }
+  if (p.type === "tool" && p.state && typeof p.state === "object") {
+    const state = p.state;
+    if (state.status === "completed" && typeof state.output === "string") {
+      crushAndApply(state, "output", stash, thresholdBytes, stats, memo);
+    }
+  }
+}
+function crushMessages(messages, opts) {
+  const stats = {
+    partsCrushed: 0,
+    partsSkipped: 0,
+    partsReverted: 0,
+    bytesBefore: 0,
+    bytesAfter: 0,
+    crushFieldCalls: 0,
+    memoHits: 0
+  };
+  const thresholdBytes = opts.thresholdBytes ?? DEFAULT_THRESHOLD_BYTES;
+  if (!Array.isArray(messages))
+    return stats;
+  for (const msg of messages) {
+    const parts = msg && typeof msg === "object" ? msg.parts : null;
+    if (!Array.isArray(parts))
+      continue;
+    for (const part of parts) {
+      try {
+        processPart(part, opts.stash, thresholdBytes, stats, opts.memo);
+      } catch {
+        stats.partsSkipped++;
+      }
+    }
+  }
+  return stats;
+}
+
+// src/opencode-plugin.ts
+var DEBUG_LOG_PATH = path2.join(os.homedir(), ".greprag", "opencode-plugin-debug.log");
+var _debugLogReady = false;
+function dlogInit() {
+  if (_debugLogReady)
+    return;
+  _debugLogReady = true;
+  try {
+    fs2.writeFileSync(DEBUG_LOG_PATH, "");
+  } catch {
+  }
+}
+function dlog(msg) {
+  dlogInit();
+  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] [greprag-memory] ${msg}
+`;
+  try {
+    fs2.appendFileSync(DEBUG_LOG_PATH, line);
+  } catch {
+  }
+}
+dlog(`module top reached: pid=${process.pid} argv0=${process.argv[0]} distPath=${__filename}`);
+var API_URL = "https://api.greprag.com";
+function loadEnvFile(filePath) {
+  try {
+    if (!fs2.existsSync(filePath))
+      return;
+    const raw = fs2.readFileSync(filePath, "utf-8");
+    for (const line of raw.split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#"))
+        continue;
+      const idx = trimmed.indexOf("=");
+      if (idx < 1)
+        continue;
+      const key = trimmed.slice(0, idx).trim();
+      let value = trimmed.slice(idx + 1).trim();
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
+      }
+      if (!process.env[key])
+        process.env[key] = value;
+    }
+  } catch {
+  }
+}
+function loadGrepragEnv() {
+  loadEnvFile(path2.join(HOME, ".greprag", ".env"));
+  try {
+    const p = path2.join(HOME, ".claude", "settings.json");
+    if (!fs2.existsSync(p))
+      return;
+    const data = JSON.parse(fs2.readFileSync(p, "utf-8"));
+    if (data && data.env && typeof data.env === "object") {
+      for (const [key, val] of Object.entries(data.env)) {
+        if (!process.env[key] && typeof val === "string") {
+          process.env[key] = val;
+        }
+      }
+    }
+  } catch {
+  }
+}
+loadGrepragEnv();
+dlog(`env loaded: MEMORY_HOOK_ENABLED=${process.env.MEMORY_HOOK_ENABLED || "<unset>"} GREPRAG_API_KEY=${process.env.GREPRAG_API_KEY ? "set" : "<unset>"} GREPRAG_OPENCODE_CAPTURE=${process.env.GREPRAG_OPENCODE_CAPTURE || "<unset>"}`);
+var WATCHER_LOCK = path2.join(HOME || os.homedir(), ".greprag", "opencode-watch.lock");
+var WATCHER_STALE_MS = 3e4;
+function findGrepragBinary() {
+  const override = process.env.GREPRAG_BIN;
+  if (override && fs2.existsSync(override))
+    return override;
+  const binaryName = process.platform === "win32" ? "greprag.cmd" : "greprag";
+  try {
+    const out = safeExecSync(`where ${binaryName}`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    for (const line of out.split(/\r?\n/)) {
+      const candidate = line.trim();
+      if (!candidate)
+        continue;
+      if (!fs2.existsSync(candidate))
+        continue;
+      if (process.platform === "win32") {
+        const ext = path2.extname(candidate).toLowerCase();
+        if (ext === ".cmd" || ext === ".exe" || ext === ".bat")
+          return candidate;
+        const cmdSibling = candidate + ".cmd";
+        if (fs2.existsSync(cmdSibling))
+          return cmdSibling;
+        continue;
+      }
+      return candidate;
+    }
+  } catch {
+  }
+  const candidates = process.platform === "win32" ? [
+    path2.join(HOME, "AppData", "Roaming", "npm", "greprag.cmd"),
+    path2.join(HOME, "AppData", "Roaming", "npm", "greprag"),
+    path2.join(HOME, "AppData", "Local", "Yarn", "bin", "greprag.cmd"),
+    path2.join(HOME, "AppData", "Local", "pnpm", "bin", "greprag.cmd")
+  ] : [
+    "/usr/local/bin/greprag",
+    "/opt/homebrew/bin/greprag",
+    path2.join(HOME || "", ".local", "bin", "greprag"),
+    path2.join(HOME || "", ".yarn", "bin", "greprag")
+  ];
+  for (const c of candidates) {
+    try {
+      if (c && fs2.existsSync(c))
+        return c;
+    } catch {
+    }
+  }
+  return null;
+}
+function tryClaimWatcherLock() {
+  try {
+    const fd = fs2.openSync(WATCHER_LOCK, "wx");
+    return { ok: true, fd };
+  } catch (err) {
+    if (err.code !== "EEXIST") {
+      return { ok: false, reason: "lock-create-failed" };
+    }
+    try {
+      const stat = fs2.statSync(WATCHER_LOCK);
+      const ageMs = Date.now() - stat.mtimeMs;
+      let pidAlive = false;
+      try {
+        const pid = parseInt(fs2.readFileSync(WATCHER_LOCK, "utf-8").trim(), 10);
+        pidAlive = pid > 0 && isPidAlive(pid);
+      } catch {
+      }
+      if (ageMs < WATCHER_STALE_MS && pidAlive) {
+        return { ok: false, reason: "busy" };
+      }
+      try {
+        fs2.unlinkSync(WATCHER_LOCK);
+      } catch {
+      }
+      const fd = fs2.openSync(WATCHER_LOCK, "wx");
+      return { ok: true, fd };
+    } catch (err2) {
+      return { ok: false, reason: "lock-stale-replace-failed" };
+    }
+  }
+}
+function startCaptureWatcher() {
+  dlog(`startCaptureWatcher: entry CAPTURE=${process.env.GREPRAG_OPENCODE_CAPTURE || "<unset>"} HOOK=${process.env.MEMORY_HOOK_ENABLED || "<unset>"} KEY=${process.env.GREPRAG_API_KEY ? "set" : "<unset>"}`);
+  if (process.env.GREPRAG_OPENCODE_CAPTURE === "0") {
+    dlog("startCaptureWatcher: bail \u2014 GREPRAG_OPENCODE_CAPTURE=0");
+    return;
+  }
+  if (process.env.MEMORY_HOOK_ENABLED !== "true") {
+    dlog("startCaptureWatcher: bail \u2014 MEMORY_HOOK_ENABLED!=true");
+    return;
+  }
+  if (!process.env.GREPRAG_API_KEY) {
+    dlog("startCaptureWatcher: bail \u2014 no GREPRAG_API_KEY");
+    return;
+  }
+  const grepragBin = findGrepragBinary();
+  dlog(`startCaptureWatcher: findGrepragBinary -> ${grepragBin || "<null>"}`);
+  if (!grepragBin) {
+    process.stderr.write(
+      "[greprag-memory] opencode watch could not start: greprag binary not in PATH. Run `npm install -g @greprag/cli` or set GREPRAG_BIN.\n"
+    );
+    return;
+  }
+  const claim = tryClaimWatcherLock();
+  dlog(`startCaptureWatcher: lock claim ok=${claim.ok}${claim.ok ? "" : " reason=" + claim.reason}`);
+  if (!claim.ok) {
+    if (claim.reason === "busy") {
+      process.stderr.write("[greprag-memory] opencode watch already running; not spawning\n");
+    } else {
+      process.stderr.write(`[greprag-memory] opencode watch could not claim lock: ${claim.reason}
+`);
+    }
+    return;
+  }
+  try {
+    fs2.writeSync(claim.fd, String(process.pid));
+    fs2.closeSync(claim.fd);
+  } catch {
+    try {
+      fs2.unlinkSync(WATCHER_LOCK);
+    } catch {
+    }
+    return;
+  }
+  let stopped = false;
+  let currentChildPid = null;
+  let currentChild = null;
+  let respawnCount = 0;
+  let childStartTime = 0;
+  const MAX_RESPAWNS = 10;
+  const MAX_BACKOFF_MS = 3e4;
+  function tryReclaimLockForRespawn() {
+    const claim2 = tryClaimWatcherLock();
+    if (claim2.ok) {
+      try {
+        fs2.writeSync(claim2.fd, String(process.pid));
+        fs2.closeSync(claim2.fd);
+      } catch {
+        try {
+          fs2.unlinkSync(WATCHER_LOCK);
+        } catch {
+        }
+        return false;
+      }
+      return true;
+    }
+    if (claim2.reason === "busy") {
+      process.stderr.write(
+        "[greprag-memory] lockfile claimed by another opencode instance; not respawning\n"
+      );
+    } else {
+      process.stderr.write(
+        `[greprag-memory] respawn lockfile error: ${claim2.reason}
+`
+      );
+    }
+    return false;
+  }
+  function spawnWatcher() {
+    if (stopped)
+      return;
+    if (!grepragBin)
+      return;
+    let child;
+    try {
+      child = safeSpawn(grepragBin, ["opencode", "watch"], {
+        stdio: ["ignore", "pipe", "pipe"],
+        env: process.env,
+        windowsHide: true,
+        shell: process.platform === "win32"
+      });
+    } catch (err) {
+      process.stderr.write(`[greprag-memory] spawn failed: ${err.message}
+`);
+      scheduleRespawn();
+      return;
+    }
+    currentChild = child;
+    currentChildPid = child.pid ?? null;
+    childStartTime = Date.now();
+    dlog(`startCaptureWatcher: spawned 'greprag opencode watch' pid=${child.pid ?? "<none>"}`);
+    try {
+      fs2.writeFileSync(WATCHER_LOCK, String(child.pid));
+    } catch {
+    }
+    child.stderr?.on("data", (chunk) => {
+      process.stderr.write(`[greprag-watch] ${chunk.toString("utf-8")}`);
+    });
+    child.stdout?.on("data", (chunk) => {
+      process.stderr.write(`[greprag-watch] ${chunk.toString("utf-8")}`);
+    });
+    child.on("exit", (code, signal) => {
+      dlog(`startCaptureWatcher: child pid=${child.pid ?? "<none>"} exited code=${code} signal=${signal || "none"}`);
+      try {
+        const current = fs2.readFileSync(WATCHER_LOCK, "utf-8").trim();
+        if (current === String(child.pid))
+          fs2.unlinkSync(WATCHER_LOCK);
+      } catch {
+      }
+      currentChild = null;
+      currentChildPid = null;
+      if (stopped)
+        return;
+      const cleanShutdown = code === 0 || signal === "SIGTERM" || signal === "SIGKILL";
+      if (!cleanShutdown) {
+        process.stderr.write(
+          `[greprag-memory] opencode watch exited code=${code} signal=${signal || "none"}, respawning
+`
+        );
+      }
+      scheduleRespawn();
+    });
+  }
+  function scheduleRespawn() {
+    if (stopped)
+      return;
+    if (Date.now() - childStartTime > 3e4)
+      respawnCount = 0;
+    respawnCount++;
+    if (respawnCount > MAX_RESPAWNS) {
+      process.stderr.write(
+        `[greprag-memory] opencode watch respawned ${respawnCount} times; giving up. Run \`greprag doctor\` to investigate.
+`
+      );
+      try {
+        fs2.unlinkSync(WATCHER_LOCK);
+      } catch {
+      }
+      return;
+    }
+    if (!tryReclaimLockForRespawn())
+      return;
+    const backoff = Math.min(MAX_BACKOFF_MS, 1e3 * Math.pow(2, Math.min(respawnCount, 5)));
+    process.stderr.write(
+      `[greprag-memory] respawning opencode watch in ${Math.round(backoff / 1e3)}s (attempt ${respawnCount}/${MAX_RESPAWNS})
+`
+    );
+    setTimeout(spawnWatcher, backoff).unref();
+  }
+  spawnWatcher();
+  const cleanup = () => {
+    if (stopped)
+      return;
+    stopped = true;
+    if (currentChild) {
+      try {
+        currentChild.kill("SIGTERM");
+      } catch {
+      }
+      setTimeout(() => {
+        try {
+          currentChild?.kill("SIGKILL");
+        } catch {
+        }
+      }, 2e3).unref();
+    }
+    try {
+      fs2.unlinkSync(WATCHER_LOCK);
+    } catch {
+    }
+  };
+  process.on("exit", cleanup);
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(0);
+  });
+}
+startCaptureWatcher();
+function getEnv(key) {
+  return process.env[key] || "";
+}
+async function fetchRecapInbox(anchor) {
+  const apiKey = getEnv("GREPRAG_API_KEY");
+  if (!apiKey) {
+    dlog("fetchRecapInbox: no API key \u2014 returning empty");
+    return [];
+  }
+  if (!anchor.sessionStartRecap) {
+    dlog(`sessionStartRecap=false on anchor \u2014 skipping memory fetch (per-project opt-out)`);
+    return [];
+  }
+  const body = await buildRecapBody(API_URL, apiKey, anchor);
+  dlog(`buildRecapBody returned ${body.length} chars (projectId=${anchor.projectId})`);
+  if (!body)
+    return [];
+  return [body];
+}
+var relayArmedBySession = /* @__PURE__ */ new Set();
+var cachedRecap = null;
+var RECAP_CACHE_TTL_MS = 5 * 6e4;
+function startSessionRelay(sessionId, serverUrl) {
+  if (process.env.GREPRAG_OPENCODE_RELAY === "0")
+    return;
+  if (process.env.MEMORY_HOOK_ENABLED !== "true")
+    return;
+  if (!process.env.GREPRAG_API_KEY)
+    return;
+  if (relayArmedBySession.has(sessionId))
+    return;
+  relayArmedBySession.add(sessionId);
+  dlog(`startSessionRelay: arming sid=${sessionId.replace(/[^0-9a-f]/gi, "").slice(0, 8)} url=${serverUrl}`);
+  const grepragBin = findGrepragBinary();
+  dlog(`startSessionRelay: findGrepragBinary -> ${grepragBin || "<null>"}`);
+  if (!grepragBin) {
+    process.stderr.write(
+      "[greprag-memory] relay could not start: greprag binary not in PATH. Run `npm install -g @greprag/cli` or set GREPRAG_BIN.\n"
+    );
+    return;
+  }
+  const lockPath = relayLockPath(sessionId);
+  const claim = tryClaimRelayLock(lockPath);
+  if (!claim.ok) {
+    if (claim.reason === "busy") {
+      process.stderr.write(
+        `[greprag-memory] relay for session ${sessionId} already running; not spawning
+`
+      );
+    } else {
+      process.stderr.write(
+        `[greprag-memory] relay lockfile error: ${claim.reason}
+`
+      );
+    }
+    return;
+  }
+  try {
+    fs2.writeSync(claim.fd, String(process.pid));
+    fs2.closeSync(claim.fd);
+  } catch {
+    try {
+      fs2.unlinkSync(lockPath);
+    } catch {
+    }
+    return;
+  }
+  let stopped = false;
+  let currentChild = null;
+  let respawnCount = 0;
+  let childStartTime = 0;
+  const MAX_RESPAWNS = 10;
+  const MAX_BACKOFF_MS = 3e4;
+  function tryReclaimLockForRespawn() {
+    const claim2 = tryClaimRelayLock(lockPath);
+    if (claim2.ok) {
+      try {
+        fs2.writeSync(claim2.fd, String(process.pid));
+        fs2.closeSync(claim2.fd);
+      } catch {
+        try {
+          fs2.unlinkSync(lockPath);
+        } catch {
+        }
+        return false;
+      }
+      return true;
+    }
+    if (claim2.reason === "busy") {
+      process.stderr.write(
+        `[greprag-memory] relay lockfile claimed by another process; not respawning
+`
+      );
+    }
+    return false;
+  }
+  function spawnRelay() {
+    if (stopped)
+      return;
+    let child;
+    try {
+      child = safeSpawn(grepragBin, ["opencode", "relay", "--session", sessionId, "--opencode-url", serverUrl], {
+        stdio: ["ignore", "pipe", "pipe"],
+        env: process.env,
+        windowsHide: true,
+        shell: process.platform === "win32"
+      });
+    } catch (err) {
+      process.stderr.write(`[greprag-relay] spawn failed: ${err.message}
+`);
+      scheduleRespawn();
+      return;
+    }
+    currentChild = child;
+    childStartTime = Date.now();
+    dlog(`startSessionRelay: spawned 'greprag opencode relay' pid=${child.pid ?? "<none>"}`);
+    try {
+      fs2.writeFileSync(lockPath, String(child.pid));
+    } catch {
+    }
+    child.stderr?.on("data", (chunk) => {
+      process.stderr.write(`[greprag-relay] ${chunk.toString("utf-8")}`);
+    });
+    child.stdout?.on("data", (chunk) => {
+      process.stderr.write(`[greprag-relay] ${chunk.toString("utf-8")}`);
+    });
+    child.on("exit", (code, signal) => {
+      try {
+        const current = fs2.readFileSync(lockPath, "utf-8").trim();
+        if (current === String(child.pid))
+          fs2.unlinkSync(lockPath);
+      } catch {
+      }
+      currentChild = null;
+      if (stopped)
+        return;
+      if (code !== 0 && signal !== "SIGTERM" && signal !== "SIGKILL") {
+        process.stderr.write(
+          `[greprag-memory] relay for ${sessionId} exited code=${code} signal=${signal || "none"}, respawning
+`
+        );
+      }
+      scheduleRespawn();
+    });
+  }
+  function scheduleRespawn() {
+    if (stopped)
+      return;
+    if (Date.now() - childStartTime > 3e4)
+      respawnCount = 0;
+    respawnCount++;
+    if (respawnCount > MAX_RESPAWNS) {
+      process.stderr.write(
+        `[greprag-memory] relay for ${sessionId} respawned ${respawnCount} times; giving up. Run \`greprag doctor\` to investigate.
+`
+      );
+      try {
+        fs2.unlinkSync(lockPath);
+      } catch {
+      }
+      return;
+    }
+    if (!tryReclaimLockForRespawn())
+      return;
+    const backoff = Math.min(MAX_BACKOFF_MS, 1e3 * Math.pow(2, Math.min(respawnCount, 5)));
+    process.stderr.write(
+      `[greprag-memory] respawning relay for ${sessionId} in ${Math.round(backoff / 1e3)}s (attempt ${respawnCount}/${MAX_RESPAWNS})
+`
+    );
+    setTimeout(spawnRelay, backoff).unref();
+  }
+  spawnRelay();
+  const cleanup = () => {
+    if (stopped)
+      return;
+    stopped = true;
+    if (currentChild) {
+      try {
+        currentChild.kill("SIGTERM");
+      } catch {
+      }
+      setTimeout(() => {
+        try {
+          currentChild?.kill("SIGKILL");
+        } catch {
+        }
+      }, 2e3).unref();
+    }
+    try {
+      fs2.unlinkSync(lockPath);
+    } catch {
+    }
+  };
+  process.on("exit", cleanup);
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(0);
+  });
+}
+var _cachedGrepragBin;
+function grepragBinCached() {
+  if (_cachedGrepragBin === void 0)
+    _cachedGrepragBin = findGrepragBinary();
+  return _cachedGrepragBin;
+}
+var _crushShapeLogged = false;
+function inlineCrushEnabled() {
+  const v = process.env.GREPRAG_OPENCODE_CRUSH;
+  return v === "true" || v === "1";
+}
+function makeCcrStash() {
+  return (original, sourceType) => {
+    const hash = crypto2.createHash("sha256").update(original, "utf8").digest("hex").slice(0, 16);
+    const bin = grepragBinCached();
+    if (bin) {
+      try {
+        const child = safeSpawn(bin, ["ccr", "put", "--type", sourceType], {
+          stdio: ["pipe", "ignore", "ignore"],
+          env: process.env,
+          windowsHide: true,
+          shell: process.platform === "win32"
+        });
+        child.on("error", () => {
+        });
+        if (child.stdin) {
+          child.stdin.on("error", () => {
+          });
+          child.stdin.write(original);
+          child.stdin.end();
+        }
+        child.unref();
+      } catch {
+      }
+    }
+    return hash;
+  };
+}
+var GrepRAGMemoryPlugin = async (ctx) => {
+  dlog(`plugin function INVOKED (this is the entry opencode calls)`);
+  const apiKey = getEnv("GREPRAG_API_KEY");
+  const enabled = getEnv("MEMORY_HOOK_ENABLED") === "true";
+  dlog(`plugin invoked: enabled=${enabled} apiKeySet=${!!apiKey} worktree=${ctx.worktree} directory=${ctx.directory}`);
+  if (!enabled || !apiKey) {
+    dlog(`bailing: env gate closed (enabled=${enabled} apiKeySet=${!!apiKey}). No hooks will register.`);
+    return {};
+  }
+  const client = ctx.client;
+  const fallbackAnchor = readAnchor(ctx.worktree);
+  const fallbackWorkingDir = ctx.directory || ctx.worktree;
+  async function resolveSessionContext(sessionID) {
+    try {
+      const session = await client.session.get({ path: { id: sessionID } });
+      const dir = session && (session.directory || session.path);
+      if (typeof dir === "string" && dir) {
+        return { anchor: readAnchor(dir), workingDir: dir };
+      }
+    } catch {
+    }
+    return { anchor: fallbackAnchor, workingDir: fallbackWorkingDir };
+  }
+  return {
+    "experimental.chat.system.transform": async (input, output) => {
+      const sid = input && input.sessionID;
+      const sidShort = sid ? sid.replace(/[^0-9a-f]/gi, "").slice(0, 8) || sid.slice(0, 8) : "<none>";
+      dlog(`hook fired sid=${sidShort}\u2026 model=${input?.model?.modelID || input?.model?.id || "?"}`);
+      if (sid && !relayArmedBySession.has(sid)) {
+        startSessionRelay(sid, ctx.serverUrl.toString());
+      }
+      const anchor = sid ? (await resolveSessionContext(sid)).anchor : fallbackAnchor;
+      let body;
+      if (cachedRecap && cachedRecap.projectId === anchor.projectId && Date.now() - cachedRecap.fetchedAt < RECAP_CACHE_TTL_MS) {
+        body = cachedRecap.body;
+        dlog(`recap cache hit for projectId=${anchor.projectId} (${body.length} chars, age=${Math.round((Date.now() - cachedRecap.fetchedAt) / 1e3)}s)`);
+      } else {
+        dlog(
+          `resolving recap: projectId=${anchor.projectId} projectName=${anchor.projectName} sessionStartRecap=${anchor.sessionStartRecap} inboxNotify=${anchor.inboxNotify}`
+        );
+        const recap = await fetchRecapInbox(anchor);
+        body = recap.join("\n");
+        cachedRecap = { projectId: anchor.projectId || "", body, fetchedAt: Date.now() };
+        dlog(`buildRecapBody returned ${body.length} chars (projectId=${anchor.projectId})`);
+        if (body) {
+          dlog(`recap content (${body.length} chars):
+---
+${body}
+---`);
+        }
+      }
+      if (body) {
+        pushSystemPrompt(output, body);
+        dlog(`pushed recap to system prompt for sid=${sidShort}\u2026 (output.system is ${Array.isArray(output.system) ? "string[]" : typeof output.system}, body=${body.length} chars)`);
+      } else {
+        dlog(`recap empty for sid=${sidShort}\u2026 (no memories in window, no unread inbox)`);
+      }
+      if (sid) {
+        const sid8 = sidShort && sidShort !== "<none>" ? sidShort : sid.slice(0, 8);
+        pushSystemPrompt(
+          output,
+          `Your greprag session id: ${sid8}
+Reply-to: travis@greprag.com/${sid8}
+ALWAYS pass \`--from-session ${sid8}\` when you run \`greprag send\`, so recipients can reply to your session:
+  greprag send "msg" --to <handle>@greprag.com/<their-8hex> --from-session ${sid8}`
+        );
+        dlog(`pushed session-id awareness for sid=${sid8}`);
+      }
+    },
+    // Inline outbound-context crusher. Fires before every LLM call with the
+    // full outbound array in `output.messages`. Crushes its bulky parts in
+    // place (reversible via CCR, token-validate-or-revert, idempotent). The
+    // ENTIRE hook is wrapped so a crush failure can NEVER break the turn —
+    // on any error we simply leave the messages as opencode handed them.
+    // Contract: we mutate ONLY this request-scoped `output.messages` copy,
+    // never opencode's persisted session history. adr:
+    // adr/opencode-context-compressor.md
+    "experimental.chat.messages.transform": async (_input, output) => {
+      try {
+        if (!inlineCrushEnabled())
+          return;
+        const msgs = output && output.messages;
+        if (!Array.isArray(msgs)) {
+          dlog(`messages.transform: output.messages is ${typeof msgs}, not an array \u2014 skip`);
+          return;
+        }
+        if (!_crushShapeLogged) {
+          _crushShapeLogged = true;
+          try {
+            dlog(`messages.transform: live shape sample = ${JSON.stringify(msgs[0]).slice(0, 600)}`);
+          } catch {
+          }
+        }
+        const thresholdEnv = parseInt(process.env.GREPRAG_OPENCODE_CRUSH_MIN_BYTES || "", 10);
+        const stats = crushMessages(msgs, {
+          stash: makeCcrStash(),
+          thresholdBytes: Number.isFinite(thresholdEnv) && thresholdEnv > 0 ? thresholdEnv : void 0
+        });
+        if (stats.partsCrushed > 0 || stats.partsReverted > 0) {
+          dlog(
+            `messages.transform: crushed=${stats.partsCrushed} reverted=${stats.partsReverted} skipped=${stats.partsSkipped} bytes ${stats.bytesBefore}->${stats.bytesAfter}`
+          );
+        }
+      } catch (e) {
+        dlog(`messages.transform: swallowed error (turn unaffected): ${e.message}`);
+      }
+    }
+  };
+};
+function pushSystemPrompt(output, body) {
+  if (Array.isArray(output.system)) {
+    output.system.push(body);
+  } else if (typeof output.system === "string" && output.system.length > 0) {
+    output.system = `${output.system}
+
+${body}`;
+  } else {
+    output.system = body;
+  }
+}
+module.exports = {
+  id: "greprag-memory",
+  server: GrepRAGMemoryPlugin
+};