opencode-acp 1.12.7-dev.1 → 1.12.8

package/README.md

@@ -422,13 +422,21 @@ 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)
+### v1.12.8 — Phantom Block Rejection (PR #148)
 
-**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.
+**Problem**: When the model called `compress` on a range that was already covered by an active compression block, `applyCompressionState` still created a new block with `directMessageIds: []`, `compressedTokens: 0`, and `effectiveMessageIds` inherited from the consumed block. The model saw "0 tokens removed" in the notification, retried the same range, and entered a death loop: each phantom block added ~1K of summary overhead while compressing nothing, causing context to *grow* with every compression call (issues #93, #135). User sessions showed 9 consecutive phantom compressions (b12–b20) on the same range before the user manually intervened.
 
-**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.
+**Fix**: Added `checkPhantomBlock()` — a stateless pre-check in `lib/compress/pipeline.ts` that mirrors `applyCompressionState`'s `newlyCompressedMessageIds` computation. For each plan, it builds the effective message set (plan messages + consumed blocks' effective messages) and checks whether ANY message is "new" (i.e., has no active block covering it BEFORE mutation). If no message is new, the plan is a phantom and the entire compress call is rejected with a clear error before any state mutation occurs. Wired into both range-mode (`compress/range.ts`) and message-mode (`compress/message.ts`) after plan preparation, before snapshot. 12 tests cover: empty plans, all-new messages, consumed-block inheritance, GC'd messages (deactivated blocks count as new), and the exact `applyCompressionState` mirroring.
 
-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.
+Files: `lib/compress/pipeline.ts`, `lib/compress/range.ts`, `lib/compress/message.ts`. Tests: `tests/phantom-block.test.ts` (NEW, 12 tests). 725 tests pass.
+
+### 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)
 

package/README.zh-CN.md

@@ -395,13 +395,21 @@ ACP 在首次启动时自动将配置从 `dcp.jsonc` 迁移到 `acp.jsonc`，将
 
 ## 更新日志
 
-### v1.12.7-dev.1 — 智能推荐过滤 + Dangerous 参数 + 部署版本守卫（PR #142, dev）
+### v1.12.8 — 幽灵块拒绝（PR #148）
 
-**问题**：推荐过滤器有三个问题。（1）使用硬编码的 5× 增长阈值（上下文的 25%），太大且容易泄露上下文。（2）过滤器会显示极小的 range（71 tokens）。（3）最后一段总是显示位置标注 "recent"，但压缩它需要显式确认——推荐和阻止矛盾。此外，`dev-deploy.sh` 的部署在 opencode 重启时被 npm 静默覆盖（当 npm 版本比本地新时）。
+**问题**：当模型对已被活跃压缩块覆盖的范围调用 `compress` 时，`applyCompressionState` 仍然创建新块，`directMessageIds: []`、`compressedTokens: 0`、`effectiveMessageIds` 从被消费的块继承。模型在通知中看到"移除 0 tokens"，重试同一范围，进入死亡循环：每个幽灵块增加约 1K 摘要开销却什么都不压缩，导致上下文随每次压缩调用*增长*（issues #93, #135）。用户会话显示同一范围连续 9 次幽灵压缩（b12–b20），直到用户手动干预。
 
-**修复**：（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 最新版之上，防止重启覆盖。
+**修复**：新增 `checkPhantomBlock()` —— `lib/compress/pipeline.ts` 中的无状态前置检查，镜像 `applyCompressionState` 的 `newlyCompressedMessageIds` 计算。对每个计划，构建有效消息集（计划消息 + 被消费块的有效消息），检查是否有任何消息是"新的"（即变异前没有活跃块覆盖它）。如果没有新消息，该计划是幽灵的，整个 compress 调用在任何状态变异前以清晰错误被拒绝。接入 range 模式（`compress/range.ts`）和 message 模式（`compress/message.ts`）的计划准备之后、快照之前。12 个测试覆盖：空计划、全新消息、被消费块继承、GC'd 消息（已停用块算新）、以及与 `applyCompressionState` 的精确镜像。
 
-文件：`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 测试通过。
+文件：`lib/compress/pipeline.ts`、`lib/compress/range.ts`、`lib/compress/message.ts`。测试：`tests/phantom-block.test.ts`（新增，12 个测试）。725 测试通过。
+
+### 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）
 

package/dist/index.js

@@ -4962,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;
 }
@@ -5258,6 +5253,30 @@ function getLastVisibleMessageId(rawMessages, state) {
   }
   return null;
 }
+function checkPhantomBlock(state, plans) {
+  for (let i = 0; i < plans.length; i++) {
+    const plan = plans[i];
+    const effective = new Set(plan.messageIds);
+    for (const consumedId of plan.consumedBlockIds) {
+      const block = state.prune.messages.blocksById.get(consumedId);
+      if (block) {
+        for (const mid of block.effectiveMessageIds) {
+          effective.add(mid);
+        }
+      }
+    }
+    const hasNew = [...effective].some((mid) => {
+      const entry = state.prune.messages.byMessageId.get(mid);
+      return !entry || entry.activeBlockIds.length === 0;
+    });
+    if (!hasNew) {
+      return new Error(
+        `Compression range ${i + 1} contains only already-compressed messages (0 new direct messages, 0 tokens saved). Nothing to compress \u2014 pick a range with visible, uncompressed content. Use \`acp_status({scope:"uncompressed"})\` to see which ranges are still compressible.`
+      );
+    }
+  }
+  return null;
+}
 function checkLastSegmentDangerous(ctx, allPlanMessageIds, rawMessages, dangerous) {
   if (ctx.config.compress.lastSegmentSoftBlock === false) return null;
   const lastVisibleId = getLastVisibleMessageId(rawMessages, ctx.state);
@@ -5496,6 +5515,14 @@ function createCompressMessageTool(ctx) {
           summaryWithTools
         });
       }
+      const phantomError = checkPhantomBlock(
+        ctx.state,
+        preparedPlans.map(({ plan }) => ({
+          messageIds: plan.selection.messageIds,
+          consumedBlockIds: []
+        }))
+      );
+      if (phantomError) throw phantomError;
       const snapshot = snapshotCompressionState(ctx.state);
       const runId = allocateRunId(ctx.state);
       try {
@@ -5714,6 +5741,14 @@ function createCompressRangeTool(ctx) {
           consumedBlockIds: mergeConsumedBlockIds
         });
       }
+      const phantomError = checkPhantomBlock(
+        ctx.state,
+        preparedPlans.map((p) => ({
+          messageIds: p.selection.messageIds,
+          consumedBlockIds: p.consumedBlockIds
+        }))
+      );
+      if (phantomError) throw phantomError;
       const snapshot = snapshotCompressionState(ctx.state);
       const runId = allocateRunId(ctx.state);
       try {
@@ -5842,7 +5877,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);
@@ -5859,7 +5894,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})`,
@@ -6010,10 +6045,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);
@@ -6068,14 +6102,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
           )
         );
@@ -7338,7 +7372,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);
@@ -7353,8 +7386,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);
@@ -7373,36 +7440,6 @@ 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
-      );
-      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 += `
 
@@ -8043,11 +8080,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;
@@ -8338,12 +8372,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.
 
@@ -8371,7 +8402,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}
 
@@ -8382,7 +8413,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)"}"`);
@@ -8726,7 +8757,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
 
@@ -10593,15 +10624,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