opencode-acp 1.3.1 → 1.4.1

package/dist/index.js

@@ -905,6 +905,10 @@ var VALID_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "gc.maxBlockAge",
   "gc.maxOldGenSummaryLength",
   "gc.majorGcThresholdPercent",
+  "gc.batchCleanup",
+  "gc.batchCleanup.lowThreshold",
+  "gc.batchCleanup.highThreshold",
+  "gc.batchCleanup.forceThreshold",
   "strategies",
   "strategies.deduplication",
   "strategies.deduplication.enabled",
@@ -1263,6 +1267,36 @@ function validateConfigTypes(config) {
           });
         }
       }
+      const validateBatchThreshold = (key, value) => {
+        const isValidNumber = typeof value === "number";
+        const isPercentString = typeof value === "string" && /^\d+(?:\.\d+)?%$/.test(value);
+        if (!isValidNumber && !isPercentString) {
+          errors.push({
+            key,
+            expected: 'number | "${number}%"',
+            actual: JSON.stringify(value)
+          });
+        }
+      };
+      if (gc.batchCleanup !== void 0) {
+        if (typeof gc.batchCleanup !== "object" || gc.batchCleanup === null || Array.isArray(gc.batchCleanup)) {
+          errors.push({
+            key: "gc.batchCleanup",
+            expected: "object",
+            actual: typeof gc.batchCleanup
+          });
+        } else {
+          if (gc.batchCleanup.lowThreshold !== void 0) {
+            validateBatchThreshold("gc.batchCleanup.lowThreshold", gc.batchCleanup.lowThreshold);
+          }
+          if (gc.batchCleanup.highThreshold !== void 0) {
+            validateBatchThreshold("gc.batchCleanup.highThreshold", gc.batchCleanup.highThreshold);
+          }
+          if (gc.batchCleanup.forceThreshold !== void 0) {
+            validateBatchThreshold("gc.batchCleanup.forceThreshold", gc.batchCleanup.forceThreshold);
+          }
+        }
+      }
     }
   }
   const strategies = config.strategies;
@@ -1351,6 +1385,8 @@ var DEFAULT_PROTECTED_TOOLS = [
   "todoread",
   "compress",
   "decompress",
+  "mark_block",
+  "unmark_block",
   "batch",
   "plan_enter",
   "plan_exit",
@@ -1447,7 +1483,12 @@ var defaultConfig = {
     promotionThreshold: 5,
     maxBlockAge: 15,
     maxOldGenSummaryLength: 3e3,
-    majorGcThresholdPercent: "100%"
+    majorGcThresholdPercent: "100%",
+    batchCleanup: {
+      lowThreshold: "60%",
+      highThreshold: "75%",
+      forceThreshold: "90%"
+    }
   }
 };
 var GLOBAL_CONFIG_DIR = process.env.XDG_CONFIG_HOME ? join(process.env.XDG_CONFIG_HOME, "opencode") : join(homedir(), ".config", "opencode");
@@ -1507,7 +1548,7 @@ function createDefaultConfig() {
       console.log("[ACP] Migrated config from dcp.json to acp.jsonc");
     } else {
       const configContent = `{
-  "$schema": "https://raw.githubusercontent.com/Opencode-DCP/opencode-dynamic-context-pruning/master/dcp.schema.json"
+  "$schema": "https://raw.githubusercontent.com/ranxianglei/opencode-acp/master/dcp.schema.json"
 }
 `;
       writeFileSync(GLOBAL_CONFIG_PATH_JSONC, configContent, "utf-8");
@@ -1631,7 +1672,20 @@ function deepCloneConfig(config) {
         protectedTools: [...config.strategies.purgeErrors.protectedTools]
       }
     },
-    gc: { ...config.gc }
+    gc: {
+      ...config.gc,
+      batchCleanup: { ...config.gc.batchCleanup }
+    }
+  };
+}
+function mergeGC(base, override) {
+  if (!override) {
+    return base;
+  }
+  return {
+    ...base,
+    ...override,
+    batchCleanup: { ...base.batchCleanup, ...override.batchCleanup ?? {} }
   };
 }
 function mergeLayer(config, data) {
@@ -1652,7 +1706,7 @@ function mergeLayer(config, data) {
       .../* @__PURE__ */ new Set([...config.protectedFilePatterns, ...data.protectedFilePatterns ?? []])
     ],
     compress: mergeCompress(config.compress, data.compress),
-    gc: { ...config.gc, ...data.gc },
+    gc: mergeGC(config.gc, data.gc),
     strategies: mergeStrategies(config.strategies, data.strategies)
   };
 }
@@ -2747,7 +2801,8 @@ function serializePruneMessagesState(messagesState) {
     activeBlockIds: Array.from(messagesState.activeBlockIds),
     activeByAnchorMessageId: Object.fromEntries(messagesState.activeByAnchorMessageId),
     nextBlockId: messagesState.nextBlockId,
-    nextRunId: messagesState.nextRunId
+    nextRunId: messagesState.nextRunId,
+    markedForCleanup: Array.from(messagesState.markedForCleanup)
   };
 }
 async function isSubAgentSession(client, sessionID) {
@@ -2804,7 +2859,8 @@ function createPruneMessagesState() {
     activeBlockIds: /* @__PURE__ */ new Set(),
     activeByAnchorMessageId: /* @__PURE__ */ new Map(),
     nextBlockId: 1,
-    nextRunId: 1
+    nextRunId: 1,
+    markedForCleanup: /* @__PURE__ */ new Set()
   };
 }
 function loadPruneMessagesState(persisted) {
@@ -2915,6 +2971,13 @@ function loadPruneMessagesState(persisted) {
       state.nextRunId = block.runId + 1;
     }
   }
+  if (Array.isArray(persisted.markedForCleanup)) {
+    for (const id of persisted.markedForCleanup) {
+      if (Number.isInteger(id) && id > 0 && state.blocksById.has(id)) {
+        state.markedForCleanup.add(id);
+      }
+    }
+  }
   return state;
 }
 function collectTurnNudgeAnchors(messages) {
@@ -3467,20 +3530,20 @@ function matchesGlob(inputPath, pattern) {
   regex += "$";
   return new RegExp(regex).test(input);
 }
-function getFilePathsFromParameters(tool4, parameters) {
+function getFilePathsFromParameters(tool5, parameters) {
   if (typeof parameters !== "object" || parameters === null) {
     return [];
   }
   const paths = [];
   const params = parameters;
-  if (tool4 === "apply_patch" && typeof params.patchText === "string") {
+  if (tool5 === "apply_patch" && typeof params.patchText === "string") {
     const pathRegex = /\*\*\* (?:Add|Delete|Update) File: ([^\n\r]+)/g;
     let match;
     while ((match = pathRegex.exec(params.patchText)) !== null) {
       paths.push(match[1].trim());
     }
   }
-  if (tool4 === "multiedit") {
+  if (tool5 === "multiedit") {
     if (typeof params.filePath === "string") {
       paths.push(params.filePath);
     }
@@ -3575,13 +3638,13 @@ var deduplicate = (state, logger, config, messages) => {
     logger.debug(`Marked ${newPruneIds.length} duplicate tool calls for pruning`);
   }
 };
-function createToolSignature(tool4, parameters) {
+function createToolSignature(tool5, parameters) {
   if (!parameters) {
-    return tool4;
+    return tool5;
   }
   const normalized = normalizeParameters(parameters);
   const sorted = sortObjectKeys(normalized);
-  return `${tool4}::${JSON.stringify(sorted)}`;
+  return `${tool5}::${JSON.stringify(sorted)}`;
 }
 function normalizeParameters(params) {
   if (typeof params !== "object" || params === null) return params;
@@ -3656,9 +3719,9 @@ var purgeErrors = (state, logger, config, messages) => {
 };
 
 // lib/ui/utils.ts
-function extractParameterKey(tool4, parameters) {
+function extractParameterKey(tool5, parameters) {
   if (!parameters) return "";
-  if (tool4 === "read" && parameters.filePath) {
+  if (tool5 === "read" && parameters.filePath) {
     const offset = parameters.offset;
     const limit = parameters.limit;
     if (offset !== void 0 && limit !== void 0) {
@@ -3672,10 +3735,10 @@ function extractParameterKey(tool4, parameters) {
     }
     return parameters.filePath;
   }
-  if ((tool4 === "write" || tool4 === "edit" || tool4 === "multiedit") && parameters.filePath) {
+  if ((tool5 === "write" || tool5 === "edit" || tool5 === "multiedit") && parameters.filePath) {
     return parameters.filePath;
   }
-  if (tool4 === "apply_patch" && typeof parameters.patchText === "string") {
+  if (tool5 === "apply_patch" && typeof parameters.patchText === "string") {
     const pathRegex = /\*\*\* (?:Add|Delete|Update) File: ([^\n\r]+)/g;
     const paths = [];
     let match;
@@ -3692,51 +3755,51 @@ function extractParameterKey(tool4, parameters) {
     }
     return "patch";
   }
-  if (tool4 === "list") {
+  if (tool5 === "list") {
     return parameters.path || "(current directory)";
   }
-  if (tool4 === "glob") {
+  if (tool5 === "glob") {
     if (parameters.pattern) {
       const pathInfo = parameters.path ? ` in ${parameters.path}` : "";
       return `"${parameters.pattern}"${pathInfo}`;
     }
     return "(unknown pattern)";
   }
-  if (tool4 === "grep") {
+  if (tool5 === "grep") {
     if (parameters.pattern) {
       const pathInfo = parameters.path ? ` in ${parameters.path}` : "";
       return `"${parameters.pattern}"${pathInfo}`;
     }
     return "(unknown pattern)";
   }
-  if (tool4 === "bash") {
+  if (tool5 === "bash") {
     if (parameters.description) return parameters.description;
     if (parameters.command) {
       return parameters.command.length > 50 ? parameters.command.substring(0, 50) + "..." : parameters.command;
     }
   }
-  if (tool4 === "webfetch" && parameters.url) {
+  if (tool5 === "webfetch" && parameters.url) {
     return parameters.url;
   }
-  if (tool4 === "websearch" && parameters.query) {
+  if (tool5 === "websearch" && parameters.query) {
     return `"${parameters.query}"`;
   }
-  if (tool4 === "codesearch" && parameters.query) {
+  if (tool5 === "codesearch" && parameters.query) {
     return `"${parameters.query}"`;
   }
-  if (tool4 === "todowrite") {
+  if (tool5 === "todowrite") {
     return `${parameters.todos?.length || 0} todos`;
   }
-  if (tool4 === "todoread") {
+  if (tool5 === "todoread") {
     return "read todo list";
   }
-  if (tool4 === "task" && parameters.description) {
+  if (tool5 === "task" && parameters.description) {
     return parameters.description;
   }
-  if (tool4 === "skill" && parameters.name) {
+  if (tool5 === "skill" && parameters.name) {
     return parameters.name;
   }
-  if (tool4 === "lsp") {
+  if (tool5 === "lsp") {
     const op = parameters.operation || "lsp";
     const path = parameters.filePath || "";
     const line = parameters.line;
@@ -3749,7 +3812,7 @@ function extractParameterKey(tool4, parameters) {
     }
     return op;
   }
-  if (tool4 === "question") {
+  if (tool5 === "question") {
     const questions = parameters.questions;
     if (Array.isArray(questions) && questions.length > 0) {
       const headers = questions.map((q) => q.header || "").filter(Boolean).slice(0, 3);
@@ -4717,6 +4780,12 @@ import { tool as tool3 } from "@opencode-ai/plugin";
 // lib/messages/utils.ts
 import { createHash } from "crypto";
 var SUMMARY_ID_HASH_LENGTH = 16;
+var MERGED_SUMMARY_HEADER = (blockId) => `[ACP compressed context summary (block ${blockId}) \u2014 prior conversation recap]
+`;
+var MERGED_SUMMARY_FOOTER = `
+[End ACP compressed context summary]
+
+`;
 var DCP_BLOCK_ID_TAG_REGEX = /(<dcp-message-id(?=[\s>])[^>]*>)b\d+(<\/dcp-message-id>)/g;
 var DCP_MESSAGE_REF_TAG_REGEX = /<dcp-message-id>m\d+<\/dcp-message-id>/g;
 var DCP_PAIRED_TAG_REGEX = /<dcp[^>]*>[\s\S]*?<\/dcp[^>]*>/gi;
@@ -4751,6 +4820,34 @@ var createSyntheticUserMessage = (baseMessage, content, stableSeed) => {
     ]
   };
 };
+var prependCompressionSummary = (message, summary, blockId) => {
+  const parts = Array.isArray(message.parts) ? message.parts : [];
+  const header = MERGED_SUMMARY_HEADER(blockId);
+  const marker = MERGED_SUMMARY_HEADER(blockId).trimEnd();
+  for (const part of parts) {
+    if (part.type !== "text") {
+      continue;
+    }
+    const textPart = part;
+    const existing = typeof textPart.text === "string" ? textPart.text : "";
+    if (existing.includes(marker)) {
+      return true;
+    }
+    textPart.text = `${header}${summary}${MERGED_SUMMARY_FOOTER}${existing}`;
+    return true;
+  }
+  const sessionID = message.info.sessionID ?? "";
+  const messageId = message.info.id;
+  parts.unshift({
+    id: generateStableId("prt_dcp_prepend", `${blockId}:${messageId}`),
+    sessionID,
+    messageID: messageId,
+    type: "text",
+    text: `${header}${summary}${MERGED_SUMMARY_FOOTER}`
+  });
+  message.parts = parts;
+  return true;
+};
 var createSyntheticTextPart = (baseMessage, content, stableSeed) => {
   const userInfo = baseMessage.info;
   const deterministicSeed = stableSeed?.trim() || userInfo.id;
@@ -4950,7 +5047,8 @@ var filterCompressedRanges = (state, logger, config, messages) => {
     return;
   }
   const result = [];
-  for (const msg of messages) {
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
     const msgId = msg.info.id;
     const blockId = state.prune.messages.activeByAnchorMessageId.get(msgId);
     const summary = blockId !== void 0 ? state.prune.messages.blocksById.get(blockId) : void 0;
@@ -4962,46 +5060,52 @@ var filterCompressedRanges = (state, logger, config, messages) => {
           blockId: summary.blockId
         });
       } else {
-        const msgIndex = messages.indexOf(msg);
-        const userMessage = getLastUserMessage(messages, msgIndex);
         const _cleaned = stripStaleMessageRefs(rawSummaryContent);
-        if (userMessage) {
-          const userInfo = userMessage.info;
-          const summaryContent = config.compress.mode === "message" ? replaceBlockIdsWithBlocked(_cleaned) : _cleaned;
-          const summarySeed = `${summary.blockId}:${summary.anchorMessageId}`;
-          result.push(
-            createSyntheticUserMessage(userMessage, summaryContent, summarySeed)
-          );
-          logger.info("Injected compress summary", {
+        const summaryContent = config.compress.mode === "message" ? replaceBlockIdsWithBlocked(_cleaned) : _cleaned;
+        const nextSurviving = findNextSurvivingMessage(messages, i, state);
+        const merged = nextSurviving !== null && nextSurviving.info.role === "user" && prependCompressionSummary(nextSurviving, summaryContent, summary.blockId);
+        if (merged) {
+          logger.info("Merged compress summary into following user message", {
             anchorMessageId: msgId,
+            targetMessageId: nextSurviving.info.id,
             summaryLength: summaryContent.length
           });
         } else {
-          const anchorInfo = msg.info;
-          const fallbackBase = {
-            info: {
-              id: anchorInfo.id || msgId,
-              sessionID: anchorInfo.sessionID || "",
-              role: "user",
-              agent: anchorInfo.agent || "code",
-              model: anchorInfo.model || {
-                providerID: "",
-                modelID: "",
-                variant: void 0
-              },
-              time: { created: anchorInfo.time?.created || Date.now() }
-            },
-            parts: []
-          };
-          const summaryContent = config.compress.mode === "message" ? replaceBlockIdsWithBlocked(_cleaned) : _cleaned;
+          const userMessage = getLastUserMessage(messages, i);
           const summarySeed = `${summary.blockId}:${summary.anchorMessageId}`;
-          result.push(
-            createSyntheticUserMessage(fallbackBase, summaryContent, summarySeed)
-          );
-          logger.info("Injected compress summary (fallback, no preceding user message)", {
-            anchorMessageId: msgId,
-            summaryLength: summaryContent.length
-          });
+          if (userMessage) {
+            result.push(
+              createSyntheticUserMessage(userMessage, summaryContent, summarySeed)
+            );
+            logger.info("Injected compress summary", {
+              anchorMessageId: msgId,
+              summaryLength: summaryContent.length
+            });
+          } else {
+            const anchorInfo = msg.info;
+            const fallbackBase = {
+              info: {
+                id: anchorInfo.id || msgId,
+                sessionID: anchorInfo.sessionID || "",
+                role: "user",
+                agent: anchorInfo.agent || "code",
+                model: anchorInfo.model || {
+                  providerID: "",
+                  modelID: "",
+                  variant: void 0
+                },
+                time: { created: anchorInfo.time?.created || Date.now() }
+              },
+              parts: []
+            };
+            result.push(
+              createSyntheticUserMessage(fallbackBase, summaryContent, summarySeed)
+            );
+            logger.info("Injected compress summary (fallback, no preceding user message)", {
+              anchorMessageId: msgId,
+              summaryLength: summaryContent.length
+            });
+          }
         }
       }
     }
@@ -5014,6 +5118,17 @@ var filterCompressedRanges = (state, logger, config, messages) => {
   messages.length = 0;
   messages.push(...result);
 };
+var findNextSurvivingMessage = (messages, startIndex, state) => {
+  for (let j = startIndex; j < messages.length; j++) {
+    const candidate = messages[j];
+    const entry = state.prune.messages.byMessageId.get(candidate.info.id);
+    if (entry && entry.activeBlockIds.length > 0) {
+      continue;
+    }
+    return candidate;
+  }
+  return null;
+};
 
 // lib/messages/sync.ts
 function sortBlocksByCreation(a, b) {
@@ -5162,8 +5277,8 @@ var resolveEffectiveCompressPermission = (basePermission, hostPermissions, agent
     agentName ? hostPermissions.agents[agentName] : void 0
   ) ? "deny" : basePermission;
 };
-var hasExplicitToolPermission = (permissionConfig, tool4) => {
-  return permissionConfig ? Object.prototype.hasOwnProperty.call(permissionConfig, tool4) : false;
+var hasExplicitToolPermission = (permissionConfig, tool5) => {
+  return permissionConfig ? Object.prototype.hasOwnProperty.call(permissionConfig, tool5) : false;
 };
 
 // lib/compress-permission.ts
@@ -6275,6 +6390,109 @@ function createDecompressTool(ctx) {
   });
 }
 
+// lib/compress/mark-block.ts
+import { tool as tool4 } from "@opencode-ai/plugin";
+async function prepareMarkSession(ctx, toolCtx) {
+  await toolCtx.ask({
+    permission: "compress",
+    patterns: ["*"],
+    always: ["*"],
+    metadata: {}
+  });
+  toolCtx.metadata({ title: "Mark block" });
+  const rawMessages = await fetchSessionMessages(ctx.client, toolCtx.sessionID);
+  await ensureSessionInitialized(
+    ctx.client,
+    ctx.state,
+    toolCtx.sessionID,
+    ctx.logger,
+    rawMessages,
+    ctx.config.manualMode.enabled
+  );
+  assignMessageRefs(ctx.state, rawMessages);
+}
+var MARK_DESCRIPTION = `Marks a compressed block for batch merge-cleanup.
+
+Use this for blocks whose detailed content you no longer need, but whose summaries
+you want to keep in context for now (to preserve prompt cache). Marked blocks stay
+fully active with zero immediate effect on context or cache. When context pressure
+rises, all marked blocks are merge-compressed together into a single summary in one
+cache break, instead of being handled one at a time.
+
+Argument: blockId \u2014 the block reference to mark (e.g., "b1", "b3")
+
+Use mark_block instead of compress when you want deferred cleanup: the block keeps
+serving cache hits now and gets consolidated later only if context gets tight.`;
+var UNMARK_DESCRIPTION = `Removes the batch cleanup mark from a compressed block.
+
+Reverses mark_block. The block returns to normal handling and will not be
+auto-merged during batch cleanup.
+
+Argument: blockId \u2014 the block reference to unmark (e.g., "b1", "b3")`;
+function buildSchema4() {
+  return {
+    blockId: tool4.schema.string().describe('Block reference to mark (e.g., "b1", "b3")')
+  };
+}
+function buildUnmarkSchema() {
+  return {
+    blockId: tool4.schema.string().describe('Block reference to unmark (e.g., "b1", "b3")')
+  };
+}
+function createMarkBlockTool(ctx) {
+  return tool4({
+    description: MARK_DESCRIPTION,
+    args: buildSchema4(),
+    async execute(args, toolCtx) {
+      await prepareMarkSession(ctx, toolCtx);
+      const targetBlockId = parseBlockRef(String(args.blockId));
+      if (targetBlockId === null) {
+        return `Error: Invalid block ID "${args.blockId}". Use format "b0", "b1", etc.`;
+      }
+      const messagesState = ctx.state.prune.messages;
+      const block = messagesState.blocksById.get(targetBlockId);
+      if (!block) {
+        return `Error: Block ${formatBlockRef(targetBlockId)} does not exist.`;
+      }
+      if (!block.active) {
+        return `Error: Block ${formatBlockRef(targetBlockId)} is not active.`;
+      }
+      messagesState.markedForCleanup.add(targetBlockId);
+      await saveSessionState(ctx.state, ctx.logger);
+      const ref = formatBlockRef(targetBlockId);
+      const markedCount = messagesState.markedForCleanup.size;
+      ctx.logger.info("mark_block: block marked for cleanup", {
+        blockId: targetBlockId,
+        markedCount
+      });
+      return `Block ${ref} marked for cleanup. It will be merge-compressed together with other marked blocks when context pressure rises. No immediate effect on context or cache. (${markedCount} block(s) currently marked.)`;
+    }
+  });
+}
+function createUnmarkBlockTool(ctx) {
+  return tool4({
+    description: UNMARK_DESCRIPTION,
+    args: buildUnmarkSchema(),
+    async execute(args, toolCtx) {
+      await prepareMarkSession(ctx, toolCtx);
+      const targetBlockId = parseBlockRef(String(args.blockId));
+      if (targetBlockId === null) {
+        return `Error: Invalid block ID "${args.blockId}". Use format "b0", "b1", etc.`;
+      }
+      const messagesState = ctx.state.prune.messages;
+      if (!messagesState.markedForCleanup.has(targetBlockId)) {
+        return `Block ${formatBlockRef(targetBlockId)} was not marked for cleanup.`;
+      }
+      messagesState.markedForCleanup.delete(targetBlockId);
+      await saveSessionState(ctx.state, ctx.logger);
+      ctx.logger.info("unmark_block: block unmarked", {
+        blockId: targetBlockId
+      });
+      return `Block ${formatBlockRef(targetBlockId)} unmarked. It will no longer be auto-merged during batch cleanup.`;
+    }
+  });
+}
+
 // lib/logger.ts
 import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
 import { join as join3 } from "path";
@@ -6483,7 +6701,7 @@ var SYSTEM = `
 
 You operate in a context-constrained environment. Context management helps preserve retrieval quality, but your primary goal is completing the task at hand. Do not let context management distract from the actual work.
 
-The tools you have for context management are \`compress\` and \`decompress\`. \`compress\` replaces older conversation content with technical summaries you produce. \`decompress\` restores previously compressed content when you need exact details.
+The tools you have for context management are \`compress\`, \`decompress\`, \`mark_block\`, and \`unmark_block\`. \`compress\` replaces older conversation content with technical summaries you produce. \`decompress\` restores previously compressed content when you need exact details. \`mark_block\` flags a compressed block for deferred batch merge-cleanup \u2014 it has zero immediate effect on context or cache, but marked blocks are merge-compressed together in a single cache break when context pressure rises. Use it for blocks you no longer need in detail but want to keep cached for now. \`unmark_block\` removes that flag.
 
 \`<dcp-message-id>\` and \`<dcp-system-reminder>\` tags are environment-injected metadata. Do not output them.
 
@@ -7514,7 +7732,7 @@ var COMPRESS_TRIGGER_PROMPT = [
   "Follow the active compress mode, preserve all critical implementation details, and choose safe targets.",
   "Return after compress with a brief explanation of what content was compressed."
 ].join("\n\n");
-function getTriggerPrompt(tool4, state, config, userFocus) {
+function getTriggerPrompt(tool5, state, config, userFocus) {
   const base = COMPRESS_TRIGGER_PROMPT;
   const compressedBlockGuidance = config.compress.mode === "message" ? "" : buildCompressedBlockGuidance(state, config.gc);
   const sections = [base, compressedBlockGuidance];
@@ -7543,8 +7761,8 @@ async function handleManualToggleCommand(ctx, modeArg) {
   );
   logger.info("Manual mode toggled", { manualMode: state.manualMode });
 }
-async function handleManualTriggerCommand(ctx, tool4, userFocus) {
-  return getTriggerPrompt(tool4, ctx.state, ctx.config, userFocus);
+async function handleManualTriggerCommand(ctx, tool5, userFocus) {
+  return getTriggerPrompt(tool5, ctx.state, ctx.config, userFocus);
 }
 function applyPendingManualTrigger(state, messages, logger) {
   const pending = state.pendingManualTrigger;
@@ -8073,6 +8291,264 @@ function parseGcThreshold(limit, modelContextLimit) {
   return Math.round(Math.max(0, Math.min(100, Math.round(percent))) / 100 * modelContextLimit);
 }
 
+// lib/gc/merge.ts
+var DEFAULT_BATCH_CLEANUP = {
+  lowThreshold: "60%",
+  highThreshold: "75%",
+  forceThreshold: "90%"
+};
+function resolveBatchCleanup(gc) {
+  return gc.batchCleanup ?? DEFAULT_BATCH_CLEANUP;
+}
+function percentToTokens(value, modelContextLimit) {
+  if (typeof value === "number") return value;
+  const percent = parseFloat(value.slice(0, -1));
+  if (isNaN(percent)) return modelContextLimit;
+  const clamped = Math.max(0, Math.min(100, Math.round(percent)));
+  return Math.round(clamped / 100 * modelContextLimit);
+}
+function collectActiveOldGenBlocks(state, maxOldGenSummaryLength) {
+  const blocks = [];
+  const ids = Array.from(state.prune.messages.activeBlockIds).sort((a, b) => a - b);
+  for (const id of ids) {
+    const block = state.prune.messages.blocksById.get(id);
+    if (!block || !block.active) continue;
+    if (block.generation === "old" || block.generation === void 0 || block.summary.length > maxOldGenSummaryLength) {
+      blocks.push(block);
+    }
+  }
+  return blocks;
+}
+function collectActiveMarkedBlocks(state) {
+  const ids = Array.from(state.prune.messages.markedForCleanup).sort((a, b) => a - b);
+  const blocks = [];
+  for (const id of ids) {
+    const block = state.prune.messages.blocksById.get(id);
+    if (!block || !block.active) continue;
+    blocks.push(block);
+  }
+  return blocks;
+}
+function extractSummaryBody(summary) {
+  let body = summary;
+  const headerPrefix = COMPRESSED_BLOCK_HEADER + "\n";
+  if (body.startsWith(headerPrefix)) {
+    body = body.slice(headerPrefix.length);
+  }
+  body = body.replace(/\n<dcp-message-id[^>]*>b\d+<\/dcp-message-id>$/, "");
+  return body.trim();
+}
+function truncateMergedSummary(merged, maxLength) {
+  if (merged.length <= maxLength) return merged;
+  const blocks = merged.split("\n---\n");
+  const headers = blocks.map((b) => b.split("\n")[0] ?? "").filter((h) => h.trim().length > 0);
+  const marker = "\n...\n[merged and truncated by batch cleanup]";
+  const budget = Math.max(0, maxLength - marker.length);
+  const headerJoin = headers.join("\n");
+  if (headerJoin.length <= budget) {
+    return headerJoin + marker;
+  }
+  return headerJoin.slice(0, budget) + marker;
+}
+function mergeMarkedBlocks(state, markedIds, maxMergedLength) {
+  const sortedIds = [...new Set(markedIds)].filter(
+    (id) => Number.isInteger(id) && id > 0
+  ).sort((a, b) => a - b);
+  const sourceBlocks = [];
+  for (const id of sortedIds) {
+    const block = state.prune.messages.blocksById.get(id);
+    if (!block || !block.active) continue;
+    if (!sourceBlocks.some((b) => b.blockId === id)) {
+      sourceBlocks.push(block);
+    }
+  }
+  if (sourceBlocks.length < 2) {
+    return { mergedCount: 0, savedTokens: 0 };
+  }
+  const messagesState = state.prune.messages;
+  const newBlockId = allocateBlockId(state);
+  const newRunId = allocateRunId(state);
+  const bodies = sourceBlocks.map((block) => extractSummaryBody(block.summary));
+  const mergedRaw = bodies.join("\n---\n");
+  const mergedBody = truncateMergedSummary(mergedRaw, maxMergedLength);
+  const newSummary = wrapCompressedSummary(newBlockId, mergedBody);
+  const newSummaryTokens = countTokens2(newSummary);
+  const oldest = sourceBlocks[0];
+  const newest = sourceBlocks[sourceBlocks.length - 1];
+  const effectiveMessageIds = /* @__PURE__ */ new Set();
+  const effectiveToolIds = /* @__PURE__ */ new Set();
+  for (const block of sourceBlocks) {
+    for (const id of block.effectiveMessageIds) effectiveMessageIds.add(id);
+    for (const id of block.effectiveToolIds) effectiveToolIds.add(id);
+  }
+  const sourceIds = sourceBlocks.map((b) => b.blockId);
+  const createdAt = Date.now();
+  const mergedBlock = {
+    blockId: newBlockId,
+    runId: newRunId,
+    active: true,
+    deactivatedByUser: false,
+    compressedTokens: 0,
+    summaryTokens: newSummaryTokens,
+    durationMs: 0,
+    mode: "range",
+    topic: "Batch merge cleanup",
+    batchTopic: "Batch merge cleanup",
+    startId: oldest.startId,
+    endId: newest.endId,
+    anchorMessageId: oldest.anchorMessageId,
+    compressMessageId: "",
+    compressCallId: void 0,
+    includedBlockIds: [...sourceIds],
+    consumedBlockIds: [...sourceIds],
+    parentBlockIds: [],
+    directMessageIds: [],
+    directToolIds: [],
+    effectiveMessageIds: [...effectiveMessageIds],
+    effectiveToolIds: [...effectiveToolIds],
+    createdAt,
+    summary: newSummary,
+    survivedCount: 0,
+    generation: "old"
+  };
+  const now = Date.now();
+  for (const block of sourceBlocks) {
+    block.active = false;
+    block.deactivatedAt = now;
+    block.deactivatedByBlockId = newBlockId;
+    if (!block.parentBlockIds.includes(newBlockId)) {
+      block.parentBlockIds.push(newBlockId);
+    }
+    messagesState.activeBlockIds.delete(block.blockId);
+    const mappedId = messagesState.activeByAnchorMessageId.get(block.anchorMessageId);
+    if (mappedId === block.blockId) {
+      messagesState.activeByAnchorMessageId.delete(block.anchorMessageId);
+    }
+  }
+  messagesState.blocksById.set(newBlockId, mergedBlock);
+  messagesState.activeBlockIds.add(newBlockId);
+  messagesState.activeByAnchorMessageId.set(mergedBlock.anchorMessageId, newBlockId);
+  for (const messageId of effectiveMessageIds) {
+    const entry = messagesState.byMessageId.get(messageId);
+    if (!entry) continue;
+    entry.activeBlockIds = entry.activeBlockIds.filter((id) => !sourceIds.includes(id));
+    if (!entry.activeBlockIds.includes(newBlockId)) {
+      entry.activeBlockIds.push(newBlockId);
+    }
+    if (!entry.allBlockIds.includes(newBlockId)) {
+      entry.allBlockIds.push(newBlockId);
+    }
+  }
+  for (const id of sourceIds) {
+    messagesState.markedForCleanup.delete(id);
+  }
+  const sourceTokens = sourceBlocks.reduce(
+    (sum, block) => sum + (block.summaryTokens || Math.round(block.summary.length / 4)),
+    0
+  );
+  const savedTokens = Math.max(0, sourceTokens - newSummaryTokens);
+  return { mergedCount: sourceBlocks.length, savedTokens };
+}
+function buildNudgeText(state, maxMergedLength) {
+  const blocks = collectActiveMarkedBlocks(state);
+  if (blocks.length < 1) return void 0;
+  const refs = blocks.map((b) => formatBlockRef(b.blockId)).join(", ");
+  const sourceTokens = blocks.reduce(
+    (sum, block) => sum + (block.summaryTokens || Math.round(block.summary.length / 4)),
+    0
+  );
+  const estimatedMergedTokens = Math.round(maxMergedLength / 4);
+  const estimatedSavings = Math.max(0, sourceTokens - estimatedMergedTokens);
+  return [
+    `\u26A0\uFE0F ${blocks.length} block(s) marked for batch cleanup (${refs}).`,
+    `Merge-compressing them would free ~${estimatedSavings} tokens.`,
+    blocks.length >= 2 ? "They will auto-merge when context pressure reaches the high threshold." : "A single marked block won't auto-merge on its own \u2014 use compress to consolidate it, or unmark_block if no longer needed.",
+    "To act now, use compress with a range covering these blocks."
+  ].join(" ");
+}
+function runBatchCleanup(state, config, logger, messages) {
+  const noop = {
+    tier: 0,
+    action: "none",
+    mergedCount: 0,
+    savedTokens: 0
+  };
+  if (!state.modelContextLimit || state.modelContextLimit <= 0) {
+    return noop;
+  }
+  const currentTokens = getCurrentTokenUsage(state, messages);
+  const limit = state.modelContextLimit;
+  const batchCleanup = resolveBatchCleanup(config.gc);
+  const maxMergedLength = config.gc.maxOldGenSummaryLength;
+  const forceTokens = percentToTokens(batchCleanup.forceThreshold, limit);
+  const highTokens = percentToTokens(batchCleanup.highThreshold, limit);
+  const lowTokens = percentToTokens(batchCleanup.lowThreshold, limit);
+  if (currentTokens >= forceTokens) {
+    const oldGenBlocks = collectActiveOldGenBlocks(state, maxMergedLength);
+    if (oldGenBlocks.length < 2) {
+      return noop;
+    }
+    const ids = oldGenBlocks.map((b) => b.blockId);
+    const result = mergeMarkedBlocks(state, ids, maxMergedLength);
+    if (result.mergedCount === 0) {
+      return noop;
+    }
+    logger.info("Batch cleanup tier 3 (force): merged old-gen blocks", {
+      mergedCount: result.mergedCount,
+      savedTokens: result.savedTokens,
+      currentTokens,
+      forceThreshold: batchCleanup.forceThreshold
+    });
+    return {
+      tier: 3,
+      action: "merge",
+      mergedCount: result.mergedCount,
+      savedTokens: result.savedTokens
+    };
+  }
+  if (currentTokens >= highTokens) {
+    const marked = collectActiveMarkedBlocks(state);
+    if (marked.length < 2) {
+      return noop;
+    }
+    const ids = marked.map((b) => b.blockId);
+    const result = mergeMarkedBlocks(state, ids, maxMergedLength);
+    if (result.mergedCount === 0) {
+      return noop;
+    }
+    logger.info("Batch cleanup tier 2 (high): merged marked blocks", {
+      mergedCount: result.mergedCount,
+      savedTokens: result.savedTokens,
+      currentTokens,
+      highThreshold: batchCleanup.highThreshold
+    });
+    return {
+      tier: 2,
+      action: "merge",
+      mergedCount: result.mergedCount,
+      savedTokens: result.savedTokens
+    };
+  }
+  if (currentTokens >= lowTokens) {
+    const nudgeText = buildNudgeText(state, maxMergedLength);
+    if (!nudgeText) {
+      return noop;
+    }
+    logger.info("Batch cleanup tier 1 (low): nudge injected", {
+      currentTokens,
+      lowThreshold: batchCleanup.lowThreshold
+    });
+    return {
+      tier: 1,
+      action: "nudge",
+      mergedCount: 0,
+      savedTokens: 0,
+      nudgeText
+    };
+  }
+  return noop;
+}
+
 // lib/hooks.ts
 var INTERNAL_AGENT_SIGNATURES = [
   "You are a title generator",
@@ -8080,6 +8556,15 @@ var INTERNAL_AGENT_SIGNATURES = [
   "You are an anchored context summarization assistant for coding sessions",
   "Summarize what was done in this conversation"
 ];
+var INTERNAL_AGENT_NAMES = /* @__PURE__ */ new Set(["title", "summary", "compaction"]);
+function isInternalAgentRequest(messages) {
+  const lastUserMessage = getLastUserMessage(messages);
+  if (!lastUserMessage) {
+    return false;
+  }
+  const agent = lastUserMessage.info.agent;
+  return typeof agent === "string" && INTERNAL_AGENT_NAMES.has(agent);
+}
 function createSystemPromptHandler(state, logger, config, prompts) {
   return async (input, output) => {
     if (input.model?.limit?.context) {
@@ -8172,6 +8657,11 @@ function runMajorGC(state, config, logger, messages) {
     void saveSessionState(state, logger);
   }
 }
+function appendBatchCleanupNudge(messages, nudgeText) {
+  const lastUser = getLastUserMessage(messages);
+  if (!lastUser) return;
+  appendToLastTextPart(lastUser, nudgeText);
+}
 function createChatMessageTransformHandler(client, state, logger, config, prompts, hostPermissions) {
   return async (input, output) => {
     const receivedMessages = Array.isArray(output.messages) ? output.messages.length : 0;
@@ -8182,6 +8672,10 @@ function createChatMessageTransformHandler(client, state, logger, config, prompt
         usable: messages.length
       });
     }
+    if (isInternalAgentRequest(messages)) {
+      logger.debug("Skipping message transform for internal agent request");
+      return;
+    }
     await checkSession(client, state, logger, output.messages, config.manualMode.enabled);
     syncCompressPermissionState(state, config, hostPermissions, output.messages);
     if (state.isSubAgent && !config.experimental.allowSubAgents) {
@@ -8198,6 +8692,13 @@ function createChatMessageTransformHandler(client, state, logger, config, prompt
     syncToolCache(state, config, logger, output.messages);
     buildToolIdList(state, output.messages);
     runMajorGC(state, config, logger, output.messages);
+    const batchResult = runBatchCleanup(state, config, logger, output.messages);
+    if (batchResult.tier === 1 && batchResult.nudgeText) {
+      appendBatchCleanupNudge(output.messages, batchResult.nudgeText);
+    }
+    if (batchResult.mergedCount > 0) {
+      void saveSessionState(state, logger);
+    }
     prune(state, logger, config, output.messages);
     assignMessageRefs(state, output.messages);
     await injectExtendedSubAgentResults(
@@ -8616,7 +9117,9 @@ var server = (async (ctx) => {
     tool: {
       ...config.compress.permission !== "deny" && {
         compress: config.compress.mode === "message" ? createCompressMessageTool(compressToolContext) : createCompressRangeTool(compressToolContext),
-        decompress: createDecompressTool(compressToolContext)
+        decompress: createDecompressTool(compressToolContext),
+        mark_block: createMarkBlockTool(compressToolContext),
+        unmark_block: createUnmarkBlockTool(compressToolContext)
       }
     },
     config: async (opencodeConfig) => {
@@ -8632,7 +9135,7 @@ var server = (async (ctx) => {
       }
       const toolsToAdd = [];
       if (config.compress.permission !== "deny" && !config.experimental.allowSubAgents) {
-        toolsToAdd.push("compress", "decompress");
+        toolsToAdd.push("compress", "decompress", "mark_block", "unmark_block");
       }
       if (toolsToAdd.length > 0) {
         const existingPrimaryTools = opencodeConfig.experimental?.primary_tools ?? [];