opencode-acp 1.12.10 → 1.13.2

package/dist/index.js

@@ -926,7 +926,11 @@ var VALID_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "strategies.purgeErrors",
   "strategies.purgeErrors.enabled",
   "strategies.purgeErrors.turns",
-  "strategies.purgeErrors.protectedTools"
+  "strategies.purgeErrors.protectedTools",
+  "qualityGate",
+  "qualityGate.enabled",
+  "qualityGate.algorithm",
+  "qualityGate.algorithms"
 ]);
 function getConfigKeyPaths(obj, prefix = "") {
   const keys = [];
@@ -1553,8 +1557,11 @@ var defaultConfig = {
   enabled: true,
   autoUpdate: true,
   debug: false,
-  pruneNotification: "detailed",
-  pruneNotificationType: "chat",
+  pruneNotification: "off",
+  // [FIX #20] Default to toast — chat-mode notifications inject an empty
+  // user message that freezes the session on providers that reject empty
+  // messages (zhipuai-lb code 1214). See lib/ui/notification.ts.
+  pruneNotificationType: "toast",
   commands: {
     enabled: true,
     protectedTools: [...DEFAULT_PROTECTED_TOOLS]
@@ -1586,7 +1593,7 @@ var defaultConfig = {
     protectedTools: [...COMPRESS_DEFAULT_PROTECTED_TOOLS],
     protectTags: false,
     protectUserMessages: false,
-    maxSummaryLengthHard: 1e4,
+    maxSummaryLengthHard: 2e4,
     minCompressRange: 5e3,
     minNudgeGrowthRatio: 0.45,
     minNudgeGrowthFloor: 5e3,
@@ -1618,6 +1625,18 @@ var defaultConfig = {
       highThreshold: "75%",
       forceThreshold: "90%"
     }
+  },
+  qualityGate: {
+    enabled: false,
+    algorithm: "rouge-recall-v1",
+    algorithms: {
+      "rouge-recall-v1": {
+        layer1MinChars: 200,
+        layer1MinRetentionPct: 1,
+        layer2MaxRougeF1: 0.05,
+        layer2MaxTop20Recall: 0.2
+      }
+    }
   }
 };
 var GLOBAL_CONFIG_DIR = process.env.XDG_CONFIG_HOME ? join(process.env.XDG_CONFIG_HOME, "opencode") : join(homedir(), ".config", "opencode");
@@ -1815,6 +1834,11 @@ function deepCloneConfig(config) {
     gc: {
       ...config.gc,
       batchCleanup: { ...config.gc.batchCleanup }
+    },
+    qualityGate: {
+      enabled: config.qualityGate.enabled,
+      algorithm: config.qualityGate.algorithm,
+      algorithms: { ...config.qualityGate.algorithms }
     }
   };
 }
@@ -1828,6 +1852,14 @@ function mergeGC(base, override) {
     batchCleanup: { ...base.batchCleanup, ...override.batchCleanup ?? {} }
   };
 }
+function mergeQualityGate(base, override) {
+  if (!override) return base;
+  return {
+    enabled: override.enabled ?? base.enabled,
+    algorithm: override.algorithm ?? base.algorithm,
+    algorithms: { ...base.algorithms, ...override.algorithms ?? {} }
+  };
+}
 function mergeLayer(config, data) {
   return {
     enabled: data.enabled ?? config.enabled,
@@ -1847,7 +1879,8 @@ function mergeLayer(config, data) {
     ],
     compress: mergeCompress(config.compress, data.compress),
     gc: mergeGC(config.gc, data.gc),
-    strategies: mergeStrategies(config.strategies, data.strategies)
+    strategies: mergeStrategies(config.strategies, data.strategies),
+    qualityGate: mergeQualityGate(config.qualityGate, data.qualityGate)
   };
 }
 function scheduleParseWarning(ctx, title, message) {
@@ -3287,6 +3320,8 @@ var SoftIssue = class extends Error {
     this.kind = kind;
     this.messageId = messageId;
   }
+  kind;
+  messageId;
 };
 function validateArgs(args) {
   if (typeof args.topic !== "string" || args.topic.trim().length === 0) {
@@ -5043,10 +5078,25 @@ function formatContextTransition(tokensBefore, tokensAfter) {
   return `Context ${beforeStr} \u2192 ${afterStr}`;
 }
 async function sendCompressNotification(client, logger, config, state, sessionId, entries, batchTopic, sessionMessageIds, params, contextTokensBefore) {
-  if (config.pruneNotification === "off") {
+  if (entries.length === 0) {
     return false;
   }
-  if (entries.length === 0) {
+  const logBlockIds = entries.map((e) => e.blockId);
+  const logTopics = entries.map((e) => state.prune.messages.blocksById.get(e.blockId)?.topic ?? "?");
+  const logCompressedTokens = entries.reduce((sum, e) => {
+    const block = state.prune.messages.blocksById.get(e.blockId);
+    return sum + (block?.compressedTokens ?? 0);
+  }, 0);
+  const logSummaryTokens = entries.reduce((sum, e) => sum + e.summaryTokens, 0);
+  logger.info("Compression completed", {
+    sessionId,
+    blockIds: logBlockIds,
+    topics: logTopics,
+    compressedTokens: logCompressedTokens,
+    summaryTokens: logSummaryTokens,
+    contextTokensBefore
+  });
+  if (config.pruneNotification === "off") {
     return false;
   }
   let message;
@@ -5145,20 +5195,22 @@ ${progressBar}`;
 \u2192 Compression (~${summaryTokensStr}): ${displaySummary}`;
     }
   }
-  if (config.pruneNotificationType === "toast") {
-    let toastMessage = message;
-    toastMessage = config.pruneNotification === "minimal" ? toastMessage : truncateToastBody(toastMessage);
-    await client.tui.showToast({
-      body: {
-        title: "ACP: Compress Notification",
-        message: toastMessage,
-        variant: "info",
-        duration: 5e3
-      }
-    });
-    return true;
+  if (config.pruneNotificationType === "chat") {
+    logger.warn(
+      "compress.pruneNotificationType 'chat' is no longer supported (it injects an empty user message that causes provider 400 errors); falling back to toast. Set pruneNotificationType to 'toast' (or pruneNotification to 'off') to silence this warning.",
+      { sessionId }
+    );
   }
-  await sendIgnoredMessage(client, sessionId, message, params, logger);
+  let toastMessage = message;
+  toastMessage = config.pruneNotification === "minimal" ? toastMessage : truncateToastBody(toastMessage);
+  await client.tui.showToast({
+    body: {
+      title: "ACP: Compress Notification",
+      message: toastMessage,
+      variant: "info",
+      duration: 5e3
+    }
+  });
   return true;
 }
 async function sendIgnoredMessage(client, sessionID, text, params, logger) {
@@ -5192,6 +5244,737 @@ async function sendIgnoredMessage(client, sessionID, text, params, logger) {
   }
 }
 
+// lib/compress/quality-gate/registry.ts
+var registry = /* @__PURE__ */ new Map();
+function registerQualityGate(gate) {
+  if (registry.has(gate.name)) {
+    const existing = registry.get(gate.name);
+    if (existing !== gate && existing.version !== gate.version) {
+      throw new Error(
+        `Quality gate "${gate.name}" already registered with version ${existing.version} (attempted ${gate.version})`
+      );
+    }
+  }
+  registry.set(gate.name, gate);
+}
+function getQualityGate(name) {
+  return registry.get(name);
+}
+
+// node_modules/context-compress-algorithms/dist/chunk-E6LYOQFY.js
+var ENGLISH_WORD_RE = /[a-z][a-z0-9_]+/g;
+var CJK_RE = /[\u4e00-\u9fff]/g;
+var FILE_PATH_RE = /(?:[a-zA-Z0-9_-]+\/){1,}[a-zA-Z0-9_-]+\.[a-zA-Z]{1,5}/g;
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "that",
+  "this",
+  "these",
+  "those",
+  "there",
+  "their",
+  "them",
+  "then",
+  "than",
+  "thats",
+  "with",
+  "will",
+  "would",
+  "could",
+  "should",
+  "from",
+  "have",
+  "has",
+  "had",
+  "having",
+  "were",
+  "what",
+  "which",
+  "when",
+  "where",
+  "while",
+  "your",
+  "yours",
+  "theirs",
+  "ours",
+  "mine",
+  "hers",
+  "whose",
+  "they",
+  "them",
+  "those",
+  "these",
+  "this",
+  "that",
+  "such",
+  "some",
+  "same",
+  "other",
+  "another",
+  "each",
+  "into",
+  "onto",
+  "upon",
+  "over",
+  "under",
+  "between",
+  "through",
+  "during",
+  "before",
+  "after",
+  "above",
+  "below",
+  "among",
+  "across",
+  "along",
+  "around",
+  "about",
+  "because",
+  "since",
+  "unless",
+  "although",
+  "though",
+  "whereas",
+  "whether",
+  "either",
+  "neither",
+  "both",
+  "also",
+  "only",
+  "just",
+  "very",
+  "more",
+  "most",
+  "much",
+  "many",
+  "less",
+  "least",
+  "several",
+  "enough",
+  "make",
+  "made",
+  "makes",
+  "making",
+  "take",
+  "took",
+  "taken",
+  "takes",
+  "taking",
+  "get",
+  "got",
+  "getting",
+  "gets",
+  "give",
+  "gave",
+  "given",
+  "gives",
+  "giving",
+  "come",
+  "came",
+  "comes",
+  "coming",
+  "were",
+  "been",
+  "being",
+  "have",
+  "make",
+  "want",
+  "need",
+  "using",
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "void",
+  "return",
+  "returns",
+  "returning",
+  "function",
+  "const",
+  "class",
+  "interface",
+  "type",
+  "typeof",
+  "instanceof",
+  "import",
+  "export",
+  "require",
+  "module",
+  "default",
+  "async",
+  "await",
+  "static",
+  "public",
+  "private",
+  "protected",
+  "readonly",
+  "partial",
+  "abstract",
+  "virtual",
+  "override",
+  "final",
+  "super",
+  "value",
+  "values",
+  "param",
+  "params",
+  "name",
+  "names",
+  "test",
+  "tests",
+  "testing",
+  "tested",
+  "expect",
+  "expected",
+  "actual",
+  "actuals",
+  "result",
+  "results",
+  "output",
+  "outputs",
+  "input",
+  "inputs",
+  "data",
+  "record",
+  "records",
+  "item",
+  "items",
+  "like",
+  "want",
+  "need",
+  "used",
+  "uses",
+  "said",
+  "say",
+  "says",
+  "went",
+  "goes",
+  "here",
+  "there",
+  "where",
+  "when",
+  "what",
+  "who",
+  "how",
+  "why",
+  "which",
+  "whose",
+  "whom",
+  "yourself",
+  "myself",
+  "itself",
+  "themselves",
+  "ourselves",
+  "himself",
+  "herself",
+  "yeah",
+  "okay",
+  "ok",
+  "yes",
+  "no",
+  "not",
+  "nor",
+  "or",
+  "and",
+  "but",
+  "if",
+  "then",
+  "else",
+  "elif",
+  "when",
+  "while",
+  "for",
+  "to",
+  "of",
+  "in",
+  "on",
+  "at",
+  "by",
+  "with",
+  "from",
+  "into",
+  "onto",
+  "\u7684",
+  "\u662F",
+  "\u4E86",
+  "\u5728",
+  "\u548C",
+  "\u4E0E",
+  "\u6216",
+  "\u4E5F",
+  "\u90FD",
+  "\u5C31",
+  "\u8FD8",
+  "\u53C8",
+  "\u624D",
+  "\u518D",
+  "\u5DF2",
+  "\u5C06",
+  "\u4F1A",
+  "\u80FD",
+  "\u53EF",
+  "\u53EF\u4EE5",
+  "\u8981",
+  "\u60F3",
+  "\u9700\u8981",
+  "\u5E94\u8BE5",
+  "\u5FC5\u987B",
+  "\u6CA1",
+  "\u6CA1\u6709",
+  "\u4E0D",
+  "\u975E",
+  "\u65E0",
+  "\u83AB",
+  "\u6211",
+  "\u4F60",
+  "\u4ED6",
+  "\u5979",
+  "\u5B83",
+  "\u6211\u4EEC",
+  "\u4F60\u4EEC",
+  "\u4ED6\u4EEC",
+  "\u5979\u4EEC",
+  "\u5B83\u4EEC",
+  "\u54B1",
+  "\u54B1\u4EEC",
+  "\u81EA\u5DF1",
+  "\u8FD9",
+  "\u90A3",
+  "\u8FD9\u4E2A",
+  "\u90A3\u4E2A",
+  "\u8FD9\u4E9B",
+  "\u90A3\u4E9B",
+  "\u8FD9\u6837",
+  "\u90A3\u6837",
+  "\u8FD9\u91CC",
+  "\u90A3\u91CC",
+  "\u8FD9\u4E48",
+  "\u90A3\u4E48",
+  "\u4EC0\u4E48",
+  "\u600E\u4E48",
+  "\u4E3A\u4EC0\u4E48",
+  "\u54EA",
+  "\u54EA\u4E2A",
+  "\u54EA\u4E9B",
+  "\u54EA\u91CC",
+  "\u600E\u6837",
+  "\u591A\u5C11",
+  "\u51E0",
+  "\u591A",
+  "\u5C11",
+  "\u4E8E",
+  "\u4ECE",
+  "\u5411",
+  "\u5F80",
+  "\u5230",
+  "\u81F3",
+  "\u4E3A",
+  "\u5BF9\u4E8E",
+  "\u5173\u4E8E",
+  "\u81F3\u4E8E",
+  "\u7531\u4E8E",
+  "\u56E0\u4E3A",
+  "\u6240\u4EE5",
+  "\u4F46\u662F",
+  "\u4F46",
+  "\u4E0D\u8FC7",
+  "\u7136\u800C",
+  "\u53EF\u662F",
+  "\u53EA\u662F",
+  "\u53EA\u6709",
+  "\u9664\u4E86",
+  "\u9664\u975E",
+  "\u65E0\u8BBA",
+  "\u4E0D\u7BA1",
+  "\u5C3D\u7BA1",
+  "\u867D\u7136",
+  "\u867D\u8BF4",
+  "\u5373\u4F7F",
+  "\u5373\u4FBF",
+  "\u54EA\u6015",
+  "\u4E00\u65E6",
+  "\u5982\u679C",
+  "\u8981\u662F",
+  "\u5047\u5982",
+  "\u5047\u4F7F",
+  "\u5018\u82E5",
+  "\u4E4B",
+  "\u5176",
+  "\u5176\u4E2D",
+  "\u5176\u4ED6",
+  "\u5176\u5B83",
+  "\u5176\u4F59",
+  "\u53E6\u4E00",
+  "\u53E6\u5916",
+  "\u6B64\u5916",
+  "\u5E76\u4E14",
+  "\u5E76",
+  "\u4E14",
+  "\u7740",
+  "\u8FC7",
+  "\u5427",
+  "\u5417",
+  "\u5462",
+  "\u554A",
+  "\u54E6",
+  "\u55EF",
+  "\u5440",
+  "\u54C7",
+  "\u54C8",
+  "\u561B",
+  "\u54AF",
+  "\u54DF"
+]);
+var ZH_STOPWORD_BIGRAMS = /* @__PURE__ */ new Set([
+  "\u6211\u4EEC",
+  "\u4F60\u4EEC",
+  "\u4ED6\u4EEC",
+  "\u5979\u4EEC",
+  "\u5B83\u4EEC",
+  "\u54B1\u4EEC",
+  "\u8FD9\u4E2A",
+  "\u90A3\u4E2A",
+  "\u8FD9\u4E9B",
+  "\u90A3\u4E9B",
+  "\u4EC0\u4E48",
+  "\u600E\u4E48",
+  "\u4E3A\u4EC0\u4E48",
+  "\u5982\u4F55",
+  "\u53EF\u4EE5",
+  "\u5E94\u8BE5",
+  "\u4F46\u662F",
+  "\u56E0\u4E3A",
+  "\u6240\u4EE5",
+  "\u5982\u679C",
+  "\u867D\u7136",
+  "\u5373\u4F7F",
+  "\u5C3D\u7BA1",
+  "\u4E3A\u4E86",
+  "\u7531\u4E8E",
+  "\u4E0D\u4F46",
+  "\u800C\u4E14",
+  "\u5E76\u4E14",
+  "\u6216\u8005",
+  "\u8FD8\u662F",
+  "\u4EE5\u53CA",
+  "\u4EE5\u4E3A",
+  "\u4E8E\u662F",
+  "\u7136\u800C",
+  "\u5176\u5B9E",
+  "\u5C31\u662F",
+  "\u53EA\u662F",
+  "\u53EA\u6709",
+  "\u9664\u4E86",
+  "\u9664\u975E",
+  "\u8FD9\u6837",
+  "\u90A3\u6837",
+  "\u8FD9\u4E48",
+  "\u90A3\u4E48",
+  "\u8FD9\u4E9B",
+  "\u90A3\u4E9B",
+  "\u8FD9\u91CC",
+  "\u90A3\u91CC",
+  "\u73B0\u5728",
+  "\u4EE5\u540E",
+  "\u4EE5\u524D",
+  "\u4E4B\u540E",
+  "\u4E4B\u524D",
+  "\u7136\u540E",
+  "\u5F53\u7136",
+  "\u53EF\u80FD",
+  "\u4E00\u4E9B",
+  "\u8BB8\u591A",
+  "\u975E\u5E38",
+  "\u5341\u5206",
+  "\u6BD4\u8F83",
+  "\u66F4\u52A0",
+  "\u6700\u4E3A",
+  "\u4E5F\u662F",
+  "\u8FD8\u662F",
+  "\u5C31\u662F",
+  "\u4E0D\u8FC7",
+  "\u4E0D\u8981",
+  "\u4E0D\u80FD",
+  "\u4E0D\u4F1A",
+  "\u6CA1\u6709",
+  "\u4E0D\u662F",
+  "\u4E0D\u7528",
+  "\u4E0D\u5FC5",
+  "\u4E00\u76F4",
+  "\u5DF2\u7ECF",
+  "\u6B63\u5728",
+  "\u9A6C\u4E0A"
+]);
+var DEFAULT_OPTS = {
+  english: true,
+  zhUnigrams: true,
+  zhBigrams: true
+};
+function tokenize(text, opts = {}) {
+  if (!text || typeof text !== "string") return [];
+  const options = { ...DEFAULT_OPTS, ...opts };
+  const tokens = [];
+  const lower = text.toLowerCase();
+  if (options.english) {
+    const matches = lower.match(ENGLISH_WORD_RE);
+    if (matches) {
+      for (const w of matches) {
+        if (w.length >= 4 && !STOPWORDS.has(w) && !/^\d+$/.test(w)) {
+          tokens.push(w);
+        }
+      }
+    }
+  }
+  if (options.zhUnigrams || options.zhBigrams) {
+    const cjkChars = text.match(CJK_RE);
+    if (cjkChars && cjkChars.length > 0) {
+      const cjkStr = cjkChars.join("");
+      if (options.zhUnigrams) {
+        for (const c of cjkStr) {
+          if (!STOPWORDS.has(c)) tokens.push(c);
+        }
+      }
+      if (options.zhBigrams) {
+        for (let i = 0; i < cjkStr.length - 1; i++) {
+          const bg = cjkStr.slice(i, i + 2);
+          if (!ZH_STOPWORD_BIGRAMS.has(bg) && !STOPWORDS.has(bg[0]) && !STOPWORDS.has(bg[1])) {
+            tokens.push(bg);
+          }
+        }
+      }
+    }
+  }
+  return tokens;
+}
+function termFrequency(tokens) {
+  const tf = /* @__PURE__ */ new Map();
+  for (const t of tokens) {
+    tf.set(t, (tf.get(t) ?? 0) + 1);
+  }
+  return tf;
+}
+function topKByTf(tokens, k) {
+  if (tokens.length === 0 || k <= 0) return [];
+  const tf = termFrequency(tokens);
+  const sorted = [...tf.entries()].sort((a, b) => {
+    if (b[1] !== a[1]) return b[1] - a[1];
+    return a[0].localeCompare(b[0]);
+  });
+  return sorted.slice(0, k).map((e) => e[0]);
+}
+function extractFilePaths(text) {
+  if (!text) return /* @__PURE__ */ new Set();
+  const paths = /* @__PURE__ */ new Set();
+  const matches = text.match(FILE_PATH_RE);
+  if (matches) {
+    for (const m of matches) paths.add(m);
+  }
+  return paths;
+}
+function rouge1Recall(summaryTokens, originalTokens) {
+  if (originalTokens.length === 0) return 0;
+  const summarySet = new Set(summaryTokens);
+  const originalSet = new Set(originalTokens);
+  let hit = 0;
+  for (const t of originalSet) if (summarySet.has(t)) hit++;
+  return hit / originalSet.size;
+}
+function rouge1Precision(summaryTokens, originalTokens) {
+  if (summaryTokens.length === 0) return 0;
+  const summarySet = new Set(summaryTokens);
+  const originalSet = new Set(originalTokens);
+  let hit = 0;
+  for (const t of summarySet) if (originalSet.has(t)) hit++;
+  return hit / summarySet.size;
+}
+function rouge1F1(summaryTokens, originalTokens) {
+  const r = rouge1Recall(summaryTokens, originalTokens);
+  const p = rouge1Precision(summaryTokens, originalTokens);
+  if (r + p === 0) return 0;
+  return 2 * r * p / (r + p);
+}
+function topKRecall(summaryTokens, originalTokens, k) {
+  if (originalTokens.length === 0 || k <= 0) return 0;
+  const top = topKByTf(originalTokens, k);
+  if (top.length === 0) return 0;
+  const summarySet = new Set(summaryTokens);
+  let hit = 0;
+  for (const t of top) if (summarySet.has(t)) hit++;
+  return hit / top.length;
+}
+var DEFAULT_ROUGE_RECALL_V1_CONFIG = {
+  layer1MinChars: 200,
+  layer1MinRetentionPct: 1,
+  layer2MaxRougeF1: 0.05,
+  layer2MaxTop20Recall: 0.2
+};
+var TOP_K = 20;
+var ORIGINAL_TOKEN_ESTIMATE_CHARS_PER_TOKEN = 4;
+function resolveConfig(input) {
+  if (!input || typeof input !== "object") return DEFAULT_ROUGE_RECALL_V1_CONFIG;
+  const c = input;
+  return {
+    layer1MinChars: typeof c.layer1MinChars === "number" && c.layer1MinChars > 0 ? c.layer1MinChars : DEFAULT_ROUGE_RECALL_V1_CONFIG.layer1MinChars,
+    layer1MinRetentionPct: typeof c.layer1MinRetentionPct === "number" && c.layer1MinRetentionPct >= 0 ? c.layer1MinRetentionPct : DEFAULT_ROUGE_RECALL_V1_CONFIG.layer1MinRetentionPct,
+    layer2MaxRougeF1: typeof c.layer2MaxRougeF1 === "number" && c.layer2MaxRougeF1 >= 0 ? c.layer2MaxRougeF1 : DEFAULT_ROUGE_RECALL_V1_CONFIG.layer2MaxRougeF1,
+    layer2MaxTop20Recall: typeof c.layer2MaxTop20Recall === "number" && c.layer2MaxTop20Recall >= 0 ? c.layer2MaxTop20Recall : DEFAULT_ROUGE_RECALL_V1_CONFIG.layer2MaxTop20Recall
+  };
+}
+var rougeRecallV1 = {
+  name: "rouge-recall-v1",
+  version: "1.0.0",
+  description: "Two-layer gate: length floor (L1) then ROUGE-1 F1 AND top-20 keyword recall (L2)",
+  evaluate(ctx, rawConfig) {
+    const cfg = resolveConfig(rawConfig);
+    const summaryLen = ctx.summary.length;
+    const originalChars = ctx.originalText.length;
+    const retentionPct = ctx.block.compressedTokens > 0 ? summaryLen / (ctx.block.compressedTokens * ORIGINAL_TOKEN_ESTIMATE_CHARS_PER_TOKEN) * 100 : 0;
+    const baseMetrics = [
+      { name: "summaryLen", value: summaryLen },
+      { name: "retentionPct", value: +retentionPct.toFixed(2), format: "percent" },
+      { name: "originalTokens", value: ctx.block.compressedTokens }
+    ];
+    if (summaryLen < cfg.layer1MinChars || originalChars > 0 && retentionPct < cfg.layer1MinRetentionPct) {
+      return {
+        passed: false,
+        layer: "L1-length",
+        reason: `Summary too short: ${summaryLen} chars, ${retentionPct.toFixed(2)}% retention (threshold: ${cfg.layer1MinChars} chars OR ${cfg.layer1MinRetentionPct}% retention)`,
+        metrics: baseMetrics
+      };
+    }
+    if (ctx.originalText.length === 0) {
+      return { passed: true, metrics: baseMetrics };
+    }
+    const summaryTokens = tokenize(ctx.summary);
+    const originalTokens = tokenize(ctx.originalText);
+    const rougeF1 = rouge1F1(summaryTokens, originalTokens);
+    const rougeRecall = rouge1Recall(summaryTokens, originalTokens);
+    const top20 = topKRecall(summaryTokens, originalTokens, TOP_K);
+    const summaryPaths = extractFilePaths(ctx.summary);
+    const originalPaths = extractFilePaths(ctx.originalText);
+    const pathCoverage = originalPaths.size >= 5 ? [...summaryPaths].filter((p) => originalPaths.has(p)).length / originalPaths.size : -1;
+    const contentMetrics = [
+      ...baseMetrics,
+      { name: "rougeF1", value: +rougeF1.toFixed(4), format: "ratio" },
+      { name: "rougeRecall", value: +rougeRecall.toFixed(4), format: "ratio" },
+      { name: "top20Recall", value: +top20.toFixed(4), format: "ratio" },
+      { name: "nOriginalPaths", value: originalPaths.size },
+      { name: "nSummaryPaths", value: summaryPaths.size }
+    ];
+    if (pathCoverage >= 0) {
+      contentMetrics.push({ name: "pathCoverage", value: +pathCoverage.toFixed(3), format: "ratio" });
+    }
+    if (rougeF1 < cfg.layer2MaxRougeF1 && top20 < cfg.layer2MaxTop20Recall) {
+      return {
+        passed: false,
+        layer: "L2-recall",
+        reason: `Content coverage too low: rougeF1=${rougeF1.toFixed(3)}, top20Recall=${top20.toFixed(3)} (threshold: rougeF1<${cfg.layer2MaxRougeF1} AND top20<${cfg.layer2MaxTop20Recall})`,
+        metrics: contentMetrics
+      };
+    }
+    return { passed: true, metrics: contentMetrics };
+  }
+};
+
+// lib/compress/quality-gate/algorithms/index.ts
+function ensureBuiltinGatesRegistered() {
+  registerQualityGate(rougeRecallV1);
+}
+
+// lib/compress/quality-gate/evaluate.ts
+var CHARS_PER_TOKEN_ESTIMATE = 4;
+var TOOL_OUTPUT_MAX_CHARS = 1500;
+var TOOL_INPUT_MAX_CHARS = 500;
+function extractMessageText(parts) {
+  if (!parts || !Array.isArray(parts)) return "";
+  let text = "";
+  for (const part of parts) {
+    if (!part || typeof part !== "object") continue;
+    if (part.type === "text") {
+      text += part.text + "\n";
+    } else if (part.type === "tool") {
+      const state = part.state;
+      const input = state.status === "completed" && typeof state.input === "object" ? JSON.stringify(state.input).slice(0, TOOL_INPUT_MAX_CHARS) : "";
+      const output = state.status === "completed" && typeof state.output === "string" ? state.output.slice(0, TOOL_OUTPUT_MAX_CHARS) : state.status === "completed" && typeof state.output === "object" ? JSON.stringify(state.output).slice(0, TOOL_OUTPUT_MAX_CHARS) : "";
+      text += `[tool:${part.tool}] ${input}
+${output}
+`;
+    }
+  }
+  return text;
+}
+function buildContext(block, rawMessages) {
+  const directIds = block.directMessageIds;
+  if (!directIds || directIds.length === 0) return null;
+  const idToMsg = /* @__PURE__ */ new Map();
+  for (const m of rawMessages) {
+    const id = m?.info?.id;
+    if (typeof id === "string") idToMsg.set(id, m);
+  }
+  const chunks = [];
+  for (const id of directIds) {
+    const m = idToMsg.get(id);
+    if (!m) continue;
+    chunks.push(extractMessageText(m.parts));
+  }
+  if (chunks.length === 0) return null;
+  const originalText = chunks.join("\n");
+  return {
+    block,
+    summary: block.summary ?? "",
+    originalChunks: chunks,
+    originalText,
+    originalTokens: Math.ceil(originalText.length / CHARS_PER_TOKEN_ESTIMATE)
+  };
+}
+function evaluateBlockQuality(state, rawMessages, entry, config, logger) {
+  const qg = config.qualityGate;
+  if (!qg || qg.enabled !== true) return null;
+  ensureBuiltinGatesRegistered();
+  const algoName = qg.algorithm;
+  if (!algoName) {
+    logger.warn("Quality gate enabled but no algorithm specified", {});
+    return null;
+  }
+  const gate = getQualityGate(algoName);
+  if (!gate) {
+    logger.warn("Quality gate algorithm not found in registry", { algorithm: algoName });
+    return null;
+  }
+  const block = state.prune.messages.blocksById.get(entry.blockId);
+  if (!block) {
+    logger.warn("Quality gate: block not found", { blockId: entry.blockId });
+    return null;
+  }
+  const ctx = buildContext(block, rawMessages);
+  if (!ctx) return null;
+  const algoConfig = (qg.algorithms && qg.algorithms[algoName]) ?? {};
+  try {
+    return gate.evaluate(ctx, algoConfig);
+  } catch (err) {
+    logger.warn("Quality gate threw \u2014 treating as pass", {
+      gate: gate.name,
+      blockId: entry.blockId,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return { passed: true, metrics: [] };
+  }
+}
+function evaluateBatchQuality(state, rawMessages, entries, config, logger) {
+  const failures = [];
+  for (const entry of entries) {
+    const result = evaluateBlockQuality(state, rawMessages, entry, config, logger);
+    if (result && !result.passed) {
+      failures.push({ blockId: entry.blockId, result });
+    }
+  }
+  return {
+    total: entries.length,
+    passed: entries.length - failures.length,
+    failures
+  };
+}
+
 // lib/compress/pipeline.ts
 function snapshotCompressionState(state) {
   return {
@@ -5240,6 +6023,27 @@ async function finalizeSession(ctx, toolCtx, rawMessages, entries, batchTopic) {
   ctx.state.manualMode = ctx.state.manualMode ? "active" : false;
   applyPendingCompressionDurations(ctx.state);
   await saveSessionState(ctx.state, ctx.logger);
+  if (entries.length > 0) {
+    const qualityReport = evaluateBatchQuality(
+      ctx.state,
+      rawMessages,
+      entries,
+      ctx.config,
+      ctx.logger
+    );
+    for (const failure of qualityReport.failures) {
+      const metrics = Object.fromEntries(
+        failure.result.metrics.map((m) => [m.name, m.value])
+      );
+      ctx.logger.warn("Compression quality gate FAILED", {
+        blockId: failure.blockId,
+        algorithm: ctx.config.qualityGate.algorithm,
+        layer: failure.result.layer,
+        reason: failure.result.reason,
+        ...metrics
+      });
+    }
+  }
   const params = getCurrentParams(ctx.state, rawMessages, ctx.logger);
   const sessionMessageIds = rawMessages.filter((msg) => !isIgnoredUserMessage(msg)).map((msg) => msg.info.id);
   const contextTokensBefore = getCurrentTokenUsage(ctx.state, rawMessages);
@@ -5880,15 +6684,29 @@ var filterCompressedRanges = (state, messages) => {
   if (state.prune.messages.byMessageId.size === 0) {
     return;
   }
+  const survive = messages.map((msg) => {
+    const pruneEntry = state.prune.messages.byMessageId.get(msg.info.id);
+    if (!pruneEntry || pruneEntry.activeBlockIds.length === 0) {
+      return true;
+    }
+    return false;
+  });
+  const anyUserSurvives = messages.some(
+    (msg, i) => survive[i] && msg.info.role === "user"
+  );
+  if (!anyUserSurvives) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+      if (messages[i].info.role === "user" && !survive[i]) {
+        survive[i] = true;
+        break;
+      }
+    }
+  }
   const result = [];
   for (let i = 0; i < messages.length; i++) {
-    const msg = messages[i];
-    const msgId = msg.info.id;
-    const pruneEntry = state.prune.messages.byMessageId.get(msgId);
-    if (pruneEntry && pruneEntry.activeBlockIds.length > 0) {
-      continue;
+    if (survive[i]) {
+      result.push(messages[i]);
     }
-    result.push(msg);
   }
   messages.length = 0;
   messages.push(...result);
@@ -6220,7 +7038,7 @@ var dropEmptyMessages = (messages) => {
   for (let i = messages.length - 1; i >= 0; i--) {
     const parts = Array.isArray(messages[i].parts) ? messages[i].parts : [];
     const isEmpty = parts.every(
-      (part) => part.type === "text" && (typeof part.text !== "string" || part.text.trim().length === 0)
+      (part) => part.type === "text" && (typeof part.text !== "string" || part.text.trim().length === 0 || part.ignored === true)
     );
     if (isEmpty) {
       messages.splice(i, 1);
@@ -6388,6 +7206,62 @@ function listPriorityRefsBeforeIndex(messages, priorities, anchorIndex, priority
   return refs;
 }
 
+// node_modules/context-compress-algorithms/dist/chunk-UX2UW5FY.js
+var NUDGE_GROWTH_FLOOR = 6e3;
+var NUDGE_GROWTH_CAP = 5e4;
+var NUDGE_GROWTH_RATIO = 0.05;
+function computeShouldNudge(params) {
+  const { currentTokens, overMinLimit, overMaxLimit } = params;
+  if (currentTokens === void 0) {
+    return { shouldNudge: false, tipsVariant: null };
+  }
+  if (params.lastNudgeTokens === void 0) {
+    return { shouldNudge: false, tipsVariant: null };
+  }
+  const growthSinceLastNudge = currentTokens - params.lastNudgeTokens;
+  const shouldNudge = growthSinceLastNudge >= params.nudgeGrowthTokens || overMaxLimit;
+  if (!shouldNudge) {
+    return { shouldNudge: false, tipsVariant: null };
+  }
+  const tipsVariant = overMaxLimit ? "maxLimit" : overMinLimit ? "minLimit" : "normal";
+  return { shouldNudge: true, tipsVariant };
+}
+function resolveAdaptiveNudgeGrowth(modelContextLimit) {
+  if (!modelContextLimit || modelContextLimit <= 0) return NUDGE_GROWTH_FLOOR;
+  return Math.min(
+    NUDGE_GROWTH_CAP,
+    Math.max(NUDGE_GROWTH_FLOOR, Math.round(modelContextLimit * NUDGE_GROWTH_RATIO))
+  );
+}
+var defaultTriggerPolicy = {
+  name: "context-compress-algorithms-trigger",
+  version: "1.0.0",
+  description: "Growth-only cadence: nudge when context growth since last nudge exceeds adaptive threshold, or when over max limit.",
+  computeShouldNudge,
+  resolveAdaptiveNudgeGrowth
+};
+
+// lib/messages/inject/policy/registry.ts
+var registry2 = /* @__PURE__ */ new Map();
+var defaultPolicy = null;
+function registerTriggerPolicy2(policy) {
+  if (!policy.name) {
+    throw new Error("TriggerPolicy must have a name");
+  }
+  registry2.set(policy.name, policy);
+  if (!defaultPolicy) {
+    defaultPolicy = policy;
+  }
+}
+function getDefaultTriggerPolicy() {
+  return defaultPolicy;
+}
+
+// lib/messages/inject/policy/index.ts
+function ensureBuiltinTriggerPolicyRegistered() {
+  registerTriggerPolicy2(defaultTriggerPolicy);
+}
+
 // lib/messages/inject/utils.ts
 var MESSAGE_MODE_NUDGE_PRIORITY = "high";
 function getNudgeFrequency(config) {
@@ -6500,31 +7374,20 @@ function isContextOverLimits(config, state, providerId, modelId, messages) {
     modelContextLimit: state.modelContextLimit
   };
 }
-function computeShouldNudge(params) {
-  const { currentTokens, overMinLimit, overMaxLimit } = params;
-  if (currentTokens === void 0) {
-    return { shouldNudge: false, tipsVariant: null };
-  }
-  if (params.lastNudgeTokens === void 0) {
+ensureBuiltinTriggerPolicyRegistered();
+function computeShouldNudge2(params) {
+  const policy = getDefaultTriggerPolicy();
+  if (!policy) {
     return { shouldNudge: false, tipsVariant: null };
   }
-  const growthSinceLastNudge = currentTokens - params.lastNudgeTokens;
-  const shouldNudge = growthSinceLastNudge >= params.nudgeGrowthTokens || overMaxLimit;
-  if (!shouldNudge) {
-    return { shouldNudge: false, tipsVariant: null };
-  }
-  const tipsVariant = overMaxLimit ? "maxLimit" : overMinLimit ? "minLimit" : "normal";
-  return { shouldNudge: true, tipsVariant };
+  return policy.computeShouldNudge(params);
 }
-var NUDGE_GROWTH_FLOOR = 6e3;
-var NUDGE_GROWTH_CAP = 5e4;
-var NUDGE_GROWTH_RATIO = 0.05;
-function resolveAdaptiveNudgeGrowth(modelContextLimit) {
-  if (!modelContextLimit || modelContextLimit <= 0) return NUDGE_GROWTH_FLOOR;
-  return Math.min(
-    NUDGE_GROWTH_CAP,
-    Math.max(NUDGE_GROWTH_FLOOR, Math.round(modelContextLimit * NUDGE_GROWTH_RATIO))
-  );
+function resolveAdaptiveNudgeGrowth2(modelContextLimit) {
+  const policy = getDefaultTriggerPolicy();
+  if (!policy) {
+    return 6e3;
+  }
+  return policy.resolveAdaptiveNudgeGrowth(modelContextLimit);
 }
 function addAnchor(anchorMessageIds, anchorMessageId, anchorMessageIndex, messages, interval) {
   if (anchorMessageIndex < 0) {
@@ -7100,7 +7963,7 @@ ${lines2.join("\n")}`;
 ${lines.join("\n")}`;
 }
 
-// lib/prompts/compression-rules.ts
+// node_modules/context-compress-algorithms/dist/chunk-ZRHPFN6B.js
 var COMPRESS_PHILOSOPHY = `Compression Philosophy:
 - All compression serves the primary task, but be frugal.
 - Context capacity is precious. Save context by compressing consumed outputs, not by avoiding tools.
@@ -7276,7 +8139,7 @@ var injectCompressNudges = (state, config, logger, messages, prompts, compressio
     }
   }
   const suffixMessage = createSuffixMessage(messages);
-  const nudgeGrowthTokens = config.compress?.nudgeGrowthTokens ?? resolveAdaptiveNudgeGrowth(modelContextLimit);
+  const nudgeGrowthTokens = config.compress?.nudgeGrowthTokens ?? resolveAdaptiveNudgeGrowth2(modelContextLimit);
   const growthFloor = Math.max(
     config.compress?.minNudgeGrowthFloor ?? 5e3,
     (config.compress?.minNudgeGrowthRatio ?? 0.45) * nudgeGrowthTokens
@@ -7291,7 +8154,7 @@ var injectCompressNudges = (state, config, logger, messages, prompts, compressio
   const hasPendingNudge = state.nudges.lastNudgeShownTokens !== void 0;
   const effectiveThreshold = hasPendingNudge ? Math.floor(nudgeGrowthTokens / 2) : nudgeGrowthTokens;
   const growthReference = state.nudges.lastNudgeShownTokens ?? state.nudges.lastPerMessageNudgeTokens;
-  const decision = computeShouldNudge({
+  const decision = computeShouldNudge2({
     currentTokens,
     modelContextLimit,
     overMinLimit,
@@ -8025,7 +8888,7 @@ function buildSchema3() {
 function extractMessageId(m) {
   return m.id ?? m.messageId ?? "";
 }
-function extractMessageText(m) {
+function extractMessageText2(m) {
   const msg = m;
   const role = msg.role || msg.type || "unknown";
   const content = typeof msg.content === "string" ? msg.content : typeof msg.text === "string" ? msg.text : JSON.stringify(msg.content || msg.text || "");
@@ -8078,7 +8941,7 @@ function createDecompressTool(ctx) {
           }
         }
         const blockMessages = rawMessages.filter((m) => msgIdSet.has(extractMessageId(m)));
-        const lines2 = blockMessages.map(extractMessageText);
+        const lines2 = blockMessages.map(extractMessageText2);
         const { writeFile: writeFile3 } = await import("fs/promises");
         const fileContent = lines2.length > 0 ? lines2.join("\n\n---\n\n") : activeBlocks[0]?.summary ?? "(no content available)";
         await writeFile3(targetPath, fileContent, "utf-8");