opencode-acp 1.12.6 → 1.12.7

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 — Smart Recommendation Filter + Dangerous Parameter + Ref-Leak Fix + Phantom Turn Fix (PRs #142, #147, #150)
+
+**Problem**: Four issues. (1) The recommendation filter used a hardcoded 5× growth threshold for single-message ranges (25% of context), leaked context, showed tiny ranges, and contradicted itself by recommending the last segment while blocking it. (2) Nudge text was injected even when the filter suppressed all ranges — wasting context with an empty recommendation list. (3) Compression block metadata leaked message refs (`m01309–m02150`) via `acp_context_recap` tool input, `acp_status` output, and `recap` tool output — the model copied these into compress calls on already-compressed ranges, creating phantom blocks (#93, #135). (4) `sendIgnoredMessage` during the transform hook persisted an ignored user message that resolved async after the model's response — the loop's `lastUser` detection picked it up → phantom LLM call with no new input → confusion → hallucination → feedback loop ("待命" spam).
+
+**Fix**: (1) Rewrote `filterRecommendedRanges`: last segment excluded if < 2× growth threshold; included with `dangerous: true` flag if ≥ 2×. Stateless `dangerous?: boolean` parameter on compress tool schema replaces state-tracking soft-block. Net −70 lines. (2) Suppress nudge text injection when filter has no recommendations. (3) Stopped leaking message refs: `acp_context_recap` tool input now shows `messages: <count>` instead of `range: "(mN–mN)"`; `acp_status` and `recap` tool output show `N msgs` instead of ref ranges. (4) Debug nudge notification uses `client.tui.showToast()` (transient, non-persisting) + `logger.debug()` (file log) instead of `sendIgnoredMessage` — breaks the phantom-turn feedback loop entirely. `dev-deploy.sh` auto-bumps version above npm 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`, `lib/messages/prune.ts`, `lib/messages/utils.ts`, `lib/compress/recap.ts`, `lib/compress/status.ts`, `lib/ui/notification.ts`, `lib/prompts/system.ts`, `lib/hooks.ts`, `scripts/dev-deploy.sh`. Tests: 725 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 — 智能推荐过滤 + Dangerous 参数 + Ref 泄漏修复 + Phantom Turn 修复（PR #142, #147, #150）
+
+**问题**：四个问题。（1）推荐过滤器使用硬编码的 5× 增长阈值（上下文的 25%），太大且容易泄露上下文；推荐最后一段的同时又阻止它，自相矛盾。（2）过滤器抑制所有 range 后仍然注入 nudge 文本——用空推荐列表浪费上下文。（3）压缩块元数据通过 `acp_context_recap` 工具输入、`acp_status` 输出和 `recap` 工具输出泄漏消息 ref（`m01309–m02150`）——模型复制这些 ref 到已压缩范围的 compress 调用中，产生幽灵块（#93, #135）。（4）`sendIgnoredMessage` 在 transform hook 中持久化 ignored 用户消息，异步在模型回复后完成——loop 的 `lastUser` 检测拾取它 → 无新输入的 phantom LLM 调用 → 困惑 → 幻觉 → 反馈循环（"待命" 刷屏）。
+
+**修复**：（1）重写 `filterRecommendedRanges`：最后一段 < 2× 增长阈值 → 剔除；≥ 2× → 保留并标记 `dangerous: true`。无状态 `dangerous?: boolean` 参数替代状态追踪 soft-block。净减 70 行。（2）过滤器无推荐时抑制 nudge 文本注入。（3）停止泄漏消息 ref：`acp_context_recap` 工具输入改为 `messages: <数量>`；`acp_status` 和 `recap` 工具输出改为 `N msgs`。（4）Debug nudge 通知改用 `client.tui.showToast()`（瞬态，不持久化）+ `logger.debug()`（文件日志），彻底打破 phantom-turn 反馈循环。`dev-deploy.sh` 自动 bump 版本到 npm 最新之上防止重启覆盖。
+
+文件：`lib/messages/inject/utils.ts`、`lib/messages/inject/inject.ts`、`lib/compress/pipeline.ts`、`lib/compress/range.ts`、`lib/compress/message.ts`、`lib/messages/prune.ts`、`lib/messages/utils.ts`、`lib/compress/recap.ts`、`lib/compress/status.ts`、`lib/ui/notification.ts`、`lib/prompts/system.ts`、`lib/hooks.ts`、`scripts/dev-deploy.sh`。测试：725 通过。
+
 ### 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) {
@@ -4960,14 +4962,9 @@ function formatEntryRanges(entries, state) {
   for (const entry of entries) {
     const block = state.prune.messages.blocksById.get(entry.blockId);
     if (!block) continue;
-    const startRef = block.startId;
-    const endRef = block.endId;
-    if (!startRef || !endRef) continue;
-    if (startRef === endRef) {
-      parts.push(`b${entry.blockId}: ${startRef}`);
-    } else {
-      parts.push(`b${entry.blockId}: ${startRef}\u2013${endRef}`);
-    }
+    const count = block.effectiveMessageIds?.length || 0;
+    if (count === 0) continue;
+    parts.push(`b${entry.blockId}: ${count} msg${count !== 1 ? "s" : ""}`);
   }
   return parts.length > 0 ? parts.join(", ") : null;
 }
@@ -5245,6 +5242,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 +5397,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 +5458,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 +5562,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 +5630,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;
@@ -5793,7 +5837,7 @@ var createSyntheticMessage = (baseMessage, content, stableSeed, role = "user") =
   return { info, parts };
 };
 var createSyntheticUserMessage = (baseMessage, content, stableSeed) => createSyntheticMessage(baseMessage, content, stableSeed, "user");
-var createSyntheticToolRecap = (baseMessage, summary, blockId, range, stableSeed) => {
+var createSyntheticToolRecap = (baseMessage, summary, blockId, messageCount, stableSeed) => {
   const baseInfo = baseMessage.info;
   const now = Date.now();
   const messageId = generateStableId("msg_acp_recap", stableSeed);
@@ -5810,7 +5854,7 @@ var createSyntheticToolRecap = (baseMessage, summary, blockId, range, stableSeed
       status: "completed",
       input: {
         blockId,
-        ...range ? { range } : {}
+        ...messageCount !== void 0 ? { messages: messageCount } : {}
       },
       output: summary,
       title: `ACP Context Recap (block ${blockId})`,
@@ -5961,10 +6005,9 @@ var dropEmptyMessages = (messages) => {
 };
 
 // lib/messages/prune.ts
-var computeBlockRange = (startId, endId) => {
-  if (!startId || !endId) return void 0;
-  if (startId === endId) return `(${startId})`;
-  return `(${startId}\u2013${endId})`;
+var computeBlockCoverage = (effectiveMessageIds) => {
+  if (!effectiveMessageIds || effectiveMessageIds.length === 0) return void 0;
+  return effectiveMessageIds.length;
 };
 var prune = (state, logger, config, messages) => {
   filterCompressedRanges(state, logger, config, messages);
@@ -6019,14 +6062,14 @@ var filterCompressedRanges = (state, logger, config, messages) => {
       } else {
         const cleaned = stripStaleMessageRefs(rawSummaryContent);
         const summaryContent = config.compress.mode === "message" ? replaceBlockIdsWithBlocked(cleaned) : cleaned;
-        const blockRange = computeBlockRange(summary.startId, summary.endId);
+        const blockCoverage = computeBlockCoverage(summary.effectiveMessageIds);
         const summarySeed = `${summary.blockId}:${summary.anchorMessageId}`;
         result.push(
           createSyntheticToolRecap(
             msg,
             summaryContent,
             summary.blockId,
-            blockRange,
+            blockCoverage,
             summarySeed
           )
         );
@@ -6945,12 +6988,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 +7073,8 @@ ${lines2.join("\n")}`;
       compressibleCount: r.count,
       protectedTokens: 0,
       protectedCount: 0,
-      protectedTools: []
+      protectedTools: [],
+      dangerous: r.dangerous ?? false
     });
   }
   for (const r of protectedRanges) {
@@ -6988,7 +7091,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 +7108,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 +7116,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}`;
     }
@@ -7227,7 +7332,6 @@ var injectCompressNudges = (state, config, logger, messages, prompts, compressio
   });
   const growthSinceBaseline = currentTokens !== void 0 && growthReference !== void 0 ? currentTokens - growthReference : void 0;
   const nudgeAllowed = emergencyOverride || decision.shouldNudge && growthSinceBaseline !== void 0 && growthSinceBaseline >= growthFloor;
-  state.nudges.shouldInjectThisTurn = nudgeAllowed;
   const effectiveTipsVariant = emergencyOverride ? "maxLimit" : decision.tipsVariant;
   if (nudgeAllowed) {
     applyAnchoredNudges(state, config, messages, prompts, compressionPriorities, currentTokens, modelContextLimit, suffixMessage);
@@ -7242,8 +7346,42 @@ var injectCompressNudges = (state, config, logger, messages, prompts, compressio
     config.compress.protectedTools,
     config.protectedFilePatterns
   );
+  const contextRanges = buildCompressibleRanges(
+    messages,
+    state,
+    config.compress.protectedTools,
+    config.protectedFilePatterns
+  );
+  const recommendedRanges = filterRecommendedRanges(
+    contextRanges.compressible,
+    contextRanges.protected,
+    { modelContextLimit, growthRatio: 0.05, logger }
+  );
+  const hasRecommendations = recommendedRanges.length > 0;
+  if (config.debug && 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 fmt = (n) => n >= 1e3 ? `${(n / 1e3).toFixed(1)}K` : String(n);
+    const lines = [
+      `[ACP Debug] Recommendation filter decision:`,
+      `  Input: ${compressible.length} range(s), ${fmt(compressible.reduce((s, r) => s + r.tokens, 0))} tokens`,
+      `  Thresholds: growth=${fmt(growthThreshold)}, lastSegmentFloor=${fmt(lastSegmentFloor)}`,
+      `  Last segment: ${lastRange.startRef}\u2013${lastRange.endRef} ${fmt(lastRange.tokens)} tokens \u2192 ${lastIncluded ? "included (dangerous)" : "excluded (< floor)"}`,
+      `  Effective compressible: ${fmt(effective)} \u2192 ${suppressed ? "SUPPRESSED (< growth threshold)" : `${recommendedRanges.length} range(s) recommended`}`
+    ];
+    logger.debug(lines.join("\n"));
+  }
+  const filterSuppressed = contextRanges.compressible.length > 0 && !hasRecommendations;
+  const shouldInject = nudgeAllowed && (!filterSuppressed || emergencyOverride);
+  state.nudges.shouldInjectThisTurn = shouldInject;
   let tipsText = null;
-  if (nudgeAllowed) {
+  if (shouldInject) {
     injectContextUsage(suffixMessage, config, currentTokens, modelContextLimit);
     if (suffixMessage && composition.total > 0) {
       const fmt = (n) => n >= 1e3 ? `${(n / 1e3).toFixed(1)}K` : String(n);
@@ -7262,16 +7400,10 @@ Breakdown: ${fmt(composition.toolTokens)} tool (${pct2(composition.toolTokens)}%
         breakdown += `
 \u26A0\uFE0F ${fmt(composition.protectedTokens)} tokens are protected (environment-managed tools) \u2014 not compressible. Effective compressible: ~${fmt(compressibleTokens)}.`;
       }
-      const contextRanges = buildCompressibleRanges(
-        messages,
-        state,
-        config.compress.protectedTools,
-        config.protectedFilePatterns
-      );
-      if (contextRanges.compressible.length > 0) {
+      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: [{...}, {...}]\`).`;
       }
@@ -7908,11 +8040,8 @@ function pct(n, total) {
   return Math.max(1, Math.round(n / total * 100));
 }
 function formatIdRange(block) {
-  const start = (block.startId || "").trim();
-  const end = (block.endId || "").trim();
-  if (!start || !end) return "\u2014";
-  if (start === end) return start;
-  return `${start}\u2013${end}`;
+  const count = block.effectiveMessageIds?.length || 0;
+  return count > 0 ? `${count} msg${count !== 1 ? "s" : ""}` : "\u2014";
 }
 function collectVisibleMessages(rawMessages, ctx) {
   const pruneMap = ctx.state.prune.messages.byMessageId;
@@ -8203,12 +8332,9 @@ function createAcpStatusTool(ctx) {
 
 // lib/compress/recap.ts
 import { tool as tool6 } from "@opencode-ai/plugin";
-function formatRange(startId, endId) {
-  const start = (startId || "").trim();
-  const end = (endId || "").trim();
-  if (!start || !end) return "\u2014";
-  if (start === end) return start;
-  return `${start}\u2013${end}`;
+function formatCoverage(block) {
+  const count = block.effectiveMessageIds?.length || 0;
+  return count > 0 ? `${count} message${count !== 1 ? "s" : ""}` : "\u2014";
 }
 var RECAP_TOOL_DESCRIPTION = `Read-only retrieval of compression block summaries.
 
@@ -8236,7 +8362,7 @@ function createAcpContextRecapTool(ctx) {
         if (!block.active) {
           return `Block b${args.blockId} is inactive (deactivated by GC or nested compression).`;
         }
-        const range = formatRange(block.startId, block.endId);
+        const range = formatCoverage(block);
         return `[Compressed conversation section]
 ${block.summary}
 
@@ -8247,7 +8373,7 @@ ${block.summary}
       for (const id of activeIds) {
         const block = msgState.blocksById.get(id);
         if (!block || !block.active) continue;
-        const range = formatRange(block.startId, block.endId);
+        const range = formatCoverage(block);
         const summaryPreview = block.summary.slice(0, 200);
         lines.push(`
 b${id} | ${range} | "${block.topic || "(none)"}"`);
@@ -8591,7 +8717,7 @@ Periodically, as context grows, the system appends a short status line in a synt
 
 This line is INFORMATION, not an instruction. Seeing it does not mean you should compress. Compress only when one of the WHEN TO COMPRESS conditions actually holds. Between these lines, context is not under additional pressure \u2014 you do not need to seek things to compress.
 
-If you are unsure which \`mNNNNN\` refs are still compressible, or which blocks have already consumed which ranges, call \`acp_status\` first. It returns the visible context breakdown (tool/code/text/summary tokens with largest items) and the compressed block list (block IDs, sizes, message-ID ranges each covers).
+If you are unsure which \`mNNNNN\` refs are still compressible, or which blocks have already consumed which ranges, call \`acp_status\` first. It returns the visible context breakdown (tool/code/text/summary tokens with largest items) and the compressed block list (block IDs, sizes, message counts each covers).
 
 CONTEXT BREAKDOWN
 
@@ -10458,15 +10584,17 @@ function createChatMessageTransformHandler(client, state, logger, config, prompt
       output.messages,
       prompts.getRuntimePrompts(),
       compressionPriorities,
-      config.debug && state.sessionId ? (text) => {
-        sendIgnoredMessage(
-          client,
-          state.sessionId,
-          `[ACP Debug] Nudge injected:
-${text}`,
-          {},
-          logger
-        ).catch(() => {
+      config.debug ? (text) => {
+        logger.debug(`[ACP Debug] Nudge injected:
+${text}`);
+        client.tui.showToast({
+          body: {
+            title: "ACP: Nudge Injected",
+            message: text.slice(0, 500),
+            variant: "info",
+            duration: 5e3
+          }
+        }).catch(() => {
         });
       } : void 0,
       prePruneTokens