opencode-acp 1.12.10-dev.1 → 1.13.1

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 = [];
@@ -1554,7 +1558,10 @@ var defaultConfig = {
   autoUpdate: true,
   debug: false,
   pruneNotification: "detailed",
-  pruneNotificationType: "chat",
+  // [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]
@@ -1609,7 +1616,8 @@ var defaultConfig = {
   gc: {
     algorithm: "truncate",
     promotionThreshold: 5,
-    maxBlockAge: 15,
+    maxBlockAge: Number.MAX_SAFE_INTEGER,
+    // no-op: age-based deactivation removed (memory-loss fix)
     maxOldGenSummaryLength: 3e3,
     majorGcThresholdPercent: "100%",
     batchCleanup: {
@@ -1617,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");
@@ -1814,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 }
     }
   };
 }
@@ -1827,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,
@@ -1846,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) {
@@ -2131,20 +2165,27 @@ function countMessageCharacters(msg) {
 
 // lib/prompts/extensions/tool.ts
 var RANGE_FORMAT_EXTENSION = `
+
 THE FORMAT OF COMPRESS
 
 \`\`\`
 {
-  topic: string,           // Short label (3-5 words) - e.g., "Auth System Exploration"
+  topic?: string,          // OPTIONAL fallback topic for entries without their own.
+                           //   Omit when every content entry specifies its own topic.
   content: [               // One or more ranges to compress
     {
+      topic?: string,      // OPTIONAL per-entry topic for this range.
+                           //   Falls back to top-level topic.
+                           //   Give each entry its own topic when compressing
+                           //   unrelated ranges in one call.
       startId: string,     // Boundary ID at range start: mNNNNN or bN
       endId: string,       // Boundary ID at range end: mNNNNN or bN
       summary: string      // Complete technical summary replacing all content in range
     }
   ]
 }
-\`\`\``;
+\`\`\`
+Each entry needs a topic \u2014 either its own or the top-level fallback.`;
 var MESSAGE_FORMAT_EXTENSION = `
 THE FORMAT OF COMPRESS
 
@@ -3279,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) {
@@ -3969,9 +4012,7 @@ function applyPendingCompressionDurations(state) {
 // lib/compress/range-utils.ts
 var BLOCK_PLACEHOLDER_REGEX = /\(b(\d+)\)|\{block_(\d+)\}/gi;
 function validateArgs2(args) {
-  if (typeof args.topic !== "string" || args.topic.trim().length === 0) {
-    throw new Error("topic is required and must be a non-empty string");
-  }
+  const hasTopLevelTopic = typeof args.topic === "string" && args.topic.trim().length > 0;
   if (!Array.isArray(args.content) || args.content.length === 0) {
     throw new Error("content is required and must be a non-empty array");
   }
@@ -3987,11 +4028,18 @@ function validateArgs2(args) {
     if (typeof entry?.summary !== "string" || entry.summary.trim().length === 0) {
       throw new Error(`${prefix}.summary is required and must be a non-empty string`);
     }
+    const hasEntryTopic = typeof entry?.topic === "string" && entry.topic.trim().length > 0;
+    if (!hasEntryTopic && !hasTopLevelTopic) {
+      throw new Error(
+        `${prefix} needs a topic \u2014 provide ${prefix}.topic or the top-level topic`
+      );
+    }
   }
 }
 function resolveRanges(args, searchContext, state) {
   return args.content.map((entry, index) => {
     const normalizedEntry = {
+      topic: typeof entry.topic === "string" && entry.topic.trim().length > 0 ? entry.topic.trim() : void 0,
       startId: entry.startId.trim(),
       endId: entry.endId.trim(),
       summary: entry.summary
@@ -4185,8 +4233,8 @@ function rebuildRangeInvocation(state, input, searchContext, invocation, protect
     applyCompressionState(
       state,
       {
-        topic: input.topic,
-        batchTopic: input.topic,
+        topic: plan.entry.topic ?? input.topic ?? "",
+        batchTopic: typeof input.topic === "string" ? input.topic : void 0,
         startId: plan.entry.startId,
         endId: plan.entry.endId,
         mode: "range",
@@ -4253,7 +4301,7 @@ function rebuildMessageInvocation(state, input, searchContext, invocation, gcCon
       state,
       {
         topic: entry.topic,
-        batchTopic: input.topic,
+        batchTopic: typeof input.topic === "string" ? input.topic : void 0,
         startId: entry.messageId,
         endId: entry.messageId,
         mode: "message",
@@ -5076,7 +5124,8 @@ async function sendCompressNotification(client, logger, config, state, sessionId
       newlyCompressedToolIds.push(toolId);
     }
   }
-  const topic = batchTopic ?? (entries.length === 1 ? state.prune.messages.blocksById.get(entries[0]?.blockId ?? -1)?.topic ?? "(unknown topic)" : "(unknown topic)");
+  const entryBlockTopics = entries.map((e) => state.prune.messages.blocksById.get(e.blockId)?.topic).filter((t) => typeof t === "string" && t.length > 0);
+  const topic = batchTopic ?? (entries.length === 1 ? state.prune.messages.blocksById.get(entries[0]?.blockId ?? -1)?.topic ?? "(unknown topic)" : entryBlockTopics.length > 0 ? entryBlockTopics.join(" \xB7 ") : "(unknown topic)");
   const contextTokensAfter = Math.max(
     0,
     contextTokensBefore - compressedTokens + summaryTokens
@@ -5131,20 +5180,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) {
@@ -5178,6 +5229,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 {
@@ -5226,6 +6008,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);
@@ -5578,9 +6381,14 @@ function createCompressMessageTool(ctx) {
 import { tool as tool3 } from "@opencode-ai/plugin";
 function buildSchema2(maxSummaryLengthHard) {
   return {
-    topic: tool3.schema.string().describe("Short label (3-5 words) for display - e.g., 'Auth System Exploration'"),
+    topic: tool3.schema.string().optional().describe(
+      "Fallback topic for entries without their own. Omit when each content entry specifies its own topic."
+    ),
     content: tool3.schema.array(
       tool3.schema.object({
+        topic: tool3.schema.string().optional().describe(
+          "Short label (3-5 words) for THIS range, e.g. 'Auth System Exploration'. Omit to use top-level topic. When compressing multiple unrelated ranges, give each its own topic for better quality."
+        ),
         startId: tool3.schema.string().describe(
           "Message or block ID marking the beginning of range (e.g. m00001, b2)"
         ),
@@ -5590,7 +6398,7 @@ function buildSchema2(maxSummaryLengthHard) {
         )
       })
     ).describe(
-      "One or more ranges to compress, each with start/end boundaries and a summary"
+      "One or more ranges to compress, each with start/end boundaries and a summary. When compressing multiple unrelated ranges in one call, give each its own topic."
     ),
     summaryMaxChars: tool3.schema.number().optional().describe(
       `Override max summary length (default max: ${maxSummaryLengthHard} chars). Use when content is important and needs more detail \u2014 don't lose critical info just to fit the limit.`
@@ -5624,7 +6432,7 @@ function createCompressRangeTool(ctx) {
       const { rawMessages, searchContext } = await prepareSession(
         ctx,
         toolCtx,
-        `Compress Range: ${input.topic}`
+        `Compress Range: ${input.topic ?? "(batch)"}`
       );
       const resolvedPlans = resolveRanges(input, searchContext, ctx.state);
       validateNonOverlapping(resolvedPlans);
@@ -5766,7 +6574,7 @@ function createCompressRangeTool(ctx) {
           const applied = applyCompressionState(
             ctx.state,
             {
-              topic: input.topic,
+              topic: preparedPlan.entry.topic ?? input.topic ?? "",
               batchTopic: input.topic,
               startId: preparedPlan.entry.startId,
               endId: preparedPlan.entry.endId,
@@ -5791,7 +6599,13 @@ function createCompressRangeTool(ctx) {
             summaryTokens
           });
         }
-        await finalizeSession(ctx, toolCtx, rawMessages, notifications, input.topic);
+        await finalizeSession(
+          ctx,
+          toolCtx,
+          rawMessages,
+          notifications,
+          input.topic
+        );
       } catch (error) {
         restoreCompressionState(ctx.state, snapshot);
         throw error;
@@ -6195,7 +7009,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);
@@ -6248,7 +7062,7 @@ function buildCompressedBlockGuidance(state, gcConfig, context) {
     }
   }
   const usageRatio = context?.currentTokens && context?.modelContextLimit ? context.currentTokens / context.modelContextLimit : 0;
-  if (gcConfig && usageRatio > 0.5) {
+  if (gcConfig && usageRatio > 0.9) {
     const promotionThreshold = gcConfig.promotionThreshold;
     const agingBlocks = [];
     for (const blockId of activeBlockIds) {
@@ -6266,10 +7080,10 @@ function buildCompressedBlockGuidance(state, gcConfig, context) {
     }
     if (agingBlocks.length > 0) {
       lines.push("");
-      lines.push("\u26A0\uFE0F Block aging warning \u2014 these blocks may be truncated by GC soon:");
+      lines.push("\u26A0\uFE0F Block aging warning \u2014 context near limit, these blocks may be truncated by last-resort GC:");
       lines.push(...agingBlocks);
       lines.push(
-        "To preserve important content: use the compress tool to re-summarize these blocks into new concise ones. Unhandled blocks will be auto-truncated."
+        "Re-summarize these blocks into concise new ones to preserve key facts. At 100% context, oversized blocks are auto-truncated as a last resort."
       );
     }
   }
@@ -6363,6 +7177,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) {
@@ -6475,31 +7345,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) {
@@ -7075,7 +7934,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.
@@ -7251,7 +8110,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
@@ -7266,7 +8125,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,
@@ -8000,7 +8859,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 || "");
@@ -8053,7 +8912,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");
@@ -8774,7 +9633,7 @@ TOOLS
 
 You have five context-management tools:
 
-- \`compress\` \u2014 Replace a contiguous range of older conversation with a single detailed summary you write. Use when content is genuinely consumed (no longer needed for the current task step). Example: \`compress({ topic: "API exploration", content: [{ startId: "m00150", endId: "m00220", summary: "..." }] })\`.
+- \`compress\` \u2014 Replace a contiguous range of older conversation with a single detailed summary you write. Use when content is genuinely consumed (no longer needed for the current task step). Single range: \`compress({ topic: "API exploration", content: [{ startId: "m00150", endId: "m00220", summary: "..." }] })\`. Batch (multiple unrelated ranges, each with its own topic): \`compress({ content: [{ topic: "Auth", startId: "m00150", endId: "m00220", summary: "..." }, { topic: "Deploy", startId: "m00300", endId: "m00350", summary: "..." }] })\`.
 - \`decompress\` \u2014 Restore a previously compressed block's full original content, optionally to a file for large blocks. Use when a summary lacks the exact detail you need. Example: \`decompress({ blockId: "b5" })\` or \`decompress({ blockId: "b5", toFile: "path" })\`.
 - \`search_context\` \u2014 Search compressed block summaries (and optionally visible messages) by keyword. Use BEFORE decompressing to find the right block. Example: \`search_context({ query: "auth token refresh" })\`.
 - \`prune\` \u2014 Remove old tool outputs by tool type, keeping only recent calls. Unlike compress (which creates summaries), prune directly strips outputs. Use for disposable outputs like old todowrite states or edit echoes. Example: \`prune({ toolType: "todowrite", keepLatest: 3 })\`.
@@ -8873,6 +9732,16 @@ Rules:
 BATCHING
 When multiple independent ranges are ready and their boundaries do not overlap, include all of them as separate entries in the \`content\` array of a single tool call. Each entry should have its own \`startId\`, \`endId\`, and \`summary\`.
 
+When the ranges cover unrelated topics, give each entry its own \`topic\` for better summary quality \u2014 do not force unrelated content under a single shared topic. Omit the top-level \`topic\` when every entry has its own. Use the top-level \`topic\` only as a fallback when entries don't specify one.
+
+\`\`\`
+compress({ content: [
+  { topic: "Auth System Exploration", startId: "m00010", endId: "m00050", summary: "..." },
+  { topic: "Bug Hunt", startId: "m00060", endId: "m00080", summary: "..." },
+  { topic: "Deployment", startId: "m00090", endId: "m00110", summary: "..." },
+]})
+\`\`\`
+
 KEEP AND REF MARKERS
 When writing a summary, you may embed markers that reference specific messages in the compressed range. The system resolves them automatically:
 
@@ -10567,46 +11436,9 @@ function createSystemPromptHandler(state, logger, config, prompts) {
   };
 }
 function runMajorGC(state, config, logger, messages) {
-  const maxBlockAge = config.gc.maxBlockAge ?? 15;
-  let agedOutCount = 0;
-  let agedOutTokens = 0;
-  const now = Date.now();
-  for (const [blockId, block] of state.prune.messages.blocksById) {
-    if (!block.active) continue;
-    const age = block.survivedCount ?? 0;
-    if (age > maxBlockAge) {
-      block.active = false;
-      block.deactivatedAt = now;
-      block.deactivatedByBlockId = void 0;
-      state.prune.messages.activeBlockIds.delete(Number(blockId));
-      const anchorMapped = state.prune.messages.activeByAnchorMessageId.get(block.anchorMessageId);
-      if (anchorMapped === Number(blockId)) {
-        state.prune.messages.activeByAnchorMessageId.delete(block.anchorMessageId);
-      }
-      agedOutCount++;
-      agedOutTokens += block.summaryTokens ?? Math.round(block.summary.length / 4);
-    }
-  }
-  if (agedOutCount > 0) {
-    logger.info("Major GC: deactivated aged-out blocks", {
-      agedOutCount,
-      agedOutTokens,
-      maxBlockAge
-    });
-    saveSessionState(state, logger).catch(() => {
-    });
-  }
   if (!state.modelContextLimit) return;
   const currentTokens = getCurrentTokenUsage(state, messages);
-  const oversizedThreshold = config.gc.maxOldGenSummaryLength * 2;
-  let hasOversizedBlocks = false;
-  for (const [, block] of state.prune.messages.blocksById) {
-    if (block.active && block.summary.length > oversizedThreshold) {
-      hasOversizedBlocks = true;
-      break;
-    }
-  }
-  if (!shouldRunMajorGC(currentTokens, state.modelContextLimit, config.gc) && !hasOversizedBlocks) return;
+  if (!shouldRunMajorGC(currentTokens, state.modelContextLimit, config.gc)) return;
   const oldBlocks = [];
   for (const [blockId, block] of state.prune.messages.blocksById) {
     if (!block.active) continue;