opencode-acp 1.12.6 → 1.12.7-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.7-dev.1 — Smart Recommendation Filter + Dangerous Parameter + Deploy Version Guard (PR #142, dev)
+
+**Problem**: The recommendation filter had three issues. (1) It used a hardcoded 5× growth threshold for single-message ranges, which was too large (25% of context) and could leak context. (2) The filter showed tiny ranges (71 tokens) alongside meaningful ones. (3) The last segment was always shown with a position-based "recent" annotation, but compressing it requires explicit opt-in — a contradiction between recommending and blocking. Additionally, `dev-deploy.sh` deploys were silently overwritten by npm on opencode restart when the npm version was newer than the local version.
+
+**Fix**: (1) Rewrote `filterRecommendedRanges` with a single coherent design: last segment excluded if < 2× growth threshold; included with `dangerous: true` flag if ≥ 2×. Gate: "effective compressible" = non-last-segment tokens + max(0, last-segment − 2× floor); suppress all if < growth threshold. (2) Protected ranges no longer affect filtering logic. (3) Replaced state-tracking soft-block with stateless `dangerous?: boolean` parameter on the compress tool schema — model must explicitly opt-in to compress the tail. Net −70 lines. (4) Added debug filter decision logging via `sendIgnoredMessage` (model-invisible, user-visible when `debug: true`). (5) `dev-deploy.sh` now queries `npm view` and auto-bumps the deployed version above npm's latest to prevent overwrite on restart.
+
+Files: `lib/messages/inject/utils.ts`, `lib/messages/inject/inject.ts`, `lib/compress/pipeline.ts`, `lib/compress/range.ts`, `lib/compress/message.ts`, `scripts/dev-deploy.sh`. Tests: `tests/smart-nudge-gating.test.ts` (rewritten, 17 tests), `tests/soft-block.test.ts` (5 tests), `tests/inject.test.ts` (updated). 711 tests pass.
+
 ### v1.12.6 — Stale contextLimitAnchors Fix (PR #143)
 
 **Problem**: `contextLimitAnchors` were populated when `overMaxLimit=true` but only cleared on a compress tool call in the current turn (`currentTurnHasCompress`). If context dropped below `maxLimit` via another mechanism (OpenCode compaction, external message deletion), the anchors stayed stale → `applyAnchoredNudges` kept injecting the "⚠️ Context limit reached" template at low context levels (as low as 10% usage).

package/README.zh-CN.md

@@ -395,6 +395,14 @@ ACP 在首次启动时自动将配置从 `dcp.jsonc` 迁移到 `acp.jsonc`，将
 
 ## 更新日志
 
+### v1.12.7-dev.1 — 智能推荐过滤 + Dangerous 参数 + 部署版本守卫（PR #142, dev）
+
+**问题**：推荐过滤器有三个问题。（1）使用硬编码的 5× 增长阈值（上下文的 25%），太大且容易泄露上下文。（2）过滤器会显示极小的 range（71 tokens）。（3）最后一段总是显示位置标注 "recent"，但压缩它需要显式确认——推荐和阻止矛盾。此外，`dev-deploy.sh` 的部署在 opencode 重启时被 npm 静默覆盖（当 npm 版本比本地新时）。
+
+**修复**：（1）重写 `filterRecommendedRanges`：最后一段 < 2× 增长阈值 → 剔除；≥ 2× → 保留并标记 `dangerous: true`。门槛："有效可压缩" = 非最后段 + max(0, 最后段 − 2× 阈值)；< 增长阈值则全部抑制。（2）受保护内容不再影响过滤逻辑。（3）用无状态的 `dangerous?: boolean` 参数替换状态追踪 soft-block——模型必须显式 opt-in 才能压缩尾部。净减 70 行。（4）通过 `sendIgnoredMessage` 注入过滤决策调试信息（模型不可见，`debug: true` 时用户可见）。（5）`dev-deploy.sh` 查询 `npm view` 并自动将部署版本 bump 到 npm 最新版之上，防止重启覆盖。
+
+文件：`lib/messages/inject/utils.ts`、`lib/messages/inject/inject.ts`、`lib/compress/pipeline.ts`、`lib/compress/range.ts`、`lib/compress/message.ts`、`scripts/dev-deploy.sh`。测试：`tests/smart-nudge-gating.test.ts`（重写，17 测试）、`tests/soft-block.test.ts`（5 测试）、`tests/inject.test.ts`（更新）。711 测试通过。
+
 ### v1.12.6 — Stale contextLimitAnchors 修复（PR #143）
 
 **问题**：`contextLimitAnchors` 仅在 `overMaxLimit=true` 时添加，但只在当前 turn 有 compress 调用时 (`currentTurnHasCompress`) 才清除。如果上下文通过其他机制（OpenCode compaction、外部消息删除）降到 `maxLimit` 以下，anchors 保持 stale → `applyAnchoredNudges` 持续注入 "⚠️ Context limit reached" 模板，即使实际上下文很低（低至 10%）。

package/dist/index.js

@@ -1592,7 +1592,8 @@ var defaultConfig = {
     minNudgeGrowthFloor: 5e3,
     emergencyThresholdPercent: "98%",
     maxVisibleSegments: 50,
-    keepEmbedMaxChars: 2e3
+    keepEmbedMaxChars: 2e3,
+    lastSegmentSoftBlock: true
   },
   strategies: {
     deduplication: {
@@ -1753,7 +1754,8 @@ function mergeCompress(base, override) {
     minNudgeGrowthFloor: override.minNudgeGrowthFloor ?? base.minNudgeGrowthFloor,
     emergencyThresholdPercent: override.emergencyThresholdPercent ?? base.emergencyThresholdPercent,
     maxVisibleSegments: override.maxVisibleSegments ?? base.maxVisibleSegments,
-    keepEmbedMaxChars: override.keepEmbedMaxChars ?? base.keepEmbedMaxChars
+    keepEmbedMaxChars: override.keepEmbedMaxChars ?? base.keepEmbedMaxChars,
+    lastSegmentSoftBlock: override.lastSegmentSoftBlock ?? base.lastSegmentSoftBlock
   };
 }
 function mergeCommands(base, override) {
@@ -5245,6 +5247,31 @@ async function finalizeSession(ctx, toolCtx, rawMessages, entries, batchTopic) {
     contextTokensBefore
   );
 }
+function getLastVisibleMessageId(rawMessages, state) {
+  for (let i = rawMessages.length - 1; i >= 0; i--) {
+    const msg = rawMessages[i];
+    const id = msg?.info?.id;
+    if (!id || typeof id !== "string") continue;
+    if (isSyntheticMessage(msg)) continue;
+    if (state.prune.messages.byMessageId.has(id)) continue;
+    return id;
+  }
+  return null;
+}
+function checkLastSegmentDangerous(ctx, allPlanMessageIds, rawMessages, dangerous) {
+  if (ctx.config.compress.lastSegmentSoftBlock === false) return null;
+  const lastVisibleId = getLastVisibleMessageId(rawMessages, ctx.state);
+  if (!lastVisibleId) return null;
+  const coversLast = allPlanMessageIds.some((ids) => ids.includes(lastVisibleId));
+  if (!coversLast) return null;
+  if (dangerous) return null;
+  return new Error(
+    `This range includes the most recent message (${lastVisibleId}), which is likely still needed for the current task step.
+
+If you are certain this content is genuinely consumed and must be compressed, re-issue the call with \`dangerous: true\`.
+Otherwise, compress older ranges that do not include the tail of the conversation.`
+  );
+}
 
 // lib/compress/keep-markers.ts
 var KEEP_REGEX = /\[\[KEEP:(m\d+)\]\]/g;
@@ -5375,6 +5402,9 @@ function buildSchema(maxSummaryLengthHard) {
     ).describe("Batch of individual message summaries to create in one tool call"),
     summaryMaxChars: tool2.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.`
+    ),
+    dangerous: tool2.schema.boolean().optional().describe(
+      "Set to true ONLY when you are certain the most recent message(s) must be compressed. Required when a range includes the tail of the conversation."
     )
   };
 }
@@ -5433,6 +5463,14 @@ function createCompressMessageTool(ctx) {
           );
         }
       }
+      const dangerous = args.dangerous === true;
+      const lastSegmentError = checkLastSegmentDangerous(
+        ctx,
+        plans.map((p) => p.selection.messageIds),
+        rawMessages,
+        dangerous
+      );
+      if (lastSegmentError) throw lastSegmentError;
       const notifications = [];
       const preparedPlans = [];
       for (const plan of plans) {
@@ -5529,6 +5567,9 @@ function buildSchema2(maxSummaryLengthHard) {
     ),
     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.`
+    ),
+    dangerous: tool3.schema.boolean().optional().describe(
+      "Set to true ONLY when you are certain the most recent message(s) must be compressed. Required when a range includes the tail of the conversation."
     )
   };
 }
@@ -5594,6 +5635,14 @@ function createCompressRangeTool(ctx) {
           );
         }
       }
+      const dangerous = args.dangerous === true;
+      const lastSegmentError = checkLastSegmentDangerous(
+        ctx,
+        filteredPlans.map((p) => p.selection.messageIds),
+        rawMessages,
+        dangerous
+      );
+      if (lastSegmentError) throw lastSegmentError;
       const notifications = [];
       const preparedPlans = [];
       let totalCompressedMessages = 0;
@@ -6945,12 +6994,71 @@ function buildCompressibleRanges(messages, state, protectedTools = [], protected
     protected: protectedGroups
   };
 }
+function filterRecommendedRanges(compressible, _protectedRanges, options) {
+  const { modelContextLimit, growthRatio, logger } = options;
+  const log = logger?.debug.bind(logger);
+  if (!modelContextLimit || modelContextLimit <= 0) {
+    log?.("filterRecommendedRanges: modelContextLimit unknown, passthrough", {
+      inputCount: compressible.length
+    });
+    if (compressible.length === 0) return [];
+    const passthrough = [...compressible];
+    passthrough[passthrough.length - 1] = {
+      ...passthrough[passthrough.length - 1],
+      dangerous: true
+    };
+    return passthrough;
+  }
+  if (compressible.length === 0) {
+    log?.("filterRecommendedRanges: no compressible ranges, returning empty");
+    return [];
+  }
+  const growthThreshold = modelContextLimit * growthRatio;
+  const lastSegmentFloor = growthThreshold * 2;
+  const lastIndex = compressible.length - 1;
+  const lastRange = compressible[lastIndex];
+  const lastSegmentIncluded = lastRange.tokens >= lastSegmentFloor;
+  let effectiveCompressible = 0;
+  const result = [];
+  for (let i = 0; i < compressible.length; i++) {
+    const r = compressible[i];
+    if (i === lastIndex) {
+      const excess = Math.max(0, r.tokens - lastSegmentFloor);
+      effectiveCompressible += excess;
+      if (lastSegmentIncluded) {
+        result.push({ ...r, dangerous: true });
+      }
+    } else {
+      effectiveCompressible += r.tokens;
+      result.push(r);
+    }
+  }
+  const suppressed = effectiveCompressible < growthThreshold;
+  log?.("filterRecommendedRanges: decision", {
+    inputRanges: compressible.length,
+    inputTokens: compressible.reduce((s, r) => s + r.tokens, 0),
+    growthThreshold,
+    lastSegmentFloor,
+    lastSegment: {
+      ref: `${lastRange.startRef}\u2013${lastRange.endRef}`,
+      tokens: lastRange.tokens,
+      included: lastSegmentIncluded
+    },
+    effectiveCompressible,
+    suppressed,
+    outputRanges: suppressed ? 0 : result.length
+  });
+  if (suppressed) {
+    return [];
+  }
+  return result;
+}
 function formatCompressibleRanges(ranges, protectedRanges) {
   const fmt = (n) => n >= 1e3 ? `${(n / 1e3).toFixed(1)}K` : String(n);
   if (!protectedRanges || protectedRanges.length === 0) {
     if (ranges.length === 0) return "";
-    const lines2 = ranges.map((r, i) => {
-      const suffix = i === ranges.length - 1 ? "  (recent \u2014 may still be in active use)" : "";
+    const lines2 = ranges.map((r) => {
+      const suffix = r.dangerous ? "  \u26A0\uFE0F NOT recommended unless you are certain. If you MUST compress this, pass `dangerous: true`." : "";
       return `  ${r.startRef}\u2013${r.endRef}  ${r.count} msgs  ${fmt(r.tokens)} [tool ${r.toolPct}% | text ${r.textPct}%]${suffix}`;
     });
     return `Compressible ranges (oldest first):
@@ -6971,7 +7079,8 @@ ${lines2.join("\n")}`;
       compressibleCount: r.count,
       protectedTokens: 0,
       protectedCount: 0,
-      protectedTools: []
+      protectedTools: [],
+      dangerous: r.dangerous ?? false
     });
   }
   for (const r of protectedRanges) {
@@ -6988,7 +7097,8 @@ ${lines2.join("\n")}`;
       compressibleCount: 0,
       protectedTokens: r.tokens,
       protectedCount: r.count,
-      protectedTools: [...r.tools]
+      protectedTools: [...r.tools],
+      dangerous: false
     });
   }
   entries.sort((a, b) => a.startNum - b.startNum);
@@ -7004,6 +7114,7 @@ ${lines2.join("\n")}`;
       last.compressibleCount += entry.compressibleCount;
       last.protectedTokens += entry.protectedTokens;
       last.protectedCount += entry.protectedCount;
+      if (entry.dangerous) last.dangerous = true;
       for (const t of entry.protectedTools) {
         if (!last.protectedTools.includes(t)) last.protectedTools.push(t);
       }
@@ -7011,8 +7122,8 @@ ${lines2.join("\n")}`;
       merged.push({ ...entry });
     }
   }
-  const lines = merged.map((e, i) => {
-    const suffix = i === merged.length - 1 && e.compressibleTokens > 0 ? "  (recent \u2014 may still be in active use)" : "";
+  const lines = merged.map((e) => {
+    const suffix = e.dangerous && e.compressibleTokens > 0 ? "  \u26A0\uFE0F NOT recommended unless you are certain. If you MUST compress this, pass `dangerous: true`." : "";
     if (e.protectedTokens > 0 && e.compressibleTokens === 0) {
       return `  ${e.startRef}\u2013${e.endRef}  ${e.count} msgs  ${fmt(e.tokens)} [PROTECTED: ${e.protectedTools.join(", ")} \u2014 not compressible]${suffix}`;
     }
@@ -7268,10 +7379,34 @@ Breakdown: ${fmt(composition.toolTokens)} tool (${pct2(composition.toolTokens)}%
         config.compress.protectedTools,
         config.protectedFilePatterns
       );
-      if (contextRanges.compressible.length > 0) {
+      const recommendedRanges = filterRecommendedRanges(
+        contextRanges.compressible,
+        contextRanges.protected,
+        { modelContextLimit, growthRatio: 0.05, logger }
+      );
+      if (debugNotify && contextRanges.compressible.length > 0 && modelContextLimit) {
+        const growthThreshold = modelContextLimit * 0.05;
+        const lastSegmentFloor = growthThreshold * 2;
+        const compressible = contextRanges.compressible;
+        const lastRange = compressible[compressible.length - 1];
+        const lastIncluded = lastRange.tokens >= lastSegmentFloor;
+        const nonLastTokens = compressible.slice(0, -1).reduce((s, r) => s + r.tokens, 0);
+        const effective = nonLastTokens + Math.max(0, lastRange.tokens - lastSegmentFloor);
+        const suppressed = effective < growthThreshold;
+        const fmt2 = (n) => n >= 1e3 ? `${(n / 1e3).toFixed(1)}K` : String(n);
+        const lines = [
+          `[ACP Debug] Recommendation filter decision:`,
+          `  Input: ${compressible.length} range(s), ${fmt2(compressible.reduce((s, r) => s + r.tokens, 0))} tokens`,
+          `  Thresholds: growth=${fmt2(growthThreshold)}, lastSegmentFloor=${fmt2(lastSegmentFloor)}`,
+          `  Last segment: ${lastRange.startRef}\u2013${lastRange.endRef} ${fmt2(lastRange.tokens)} tokens \u2192 ${lastIncluded ? "included (dangerous)" : "excluded (< floor)"}`,
+          `  Effective compressible: ${fmt2(effective)} \u2192 ${suppressed ? "SUPPRESSED (< growth threshold)" : `${recommendedRanges.length} range(s) recommended`}`
+        ];
+        debugNotify(lines.join("\n"));
+      }
+      if (recommendedRanges.length > 0) {
         breakdown += `
 
-${formatCompressibleRanges(contextRanges.compressible, contextRanges.protected)}`;
+${formatCompressibleRanges(recommendedRanges, contextRanges.protected)}`;
         breakdown += `
 \u{1F4A1} Compress all ranges in one call (pass multiple content entries: \`content: [{...}, {...}]\`).`;
       }