opencode-acp 1.9.0 → 1.9.1

package/README.md

@@ -421,6 +421,18 @@ For the complete list with root cause analysis, see the [bug tracker](https://gi
 
 ## Changelog
 
+### v1.9.1 — Disjoint Visible-Range Segments & Nudge Wording (issue #9 root cause)
+
+**Problem**: Even after v1.9.0, the model kept calling `compress` against IDs that a prior block had consumed. The root cause was that the suffix advertised a single contiguous span "first visible → last visible" that **straddled compression holes** — so the model's first guess for an `endId` landed inside an already-summarized range. Separately, the suffix's `(+X tokens since last nudge)` growth line was being misread as an *overflow* warning, triggering panic compressions of large-but-still-needed ranges.
+
+**Fix 1 — disjoint visible-id segments** (PR #57): `injectVisibleIdRange` no longer emits one "first-to-last" span. It builds the actual surviving segments in ascending ref order and truncates to the largest tool-bearing / high-token segments when the count overflows (`compress.maxVisibleSegments`, default `50`, now plumbed through config defaults + merge + validation + schema). The suffix now reads e.g. `[Visible (top 2 of 3 segments, 803 msgs): m00001–m00929, m00944–m00950 | +1 smaller segment (~1.2K tokens, 6 msgs) omitted]`, so the model sees exactly which ranges are compressible and never targets a hole. The formatting logic is extracted into pure, exported, unit-tested functions (`buildVisibleSegments`, `formatVisibleGuidance`).
+
+**Fix 2 — nudge wording** (PR #58): The incremental-compression guidance line (`💡 Compress incrementally: target the ranges above...`) moved to *after* the largest-ranges list and is reworded to stress that **size alone is not a reason to compress** — a large range that is still needed in full must be kept. Soft efficiency nudges (`growth` / `minLimit` variants) are now prefixed with an explicit *"This is an efficiency nudge to compress early and keep context lean — not an overflow warning. A separate, stronger alert will appear if the context is actually full."* so the growth delta isn't mistaken for an overflow alarm. The `maxLimit` path keeps its stronger alert and is intentionally excluded from the efficiency framing.
+
+**Compatibility**: No persisted-state schema changes. New optional config field `compress.maxVisibleSegments` (number, default `50`); old configs keep working.
+
+---
+
 ### v1.9.0 — Visible-Range Guidance & Compression Failure Recovery
 
 **Problem**: On large-context models (1M+) the model repeatedly called `compress(startId=m00930, endId=m00943)` against IDs that a prior block had already consumed. It had no stable view of which `mNNNNN` refs were still compressible, the failure error gave no recovery info, `acp_status` was registered but never mentioned in the prompt, and the suffix nudge reported a bare percentage with no indication of *where* the tokens were actually spent.

package/README.zh-CN.md

@@ -393,6 +393,18 @@ ACP 在首次启动时自动将配置从 `dcp.jsonc` 迁移到 `acp.jsonc`，将
 
 ## 更新日志
 
+### v1.9.1 — 不相交可见范围段 & 提醒措辞修正（issue #9 根因）
+
+**问题**：即便有了 v1.9.0，模型仍反复对已被先前块消费的 ID 调用 `compress`。根因是 suffix 一直广播一条"从首条可见到最后一条可见"的**跨越压缩空洞的连续 span** —— 模型对 `endId` 的第一反应往往是落在已经被摘要的范围里。此外，suffix 的 `(+X tokens since last nudge)` 增长行被误读为**溢出警告**，触发对"大但仍然需要"范围的恐慌性压缩。
+
+**修复 1 — 不连续可见 ID 段**（PR #57）：`injectVisibleIdRange` 不再输出一条"首到尾"span。改为按引用升序构建真正存活的不相交段，并在段数溢出时截断到最大的含工具 / 高 token 段（`compress.maxVisibleSegments`，默认 `50`，已通过 config defaults + merge + validation + schema 全链路接入）。suffix 现在形如 `[Visible (top 2 of 3 segments, 803 msgs): m00001–m00929, m00944–m00950 | +1 smaller segment (~1.2K tokens, 6 msgs) omitted]`，模型能精确看到哪些范围可压缩、绝不会被引导去打空洞。格式化逻辑抽取为纯函数并导出、可单测（`buildVisibleSegments`、`formatVisibleGuidance`）。
+
+**修复 2 — 提醒措辞**（PR #58）：增量压缩指引行（`💡 Compress incrementally: target the ranges above...`）移到 largest-ranges 列表**之后**，并改写以强调**仅凭大小不是压缩理由** —— 仍然需要完整保留的大范围必须保留。软性效率提醒（`growth` / `minLimit` 变体）现在前置一条明确说明 *"This is an efficiency nudge to compress early and keep context lean — not an overflow warning. A separate, stronger alert will appear if the context is actually full."*，使增长量不被误读为溢出警报。`maxLimit` 路径保留更强的告警，并有意排除在效率措辞之外。
+
+**兼容性**：无持久化 state schema 变更。新增可选配置字段 `compress.maxVisibleSegments`（数字，默认 `50`）；旧配置继续工作。
+
+---
+
 ### v1.9.0 — 可见范围引导 & 压缩失败恢复
 
 **问题**：在大上下文模型（1M+）上，模型反复调用 `compress(startId=m00930, endId=m00943)`，而这些 ID 已被之前的块消费。模型对哪些 `mNNNNN` 引用仍可压缩没有稳定视图，失败错误不提供恢复信息，`acp_status` 工具已注册但从未在提示中提及，suffix nudge 只报告一个裸百分比，完全不说明 token 实际花在了哪里。

package/dist/index.js

@@ -903,6 +903,7 @@ var VALID_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "compress.protectUserMessages",
   "compress.maxSummaryLengthHard",
   "compress.minCompressRange",
+  "compress.maxVisibleSegments",
   "gc",
   "gc.algorithm",
   "gc.promotionThreshold",
@@ -1184,6 +1185,20 @@ function validateConfigTypes(config) {
           actual: `${compress.minCompressRange}`
         });
       }
+      if (compress.maxVisibleSegments !== void 0 && typeof compress.maxVisibleSegments !== "number") {
+        errors.push({
+          key: "compress.maxVisibleSegments",
+          expected: "number",
+          actual: typeof compress.maxVisibleSegments
+        });
+      }
+      if (typeof compress.maxVisibleSegments === "number" && compress.maxVisibleSegments < 1) {
+        errors.push({
+          key: "compress.maxVisibleSegments",
+          expected: "positive number (>= 1)",
+          actual: `${compress.maxVisibleSegments}`
+        });
+      }
       if (typeof compress.iterationNudgeThreshold === "number" && compress.iterationNudgeThreshold < 1) {
         errors.push({
           key: "compress.iterationNudgeThreshold",
@@ -1498,7 +1513,8 @@ var defaultConfig = {
     protectTags: false,
     protectUserMessages: false,
     maxSummaryLengthHard: 1e4,
-    minCompressRange: 2e3
+    minCompressRange: 2e3,
+    maxVisibleSegments: 50
   },
   strategies: {
     deduplication: {
@@ -1653,7 +1669,8 @@ function mergeCompress(base, override) {
     protectTags: override.protectTags ?? base.protectTags,
     protectUserMessages: override.protectUserMessages ?? base.protectUserMessages,
     maxSummaryLengthHard: override.maxSummaryLengthHard ?? base.maxSummaryLengthHard,
-    minCompressRange: override.minCompressRange ?? base.minCompressRange
+    minCompressRange: override.minCompressRange ?? base.minCompressRange,
+    maxVisibleSegments: override.maxVisibleSegments ?? base.maxVisibleSegments
   };
 }
 function mergeCommands(base, override) {
@@ -6307,15 +6324,15 @@ var injectCompressNudges = (state, config, logger, messages, prompts, compressio
       const growth = currentTokens !== void 0 && state.nudges.lastPerMessageNudgeTokens !== void 0 ? currentTokens - state.nudges.lastPerMessageNudgeTokens : 0;
       const growthStr = growth > 0 ? ` (+${fmt(growth)} since last nudge)` : "";
       const plainTextTokens = composition.textTokens;
-      let breakdown = `
+      const efficiencyNote = decision.tipsVariant !== "maxLimit" ? `
+This is an efficiency nudge to compress early and keep context lean \u2014 not an overflow warning. A separate, stronger alert will appear if the context is actually full.` : "";
+      let breakdown = `${efficiencyNote}
 Breakdown: ${fmt(composition.toolTokens)} tool (${pct(composition.toolTokens)}%) | ${fmt(composition.summaryTokens)} summaries (${pct(composition.summaryTokens)}%) | ${fmt(composition.codeTokens)} code (${pct(composition.codeTokens)}%) | ${fmt(plainTextTokens)} text (${pct(plainTextTokens)}%)${growthStr}`;
       const topBlocks = Array.from(state.prune.messages.blocksById.values()).filter((b) => b.active).sort((a, b) => b.compressedTokens - a.compressedTokens).slice(0, 3);
       if (topBlocks.length > 0) {
         breakdown += `
 Top blocks: ${topBlocks.map((b) => `b${b.blockId} ${fmt(b.compressedTokens)}\u2192${fmt(b.summaryTokens)}`).join(", ")}`;
       }
-      breakdown += `
-\u{1F4A1} Compress incrementally \u2014 compress the largest consumed ranges first.`;
       if (composition.largestToolRanges.length > 0) {
         breakdown += `
 Largest tool outputs: ${composition.largestToolRanges.map((r) => `${r.ref} (${fmt(r.tokens)})`).join(", ")}`;
@@ -6328,6 +6345,8 @@ Largest code messages: ${composition.largestCodeRanges.map((r) => `${r.ref} (${f
         breakdown += `
 Largest text messages: ${composition.largestMessageRanges.map((r) => `${r.ref} (${fmt(r.tokens)})`).join(", ")}`;
       }
+      breakdown += `
+\u{1F4A1} Compress incrementally: target the ranges above whose content you have already extracted for this step. Size alone is not a reason to compress \u2014 if a large range is still needed in full, keep it.`;
       appendToLastTextPart(suffixMessage, breakdown);
     }
     if (decision.tipsVariant === "maxLimit") {
@@ -6352,7 +6371,7 @@ Largest text messages: ${composition.largestMessageRanges.map((r) => `${r.ref} (
     if (tipsText && suffixMessage) {
       appendToLastTextPart(suffixMessage, tipsText);
     }
-    injectVisibleIdRange(state, messages, suffixMessage);
+    injectVisibleIdRange(state, config, messages, suffixMessage);
   }
   if (toolOutputReminder && suffixMessage) {
     if (!decision.shouldNudge) {
@@ -6393,22 +6412,78 @@ function injectContextUsage(target, config, currentTokens, modelContextLimit) {
   }
   target.parts.push(createSyntheticTextPart(target, usageTag));
 }
-function injectVisibleIdRange(state, messages, target) {
+function refNumber(ref) {
+  const n = parseInt(ref.slice(1), 10);
+  return Number.isNaN(n) ? -1 : n;
+}
+function buildVisibleSegments(state, messages) {
+  const refInfo = /* @__PURE__ */ new Map();
+  for (const msg of messages) {
+    const ref = state.messageIds.byRawId.get(msg.info.id);
+    if (!ref) continue;
+    let tokens = 0;
+    let hasTool = false;
+    for (const part of msg.parts || []) {
+      if (part.type === "text" && typeof part.text === "string") {
+        tokens += Math.round(part.text.length / 4);
+      } else if (part.type !== "text" && part.type !== "reasoning") {
+        tokens += Math.round(JSON.stringify(part).length / 4);
+        hasTool = true;
+      }
+    }
+    refInfo.set(ref, { tokens, hasTool });
+  }
+  if (refInfo.size === 0) return [];
+  const refs = Array.from(refInfo.keys()).sort((a, b) => refNumber(a) - refNumber(b));
+  const segments = [];
+  let cur = null;
+  let prevNum = -2;
+  for (const ref of refs) {
+    const num = refNumber(ref);
+    const info = refInfo.get(ref);
+    if (cur && num === prevNum + 1) {
+      cur.endRef = ref;
+      cur.count++;
+      cur.tokens += info.tokens;
+      if (info.hasTool) cur.hasTool = true;
+    } else {
+      if (cur) segments.push(cur);
+      cur = { startRef: ref, endRef: ref, count: 1, tokens: info.tokens, hasTool: info.hasTool };
+    }
+    prevNum = num;
+  }
+  if (cur) segments.push(cur);
+  return segments;
+}
+function formatSegment(seg) {
+  return seg.startRef === seg.endRef ? seg.startRef : `${seg.startRef}\u2013${seg.endRef}`;
+}
+function formatVisibleGuidance(segments, maxSegs) {
+  if (segments.length === 0) return "";
+  const totalMsgs = segments.reduce((s, seg) => s + seg.count, 0);
+  const totalSegs = segments.length;
+  const fmt = (n) => n >= 1e3 ? `${(n / 1e3).toFixed(1)}K` : String(n);
+  if (totalSegs <= maxSegs) {
+    return `[Visible: ${segments.map(formatSegment).join(", ")} (${totalMsgs} msg${totalMsgs === 1 ? "" : "s"}, ${totalSegs} segment${totalSegs === 1 ? "" : "s"})]`;
+  }
+  const keepSet = new Set(
+    [...segments].sort((a, b) => {
+      if (a.hasTool !== b.hasTool) return a.hasTool ? -1 : 1;
+      return b.tokens - a.tokens;
+    }).slice(0, maxSegs)
+  );
+  const shown = segments.filter((s) => keepSet.has(s));
+  const omitted = segments.filter((s) => !keepSet.has(s));
+  const omittedTokens = omitted.reduce((sum, s) => sum + s.tokens, 0);
+  const omittedMsgs = omitted.reduce((sum, s) => sum + s.count, 0);
+  return `[Visible (top ${shown.length} of ${totalSegs} segments, ${totalMsgs} msgs): ${shown.map(formatSegment).join(", ")} | +${omitted.length} smaller segment${omitted.length === 1 ? "" : "s"} (~${fmt(omittedTokens)} tokens, ${omittedMsgs} msg${omittedMsgs === 1 ? "" : "s"}) omitted]`;
+}
+function injectVisibleIdRange(state, config, messages, target) {
   if (!target) return;
-  const visibleRefs = [];
-  for (const message of messages) {
-    const ref = state.messageIds.byRawId.get(message.info.id);
-    if (ref) {
-      visibleRefs.push(ref);
-    }
-  }
-  if (visibleRefs.length === 0) return;
-  visibleRefs.sort();
-  const first = visibleRefs[0];
-  const last = visibleRefs[visibleRefs.length - 1];
-  const rangeTag = `
-
-[Visible messages: ${first} to ${last} (${visibleRefs.length} messages)]`;
+  const segments = buildVisibleSegments(state, messages);
+  if (segments.length === 0) return;
+  const maxSegs = config.compress?.maxVisibleSegments ?? 50;
+  const rangeTag = "\n\n" + formatVisibleGuidance(segments, maxSegs);
   for (const part of target.parts) {
     if (part.type === "text") {
       appendToTextPart(part, rangeTag);