opencode-acp 1.12.9 → 1.12.10-dev.1

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-dev.1 — Decompress Range Mode + Token Classification + Protected Label Accuracy + Nudge Suppression + Discrete Intervals (PRs #73, #155, #157, #158, #159)
+
+**Problem**: Five issues across decompress ergonomics, token accounting, 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 — misleading the model's compression decisions. (3) The `[PROTECTED: ...]` label listed every tool in a protected message (e.g. `[PROTECTED: grep, skill]`), misleading the model into thinking non-protected tools like `grep` were the reason for protection. (4) When all visible content was protected, the nudge still fired with an empty recommendation list — wasting context and confusing the model. (5) When a nudge was suppressed (filter removed all recommendations), the next-turn check re-evaluated every turn because the baseline never advanced, causing repeated wasted computation.
+
+**Fix**: (1) **PR #73** — Added optional `startId`/`endId` to `decompress` schema; range mode batch-restores every active block whose `effectiveMessageIds` overlaps the resolved range in one call. New pure helper `findActiveBlocksOverlappingMessages` in `decompress-logic.ts`; backward compatible (`blockId` path unchanged). (2) **PR #155** — In `estimateContextComposition` (`lib/messages/inject/utils.ts`), when `toolName === "compress"`, extract `summary` text from `part.state.input.content[].summary` and classify it as `summaryTokens`. Structural overhead remains `toolTokens`. (3) **PR #157** — `buildCompressibleRanges` now only adds tools that actually trigger protection via `isToolNameProtected` or `isFilePathProtected`, mirroring `messageContainsProtectedTool` exactly — the label now shows `[PROTECTED: skill]` only. (4) **PR #158** — Added `allProtected = compressible.length === 0 && protected.length > 0` check; `nothingToCompress = filterSuppressed || allProtected` gates nudge injection so soft nudges are suppressed when there's genuinely nothing to compress (the `protected.length > 0` discriminator preserves the "no refs assigned yet" edge case). (5) **PR #159** — When a nudge is suppressed, advance `lastPerMessageNudgeTokens` to `currentTokens` and clear `lastNudgeShownTokens`, creating discrete 5% check intervals instead of every-turn re-evaluation.
+
+Files: `lib/compress/decompress.ts`, `lib/compress/decompress-logic.ts`, `lib/messages/inject/utils.ts`, `lib/messages/inject/inject.ts`. Tests: 757 pass (11 new for decompress-logic, 5 new for token classification, 4 "all protected" tests fixed to actually exercise the `allProtected` branch, +1 new Scenario A test for compress-after-suppression).
+
 ### 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-dev.1 — Decompress 范围模式 + Token 分类 + Protected 标签精确性 + Nudge 抑制 + 离散间隔（PR #73, #155, #157, #158, #159）
+
+**问题**：五个问题，涉及 decompress 易用性、token 统计和 nudge 质量。（1）`decompress` 需要先 `acp_status` 再逐块 decompress 的循环才能恢复多个压缩块。（2）自 v1.12.9（compress-as-anchor）起，compress 工具的 `summary` 内容被错误分类为 `toolTokens` 而非 `summaryTokens`，导致上下文分布中 tool% 虚高、summary% 虚低 —— 误导模型的压缩决策。（3）`[PROTECTED: ...]` 标签列出受保护消息中的所有工具（例如 `[PROTECTED: grep, skill]`），让模型误以为 `grep` 等非保护工具也是保护原因。（4）当所有可见内容都是受保护内容时，nudge 仍然以空推荐列表注入 —— 浪费上下文且让模型困惑。（5）当 nudge 被抑制（过滤器移除所有推荐）时，下一轮检查每轮都重新评估，因为 baseline 从不前进，导致重复浪费计算。
+
+**修复**：（1）**PR #73** —— 为 `decompress` schema 新增可选 `startId`/`endId`；范围模式批量恢复所有 `effectiveMessageIds` 与解析范围重叠的活跃块，一次调用完成。新纯函数 `findActiveBlocksOverlappingMessages` 在 `decompress-logic.ts`；向后兼容（`blockId` 路径不变）。（2）**PR #155** —— 在 `estimateContextComposition`（`lib/messages/inject/utils.ts`）中，当 `toolName === "compress"` 时，从 `part.state.input.content[].summary` 提取 `summary` 文本并分类为 `summaryTokens`。结构开销仍计为 `toolTokens`。（3）**PR #157** —— `buildCompressibleRanges` 现在只添加通过 `isToolNameProtected` 或 `isFilePathProtected` 实际触发保护的工具，与 `messageContainsProtectedTool` 逻辑完全一致 —— 标签现在只显示 `[PROTECTED: skill]`。（4）**PR #158** —— 新增 `allProtected = compressible.length === 0 && protected.length > 0` 检查；`nothingToCompress = filterSuppressed || allProtected` 门控 nudge 注入，当确实没有可压缩内容时抑制软 nudge（`protected.length > 0` 判别式保留了"尚未分配 ref"的边缘情况）。（5）**PR #159** —— 当 nudge 被抑制时，将 `lastPerMessageNudgeTokens` 前进到 `currentTokens` 并清除 `lastNudgeShownTokens`，创建离散 5% 检查间隔而非每轮重新评估。
+
+文件：`lib/compress/decompress.ts`、`lib/compress/decompress-logic.ts`、`lib/messages/inject/utils.ts`、`lib/messages/inject/inject.ts`。测试：757 通过（decompress-logic 新增 11 个，token 分类新增 5 个，4 个 "all protected" 测试修复为真正触发 `allProtected` 分支，+1 个 Scenario A 测试覆盖抑制后压缩）。
+
 ### 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

@@ -6765,10 +6765,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 +6837,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 +7323,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 +7688,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 +7869,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 +7991,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 +8016,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 +8038,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 +8087,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 +8106,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