opencode-acp 1.12.9 → 1.12.10

package/README.md

@@ -422,6 +422,14 @@ For the complete list with root cause analysis, see the [bug tracker](https://gi
 
 ## Changelog
 
+### v1.12.10 — Batch Compress + Decompress Range Mode + GC Memory-Loss Fix + Token Classification + Nudge Quality (PRs #73, #155, #156, #157, #158, #159, #161)
+
+**Problem**: Seven issues across compression UX, token accounting, GC safety, and nudge quality. (1) `decompress` required a per-block `acp_status` → decompress-per-block loop to restore multiple compressed blocks. (2) Since v1.12.9 (compress-as-anchor), compress tool `summary` content was misclassified as `toolTokens` instead of `summaryTokens`, inflating tool% and deflating summary% in the context breakdown. (3) The `compress` tool only accepted a single range per call — the model had to issue multiple calls to compress unrelated ranges, wasting turns. (4) The `[PROTECTED: ...]` label listed every tool in a protected message instead of only the triggering tools. (5) When all visible content was protected, the nudge still fired with an empty recommendation list. (6) When a nudge was suppressed, the next-turn check re-evaluated every turn. (7) **The GC system was silently destroying model-written summaries**: any block with `summary.length > 6000` chars was force-truncated to 3000 regardless of context pressure (0% pressure triggered truncation), and blocks with high `survivedCount` were auto-deactivated — causing irrecoverable memory loss across hundreds of sessions.
+
+**Fix**: (1) **PR #73** — Added optional `startId`/`endId` to `decompress` schema; range mode batch-restores every active block whose `effectiveMessageIds` overlaps the resolved range. (2) **PR #155** — In `estimateContextComposition`, when `toolName === "compress"`, extract `summary` text and classify it as `summaryTokens`. (3) **PR #156** — The `compress` tool now accepts a `content` array of `{ topic, startId, endId, summary }` entries, allowing the model to compress multiple unrelated ranges in a single call with per-entry topics. (4) **PR #157** — `buildCompressibleRanges` only adds tools that actually trigger protection. (5) **PR #158** — Added `allProtected` check to suppress nudges when there's genuinely nothing to compress. (6) **PR #159** — When a nudge is suppressed, advance `lastPerMessageNudgeTokens` to `currentTokens` for discrete 5% check intervals. (7) **PR #161** — Removed the GC oversized-block override (`hasOversizedBlocks` bypass that truncated at 0% context) and the age-based deactivation loop entirely. Truncation now only fires at `majorGcThresholdPercent` (default 100%). `gc.maxBlockAge` is now a no-op. Aging warning threshold raised from 50% to 90% context to stop misleading the model.
+
+Files: `lib/hooks.ts`, `lib/config.ts`, `lib/prompts/extensions/nudge.ts`, `lib/compress/decompress.ts`, `lib/compress/decompress-logic.ts`, `lib/messages/inject/utils.ts`, `lib/messages/inject/inject.ts`. Tests: 758 pass.
+
 ### v1.12.9 — Compress-as-Anchor (PR #153)
 
 **Problem**: Since v1.12.1, compression summaries were injected as synthetic tool-result messages via a registered `acp_context_recap` tool, while `stripStaleCompressCalls` removed past `compress` tool calls from the API context to avoid duplication. This doubled summary overhead: each block's summary existed both as a synthetic recap message AND in the original (now-stripped) compress call's `summary` parameter. For sessions with many compressions, this "recap overhead" consumed 10–20% of context with no additional information value. The `acp_context_recap` tool description also claimed it "automatically injects" summaries, which was misleading.

package/README.zh-CN.md

@@ -395,6 +395,14 @@ ACP 在首次启动时自动将配置从 `dcp.jsonc` 迁移到 `acp.jsonc`，将
 
 ## 更新日志
 
+### v1.12.10 — 批量压缩 + Decompress 范围模式 + GC 记忆丢失修复 + Token 分类 + Nudge 质量（PR #73, #155, #156, #157, #158, #159, #161）
+
+**问题**：七个问题，涉及压缩 UX、token 统计、GC 安全和 nudge 质量。（1）`decompress` 需要先 `acp_status` 再逐块 decompress 的循环才能恢复多个压缩块。（2）自 v1.12.9 起，compress 工具的 `summary` 内容被错误分类为 `toolTokens` 而非 `summaryTokens`，导致上下文分布中 tool% 虚高、summary% 虚低。（3）`compress` 工具每次调用只能压缩一个范围 —— 模型需要多次调用才能压缩不相关的范围，浪费轮次。（4）`[PROTECTED: ...]` 标签列出受保护消息中的所有工具而非仅触发保护的工具。（5）当所有可见内容都是受保护内容时，nudge 仍然以空推荐列表注入。（6）当 nudge 被抑制时，下一轮检查每轮都重新评估。（7）**GC 系统在静默销毁模型编写的 summary**：任何 `summary.length > 6000` 字符的块在零上下文压力下被强制截断到 3000，且 `survivedCount` 过高的块被自动 deactivate —— 导致数百个会话的不可恢复记忆丢失。
+
+**修复**：（1）**PR #73** —— 为 `decompress` schema 新增可选 `startId`/`endId`；范围模式批量恢复所有 `effectiveMessageIds` 与解析范围重叠的活跃块。（2）**PR #155** —— 在 `estimateContextComposition` 中，当 `toolName === "compress"` 时，提取 `summary` 文本并分类为 `summaryTokens`。（3）**PR #156** —— `compress` 工具现在接受 `content` 数组（`{ topic, startId, endId, summary }`），允许模型在单次调用中压缩多个不相关范围，每个范围有独立 topic。（4）**PR #157** —— `buildCompressibleRanges` 只添加实际触发保护的工具。（5）**PR #158** —— 新增 `allProtected` 检查，当确实没有可压缩内容时抑制 nudge。（6）**PR #159** —— 当 nudge 被抑制时，将 `lastPerMessageNudgeTokens` 前进到 `currentTokens`，创建离散 5% 检查间隔。（7）**PR #161** —— 删除 GC oversized-block 旁路（`hasOversizedBlocks`，在 0% 上下文压力下截断）和 age-based 自动 deactivate 循环。截断现在只在 `majorGcThresholdPercent`（默认 100%）时触发。`gc.maxBlockAge` 变为 no-op。aging warning 门槛从 50% 提高到 90%，不再误导模型。
+
+文件：`lib/hooks.ts`、`lib/config.ts`、`lib/prompts/extensions/nudge.ts`、`lib/compress/decompress.ts`、`lib/compress/decompress-logic.ts`、`lib/messages/inject/utils.ts`、`lib/messages/inject/inject.ts`。测试：758 通过。
+
 ### v1.12.9 — Compress-as-Anchor（PR #153）
 
 **问题**：自 v1.12.1 起，压缩摘要通过注册的 `acp_context_recap` 工具以 synthetic tool-result 消息注入，同时 `stripStaleCompressCalls` 从 API 上下文中移除历史 `compress` 工具调用以避免重复。这导致摘要开销翻倍：每个块的摘要同时存在于 synthetic recap 消息和原始（已移除的）compress 调用的 `summary` 参数中。对于压缩频繁的会话，这个 "recap 开销" 占用 10–20% 上下文却没有额外信息价值。`acp_context_recap` 工具描述也声称它"自动注入"摘要，具有误导性。

package/dist/index.js

@@ -1609,7 +1609,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: {
@@ -2131,20 +2132,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
 
@@ -3969,9 +3977,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 +3993,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 +4198,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 +4266,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 +5089,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
@@ -5578,9 +5592,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 +5609,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 +5643,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 +5785,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 +5810,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;
@@ -6248,7 +6273,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 +6291,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."
       );
     }
   }
@@ -6765,10 +6790,23 @@ function estimateContextComposition(messages, state, protectedTools = [], protec
         const raw = JSON.stringify(part);
         const tokens = Math.round(raw.length / 4);
         msgTotal += tokens;
-        toolTokens += tokens;
-        msgTool += tokens;
         const toolName = part?.tool || "unknown";
-        toolTypeMap.set(toolName, (toolTypeMap.get(toolName) || 0) + tokens);
+        let summaryPartTokens = 0;
+        if (toolName === "compress") {
+          const input = part?.state?.input;
+          if (input?.content && Array.isArray(input.content)) {
+            for (const entry of input.content) {
+              if (typeof entry?.summary === "string") {
+                summaryPartTokens += Math.round(entry.summary.length / 4);
+              }
+            }
+          }
+        }
+        const toolPartTokens = Math.max(0, tokens - summaryPartTokens);
+        toolTokens += toolPartTokens;
+        msgTool += toolPartTokens;
+        summaryTokens += summaryPartTokens;
+        toolTypeMap.set(toolName, (toolTypeMap.get(toolName) || 0) + toolPartTokens);
         if (!msgToolName) msgToolName = toolName;
       }
     }
@@ -6824,7 +6862,20 @@ function buildCompressibleRanges(messages, state, protectedTools = [], protected
         } else if (part.type !== "text" && part.type !== "reasoning") {
           tokens2 += Math.round(JSON.stringify(part).length / 4);
           const toolName = part?.tool;
-          if (toolName) tools.add(toolName);
+          const callID = part?.callID;
+          if (toolName && callID) {
+            if (isToolNameProtected(toolName, protectedTools)) {
+              tools.add(toolName);
+            } else if (protectedFilePatterns.length > 0) {
+              const filePaths = getFilePathsFromParameters(
+                toolName,
+                part?.state?.input
+              );
+              if (isFilePathProtected(filePaths, protectedFilePatterns)) {
+                tools.add(toolName);
+              }
+            }
+          }
         }
       }
       protectedMsgInfo.push({ ref, refNum: rn, tokens: tokens2, tools: [...tools] });
@@ -7297,7 +7348,13 @@ var injectCompressNudges = (state, config, logger, messages, prompts, compressio
     logger.debug(lines.join("\n"));
   }
   const filterSuppressed = contextRanges.compressible.length > 0 && !hasRecommendations;
-  const shouldInject = nudgeAllowed && (!filterSuppressed || emergencyOverride);
+  const allProtected = contextRanges.compressible.length === 0 && contextRanges.protected.length > 0;
+  const nothingToCompress = filterSuppressed || allProtected;
+  const shouldInject = nudgeAllowed && (!nothingToCompress || emergencyOverride);
+  if (nudgeAllowed && nothingToCompress && !emergencyOverride && currentTokens !== void 0) {
+    state.nudges.lastPerMessageNudgeTokens = currentTokens;
+    state.nudges.lastNudgeShownTokens = void 0;
+  }
   state.nudges.shouldInjectThisTurn = shouldInject;
   let tipsText = null;
   if (shouldInject) {
@@ -7656,6 +7713,37 @@ function parseBlockIdArg(arg) {
   const parsed = Number.parseInt(normalized, 10);
   return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
 }
+function resolveDecompressMode(args) {
+  const hasBlockId = typeof args.blockId === "string" && args.blockId.trim() !== "";
+  const hasStartId = typeof args.startId === "string" && args.startId.trim() !== "";
+  const hasEndId = typeof args.endId === "string" && args.endId.trim() !== "";
+  if (hasBlockId && (hasStartId || hasEndId)) {
+    return { ok: false, error: "Cannot specify both blockId and startId/endId. Choose one mode." };
+  }
+  if (!hasBlockId && !(hasStartId && hasEndId)) {
+    return { ok: false, error: "Must specify either blockId, or both startId and endId." };
+  }
+  return { ok: true, mode: hasBlockId ? "block" : "range" };
+}
+function findActiveBlocksOverlappingMessages(messagesState, messageIds) {
+  if (messageIds.size === 0) {
+    return [];
+  }
+  const matched = /* @__PURE__ */ new Map();
+  for (const [blockId, block] of messagesState.blocksById) {
+    if (!block.active) {
+      continue;
+    }
+    const effectiveIds = block.effectiveMessageIds ?? [];
+    for (const msgId of effectiveIds) {
+      if (messageIds.has(msgId)) {
+        matched.set(blockId, block);
+        break;
+      }
+    }
+  }
+  return Array.from(matched.values()).sort((a, b) => a.blockId - b.blockId);
+}
 function findActiveParentBlockId(messagesState, block) {
   const queue = [...block.parentBlockIds];
   const visited = /* @__PURE__ */ new Set();
@@ -7806,12 +7894,120 @@ async function prepareDecompressSession(ctx, toolCtx) {
 async function finalizeDecompressSession(ctx) {
   await saveSessionState(ctx.state, ctx.logger);
 }
-var TOOL_DESCRIPTION = `Restores previously compressed content identified by a block ID.
+function resolveTargets(args, state, rawMessages, logger) {
+  const mode = resolveDecompressMode(args);
+  if (!mode.ok) {
+    return { ok: false, error: `Error: ${mode.error}` };
+  }
+  const messagesState = state.prune.messages;
+  if (mode.mode === "block") {
+    return resolveSingleBlockTarget(messagesState, args.blockId);
+  }
+  return resolveRangeTarget(state, rawMessages, args.startId, args.endId, logger);
+}
+function resolveSingleBlockTarget(messagesState, blockIdArg) {
+  const targetBlockId = parseBlockIdArg(blockIdArg);
+  if (targetBlockId === null) {
+    return {
+      ok: false,
+      error: `Error: Invalid block ID "${blockIdArg}". Use format "b0", "b1", etc.`
+    };
+  }
+  const target = resolveCompressionTarget(messagesState, targetBlockId);
+  if (!target) {
+    return {
+      ok: false,
+      error: `Error: Block ${targetBlockId} does not exist. No compression found with that ID.`
+    };
+  }
+  const activeBlocks = target.blocks.filter((block) => block.active);
+  if (activeBlocks.length === 0) {
+    const activeAncestorBlockId = findActiveAncestorBlockId(messagesState, target);
+    if (activeAncestorBlockId !== null) {
+      return {
+        ok: false,
+        error: `Error: Block ${target.displayId} is nested inside active block ${activeAncestorBlockId}. Decompress block ${activeAncestorBlockId} first.`
+      };
+    }
+    return {
+      ok: false,
+      error: `Error: Block ${target.displayId} is not active. It may have already been decompressed.`
+    };
+  }
+  return { ok: true, targets: [target] };
+}
+function resolveRangeTarget(state, rawMessages, startId, endId, logger) {
+  const searchContext = buildSearchContext(state, rawMessages);
+  let startReference;
+  let endReference;
+  try {
+    const resolved = resolveBoundaryIds(searchContext, state, startId, endId);
+    startReference = resolved.startReference;
+    endReference = resolved.endReference;
+  } catch (err) {
+    return { ok: false, error: `Error: ${err.message}` };
+  }
+  let selection;
+  try {
+    selection = resolveSelection(searchContext, startReference, endReference);
+  } catch (err) {
+    return { ok: false, error: `Error: ${err.message}` };
+  }
+  if (selection.messageIds.length === 0) {
+    return {
+      ok: false,
+      error: `Error: No messages found in range ${startId}..${endId}.`
+    };
+  }
+  const messageIdSet = new Set(selection.messageIds);
+  const messagesState = state.prune.messages;
+  const overlappingBlocks = findActiveBlocksOverlappingMessages(messagesState, messageIdSet);
+  if (overlappingBlocks.length === 0) {
+    return {
+      ok: false,
+      error: `Error: No active compression blocks overlap the range ${startId}..${endId}. The content may already be fully visible. Use acp_status to review block coverage.`
+    };
+  }
+  const targetMap = /* @__PURE__ */ new Map();
+  for (const block of overlappingBlocks) {
+    const target = resolveCompressionTarget(messagesState, block.blockId);
+    if (target) {
+      targetMap.set(target.displayId, target);
+    }
+  }
+  const targets = Array.from(targetMap.values());
+  logger.info("range decompress resolved", {
+    range: `${startId}..${endId}`,
+    matchedBlocks: overlappingBlocks.map((b) => b.blockId),
+    targets: targets.map((t) => t.displayId)
+  });
+  return { ok: true, targets };
+}
+var TOOL_DESCRIPTION = `Restores previously compressed content.
 
-Use this tool when you need exact details from a compressed block that the summary cannot provide.
+Use this tool when you need exact details from compressed content that the summary cannot provide.
 The tool returns a condensed preview of the restored content so you can reason about it immediately.
 
-Argument: blockId \u2014 the block reference to decompress (e.g., "b0", "b2")
+TWO MODES:
+
+1. Block mode (default): decompress a single block by ID.
+   - blockId: block reference to decompress (e.g., "b0", "b2")
+
+2. Range mode: decompress ALL blocks overlapping a message range. Use this to restore
+   content across multiple blocks without calling acp_status + decompress repeatedly.
+   - startId: starting message or block ref (e.g., "m00150")
+   - endId: ending message or block ref (e.g., "m00200")
+
+   Range mode finds every active block whose effectiveMessageIds touch the range and
+   batch-restores them. Partial overlap decompresses the whole block (content cannot be
+   partially restored). Nested blocks are handled automatically.
+
+ARGUMENTS:
+- blockId?: string \u2014 use this OR startId+endId (mutually exclusive)
+- startId?: string \u2014 range start (message or block ref)
+- endId?: string \u2014 range end (message or block ref)
+- toFile?: string \u2014 if provided, writes restored content to this file path (must be under
+  /tmp or ~/.cache/opencode/) instead of inflating context. Block(s) stay compressed.
 
 IMPORTANT:
 - Decompressing inflates context. Check context usage before decompressing.
@@ -7820,10 +8016,22 @@ IMPORTANT:
 - Do NOT call this tool in parallel with compress \u2014 their state mutations may conflict.`;
 function buildSchema3() {
   return {
-    blockId: tool4.schema.string().describe('Block reference to decompress (e.g., "b0", "b2")'),
-    toFile: tool4.schema.string().optional().describe("If provided, writes restored content to this file path instead of inflating context. Block stays compressed. Use read tool to access specific parts. Example: '/tmp/block52.txt'")
+    blockId: tool4.schema.string().optional().describe('Block reference to decompress (e.g., "b0", "b2"). Mutually exclusive with startId/endId.'),
+    startId: tool4.schema.string().optional().describe('Range start: message ref (e.g., "m00150") or block ref (e.g., "b2"). Used with endId.'),
+    endId: tool4.schema.string().optional().describe('Range end: message ref (e.g., "m00200") or block ref (e.g., "b5"). Used with startId.'),
+    toFile: tool4.schema.string().optional().describe("If provided, writes restored content to this file path instead of inflating context. Block stays compressed. Path must be under /tmp or ~/.cache/opencode/. Example: '/tmp/block52.txt'")
   };
 }
+function extractMessageId(m) {
+  return m.id ?? m.messageId ?? "";
+}
+function extractMessageText(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 || "");
+  return `[${role}]
+${content}`;
+}
 function createDecompressTool(ctx) {
   return tool4({
     description: TOOL_DESCRIPTION,
@@ -7833,22 +8041,19 @@ function createDecompressTool(ctx) {
       const contextUsageBefore = ctx.state.modelContextLimit ? Math.round(
         getCurrentTokenUsage(ctx.state, rawMessages) / ctx.state.modelContextLimit * 100
       ) : void 0;
-      const targetBlockId = parseBlockIdArg(args.blockId);
-      if (targetBlockId === null) {
-        return `Error: Invalid block ID "${args.blockId}". Use format "b0", "b1", etc.`;
+      const resolved = resolveTargets(args, ctx.state, rawMessages, ctx.logger);
+      if (!resolved.ok) {
+        return resolved.error;
       }
+      const targets = resolved.targets;
       const messagesState = ctx.state.prune.messages;
-      const target = resolveCompressionTarget(messagesState, targetBlockId);
-      if (!target) {
-        return `Error: Block ${targetBlockId} does not exist. No compression found with that ID.`;
-      }
-      const activeBlocks = target.blocks.filter((block) => block.active);
-      if (activeBlocks.length === 0) {
-        const activeAncestorBlockId = findActiveAncestorBlockId(messagesState, target);
-        if (activeAncestorBlockId !== null) {
-          return `Error: Block ${target.displayId} is nested inside active block ${activeAncestorBlockId}. Decompress block ${activeAncestorBlockId} first.`;
+      const activeBlocks = [];
+      for (const target of targets) {
+        for (const block of target.blocks) {
+          if (block.active) {
+            activeBlocks.push(block);
+          }
         }
-        return `Error: Block ${target.displayId} is not active. It may have already been decompressed.`;
       }
       if (args.toFile) {
         const targetPath = args.toFile;
@@ -7858,35 +8063,33 @@ function createDecompressTool(ctx) {
           os.tmpdir() + "/",
           path.join(os.homedir(), ".cache", "opencode") + "/"
         ];
-        const resolved = path.resolve(targetPath);
+        const resolvedPath = path.resolve(targetPath);
         const isAllowed = allowedDirs.some((dir) => {
-          const rel = path.relative(dir, resolved);
+          const rel = path.relative(dir, resolvedPath);
           return rel === "" || !rel.startsWith("..") && !path.isAbsolute(rel);
         });
         if (!isAllowed) {
           return `Error: toFile path must be under ${os.tmpdir()} or ~/.cache/opencode/. Got: ${targetPath}`;
         }
-        const block = activeBlocks[0];
-        const msgIds = new Set(block.effectiveMessageIds ?? []);
-        const blockMessages = rawMessages.filter((m) => {
-          const id = m.id ?? m.messageId ?? "";
-          return msgIds.has(id);
-        });
-        const lines2 = blockMessages.map((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 || "");
-          return `[${role}]
-${content}`;
-        });
+        const msgIdSet = /* @__PURE__ */ new Set();
+        for (const block of activeBlocks) {
+          for (const id of block.effectiveMessageIds ?? []) {
+            msgIdSet.add(id);
+          }
+        }
+        const blockMessages = rawMessages.filter((m) => msgIdSet.has(extractMessageId(m)));
+        const lines2 = blockMessages.map(extractMessageText);
         const { writeFile: writeFile3 } = await import("fs/promises");
-        const fileContent = lines2.length > 0 ? lines2.join("\n\n---\n\n") : block.summary ?? "(no content available)";
-        await writeFile3(args.toFile, fileContent, "utf-8");
-        return `Block b${target.displayId} content (${blockMessages.length} messages, ${fileContent.length} chars) written to ${args.toFile}. Block stays compressed \u2014 context unchanged. Use read tool to access specific parts.`;
+        const fileContent = lines2.length > 0 ? lines2.join("\n\n---\n\n") : activeBlocks[0]?.summary ?? "(no content available)";
+        await writeFile3(targetPath, fileContent, "utf-8");
+        const displayIds2 = targets.map((t) => `b${t.displayId}`).join(", ");
+        return `Block(s) ${displayIds2} content (${blockMessages.length} messages, ${fileContent.length} chars) written to ${targetPath}. Block(s) stay compressed \u2014 context unchanged. Use read tool to access specific parts.`;
       }
       const activeMessagesBefore = snapshotActiveMessages(messagesState);
       const activeBlockIdsBefore = new Set(messagesState.activeBlockIds);
-      deactivateCompressionTarget(messagesState, target);
+      for (const target of targets) {
+        deactivateCompressionTarget(messagesState, target);
+      }
       syncCompressionBlocks(ctx.state, ctx.logger, rawMessages);
       const { restoredMessageCount, restoredTokens } = computeRestoredMessages(
         messagesState,
@@ -7909,9 +8112,11 @@ ${content}`;
         activeMessagesBefore,
         messagesState
       );
+      const displayIds = targets.map((t) => `b${t.displayId}`).join(", ");
       const lines = [];
+      const headerNoun = targets.length === 1 ? "block" : "blocks";
       lines.push(
-        `Decompressed block b${target.displayId}. Restored ${restoredMessageCount} message(s) (~${formatTokenCount(restoredTokens)}).`
+        `Decompressed ${headerNoun} ${displayIds}. Restored ${restoredMessageCount} message(s) (~${formatTokenCount(restoredTokens)}).`
       );
       if (contextUsageBefore !== void 0 && contextUsageAfter !== void 0) {
         lines.push(`Context usage: ${contextUsageBefore}% \u2192 ${contextUsageAfter}%.`);
@@ -7926,8 +8131,8 @@ ${content}`;
         lines.push(restoredContentPreview);
       }
       ctx.logger.info("Decompress tool completed", {
-        targetBlockId: target.displayId,
-        targetRunId: target.runId,
+        mode: typeof args.startId === "string" ? "range" : "block",
+        targetBlockIds: targets.map((t) => t.displayId),
         restoredMessageCount,
         restoredTokens,
         reactivatedBlockIds
@@ -8594,7 +8799,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 })\`.
@@ -8693,6 +8898,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:
 
@@ -10387,46 +10602,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;