opencode-acp 1.14.13-dev.1 → 1.14.14-dev.1

package/README.md

@@ -435,7 +435,7 @@ For the `compress` tool, `compress.protectedTools` ensures specific tool outputs
 ACP is a drop-in replacement for DCP. To migrate:
 
 1. Remove the old DCP plugin from your `opencode.json`
-2. Install ACP: `opencode plugin install opencode-acp@stable --global`
+2. Install ACP: `opencode plugin opencode-acp@stable --global`
 3. Copy your config: `cp ~/.config/opencode/dcp.jsonc ~/.config/opencode/acp.jsonc`
 4. Copy prompt overrides (if any): `cp -r ~/.config/opencode/dcp-prompts ~/.config/opencode/acp-prompts`
 5. Copy session state (optional, preserves compression blocks): `cp -r ~/.local/share/opencode/storage/plugin/dcp ~/.local/share/opencode/storage/plugin/acp`
@@ -492,6 +492,26 @@ For the complete list with root cause analysis, see the [bug tracker](https://gi
 
 ## Changelog
 
+### v1.14.14-dev.1 — Dev Prerelease (2 PRs since v1.14.13)
+
+Dev prerelease covering two compress-subsystem fixes: the batched-call summary leak (#288) and the batch-compress all-or-nothing abort (#290). Published to the `dev` npm tag for early testing.
+
+**PRs included**:
+- **#288** (via #289) — `hideConsumedCompressCalls` keyed its keep-set on `compressCallId`, which is 1:N under batched compress (one tool call, multiple `content[]` entries share one callId). When a T2 distillation consumed only some siblings, a surviving sibling rescued the whole tool part, permanently leaking the consumed summaries — unreclaimable because compress is a default protected tool. Fix: key visibility per-block (on `startId::endId`) instead of per-callId; for kept batches with mixed liveness, rewrite the surviving tool part's `state.input.content` to drop consumed entries' summaries. All-consumed batches still fully removed. Files: `lib/compress/hide-consumed.ts`. Tests: +3 in `tests/hide-consumed.test.ts` (core regression verified to FAIL pre-fix).
+- **#290** (via #291) — Batch `compress` aborted entirely when any single `content[]` entry contained only already-compressed messages (`Compression range N contains only already-compressed messages`), leaving valid entries unexecuted; the error also omitted which entry/IDs/blocks conflicted, forcing trial-and-error retries. Fix: (A) partial-failure batches — new `identifyPhantomPlans` drops phantom entries and compresses the rest, returning a concise skip notice; (C) detailed diagnostics on the all-phantom throw (entry index + consumed IDs + owning block); (B) a clamp warning when `clampMessageRef` silently shifts a boundary. Extracted `partitionPhantomPlans` + `buildPhantomSkipNotice` pure helpers for testable batch decision logic. `checkPhantomBlock` keeps its exact legacy contract. Files: `lib/compress/{pipeline,range,search,range-utils}.ts`. Tests: +19. Dual-agent reviewed (Oracle + General, both APPROVE).
+
+**Install**: `opencode plugin opencode-acp@dev --global`
+
+### v1.14.13 — Stable Release (3 PRs since v1.14.12)
+
+Stable release with `allowSubAgents` promoted to a top-level config field (default: `true`), plus config documentation updates.
+
+**PRs included**:
+- **#276** — Promote `allowSubAgents` from `experimental` to top-level config field, change default from `false` to `true`. Subagent sessions now get compression by default. Fully backward compatible: old `experimental.allowSubAgents` configs still work (top-level takes priority). Updated all 4 hook sites, schema, config validation, and 6 documentation files. Dual-agent reviewed (Oracle + Explore, both APPROVE).
+- **#280, #281** — Update recommended config in documentation: `maxContextLimit: 70%`, `minContextLimit: 70%`, simplified `protectedTools`.
+
+**Install**: `opencode plugin opencode-acp@stable --global`
+
 ### v1.14.13-dev.1 — Dev Prerelease (1 PR since v1.14.12)
 
 Dev prerelease covering PR #276. Published to `dev` npm tag for early testing.

package/README.zh-CN.md

@@ -389,7 +389,7 @@ ACP 暴露六个可编辑的 prompt：
 ACP 是 DCP 的直接替代品。迁移步骤：
 
 1. 从 `opencode.json` 中移除旧的 DCP 插件
-2. 安装 ACP：`opencode plugin install opencode-acp@stable --global`
+2. 安装 ACP：`opencode plugin opencode-acp@stable --global`
 3. 复制配置：`cp ~/.config/opencode/dcp.jsonc ~/.config/opencode/acp.jsonc`
 4. 复制 prompt 覆盖（如有）：`cp -r ~/.config/opencode/dcp-prompts ~/.config/opencode/acp-prompts`
 5. 复制会话状态（可选，保留压缩块）：`cp -r ~/.local/share/opencode/storage/plugin/dcp ~/.local/share/opencode/storage/plugin/acp`
@@ -446,6 +446,26 @@ ACP 是 DCP 的直接替代品。迁移步骤：
 
 ## 更新日志
 
+### v1.14.14-dev.1 — Dev 预发布版（v1.14.13 以来 2 个 PR）
+
+Dev 预发布版，包含两个压缩子系统修复：批量调用的 summary 泄漏（#288）和批量压缩的全有或全无中断（#290）。发布到 `dev` npm tag 供早期测试。
+
+**包含的 PR**：
+- **#288**（经 #289）— `hideConsumedCompressCalls` 的 keep-set 以 `compressCallId` 为键，在批量压缩下是 1:N 关系（一次工具调用，多个 `content[]` 条目共享一个 callId）。当 T2 蒸馏只消费了部分兄弟块时，存活的兄弟块会救下整个工具 part，永久泄漏已消费的 summary——且因 compress 是默认受保护工具而无法回收。修复：改为按块（`startId::endId`）标记可见性；对混合存活状态的保留批次，重写存活工具 part 的 `state.input.content` 以丢弃已消费条目的 summary。全部消费的批次仍整体移除。文件：`lib/compress/hide-consumed.ts`。测试：`tests/hide-consumed.test.ts` +3（核心回归测试已验证修复前会失败）。
+- **#290**（经 #291）— 批量 `compress` 在任一 `content[]` 条目只含已压缩消息时整体中断（`Compression range N contains only already-compressed messages`），导致有效条目未执行；错误也未说明哪个条目/ID/块冲突，迫使反复试错重试。修复：(A) 部分失败批次——新增 `identifyPhantomPlans` 丢弃 phantom 条目并压缩其余，返回简洁的跳过提示；(C) 全 phantom 抛错时附详细诊断（条目序号 + 已消费 ID + 所属块）；(B) `clampMessageRef` 静默平移边界时发出警告。抽出 `partitionPhantomPlans` + `buildPhantomSkipNotice` 纯函数使批量决策逻辑可测试。`checkPhantomBlock` 保持原有契约不变。文件：`lib/compress/{pipeline,range,search,range-utils}.ts`。测试：+19。双 agent review（Oracle + General，均 APPROVE）。
+
+**安装**：`opencode plugin opencode-acp@dev --global`
+
+### v1.14.13 — 正式版（v1.14.12 以来 3 个 PR）
+
+正式版发布，`allowSubAgents` 从实验性参数提升为正式参数（默认：`true`），并更新了配置文档的推荐设置。
+
+**包含的 PR**：
+- **#276** — 将 `allowSubAgents` 从 `experimental` 提升为顶层配置字段，默认值从 `false` 改为 `true`。子 Agent 会话现在默认启用压缩。完全向后兼容：旧的 `experimental.allowSubAgents` 配置仍然有效（顶层优先级更高）。更新了全部 4 个 hook 调用点、schema、配置验证和 6 个文档文件。双 Agent 审查通过（Oracle + Explore，均 APPROVE）。
+- **#280, #281** — 更新文档中的推荐配置：`maxContextLimit: 70%`、`minContextLimit: 70%`，简化 `protectedTools`。
+
+**安装**：`opencode plugin opencode-acp@stable --global`
+
 ### v1.14.13-dev.1 — Dev 预发布版（v1.14.12 以来 1 个 PR）
 
 Dev 预发布版，包含 PR #276。发布到 `dev` npm tag 供早期测试。

package/dist/index.js

@@ -2983,7 +2983,7 @@ function buildSearchContext(state, rawMessages) {
     summaryByBlockId
   };
 }
-function resolveBoundaryIds(context, state, startId, endId) {
+function resolveBoundaryIds(context, state, startId, endId, logger) {
   const lookup = buildBoundaryLookup(context, state);
   const issues = [];
   const parsedStartId = parseBoundaryId(startId);
@@ -3005,20 +3005,28 @@ function resolveBoundaryIds(context, state, startId, endId) {
   let startReference = lookup.get(parsedStartId.ref);
   let endReference = lookup.get(parsedEndId.ref);
   if (!startReference && parsedStartId.kind === "message") {
+    const requestedRef = parsedStartId.ref;
     const clamped = clampMessageRef(parsedStartId, context, state);
     if (clamped) {
       startReference = lookup.get(clamped.ref);
       if (startReference) {
         parsedStartId.ref = clamped.ref;
+        logger?.warn(
+          `compress startId ${requestedRef} not available \u2014 clamped to ${clamped.ref}`
+        );
       }
     }
   }
   if (!endReference && parsedEndId.kind === "message") {
+    const requestedRef = parsedEndId.ref;
     const clamped = clampMessageRef(parsedEndId, context, state);
     if (clamped) {
       endReference = lookup.get(clamped.ref);
       if (endReference) {
         parsedEndId.ref = clamped.ref;
+        logger?.warn(
+          `compress endId ${requestedRef} not available \u2014 clamped to ${clamped.ref}`
+        );
       }
     }
   }
@@ -3042,6 +3050,7 @@ ${hint}` : body);
     throw new Error("Failed to resolve boundary IDs");
   }
   if (startReference.rawIndex > endReference.rawIndex) {
+    ;
     [startReference, endReference] = [endReference, startReference];
   }
   const adjusted = adjustBoundariesForToolPairs(
@@ -3318,7 +3327,9 @@ function createSearchContextTool(factoryCtx) {
     args: {
       query: tool.schema.string().describe("Search query \u2014 keywords or phrase to find"),
       limit: tool.schema.number().optional().describe("Maximum results to return (default: 10)"),
-      deep: tool.schema.boolean().optional().describe("If true, also search visible (uncompressed) messages. Slower but more thorough (default: false)")
+      deep: tool.schema.boolean().optional().describe(
+        "If true, also search visible (uncompressed) messages. Slower but more thorough (default: false)"
+      )
     },
     async execute(args, toolCtx) {
       const ctx = resolveToolContext(factoryCtx, toolCtx.sessionID);
@@ -3769,7 +3780,7 @@ function validateArgs(args) {
     }
   }
 }
-function resolveRanges(args, searchContext, state) {
+function resolveRanges(args, searchContext, state, logger) {
   return args.content.map((entry, index) => {
     const normalizedEntry = {
       topic: typeof entry.topic === "string" && entry.topic.trim().length > 0 ? entry.topic.trim() : void 0,
@@ -3781,7 +3792,8 @@ function resolveRanges(args, searchContext, state) {
       searchContext,
       state,
       normalizedEntry.startId,
-      normalizedEntry.endId
+      normalizedEntry.endId,
+      logger
     );
     const selection = resolveSelection(searchContext, startReference, endReference);
     return {
@@ -5711,9 +5723,7 @@ async function finalizeSession(ctx, toolCtx, rawMessages, entries, batchTopic) {
       ctx.logger
     );
     for (const failure of qualityReport.failures) {
-      const metrics = Object.fromEntries(
-        failure.result.metrics.map((m) => [m.name, m.value])
-      );
+      const metrics = Object.fromEntries(failure.result.metrics.map((m) => [m.name, m.value]));
       ctx.logger.warn("Compression quality gate FAILED", {
         blockId: failure.blockId,
         algorithm: ctx.config.qualityGate.algorithm,
@@ -5739,9 +5749,12 @@ async function finalizeSession(ctx, toolCtx, rawMessages, entries, batchTopic) {
     contextTokensBefore
   );
 }
-function checkPhantomBlock(state, plans) {
+function identifyPhantomPlans(state, plans) {
+  const phantomIndices = [];
+  const details = [];
   for (let i = 0; i < plans.length; i++) {
     const plan = plans[i];
+    if (!plan) continue;
     const effective = new Set(plan.messageIds);
     for (const consumedId of plan.consumedBlockIds) {
       const block = state.prune.messages.blocksById.get(consumedId);
@@ -5755,23 +5768,62 @@ function checkPhantomBlock(state, plans) {
       const entry = state.prune.messages.byMessageId.get(mid);
       return !entry || entry.activeBlockIds.length === 0;
     });
-    if (!hasNew) {
-      if (plan.consumedBlockIds.length >= 2) {
-        const tiers = new Set(
-          plan.consumedBlockIds.map(
-            (id) => state.prune.messages.blocksById.get(id)?.tier ?? 1
-          )
-        );
-        if (tiers.size === 1) {
-          continue;
-        }
-      }
-      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.`
+    if (hasNew) continue;
+    if (plan.consumedBlockIds.length >= 2) {
+      const tiers = new Set(
+        plan.consumedBlockIds.map(
+          (id) => state.prune.messages.blocksById.get(id)?.tier ?? 1
+        )
       );
+      if (tiers.size === 1) continue;
+    }
+    phantomIndices.push(i);
+    const consumedMessageIds = [];
+    const owningBlockIds = /* @__PURE__ */ new Set();
+    for (const mid of effective) {
+      const entry = state.prune.messages.byMessageId.get(mid);
+      if (entry && entry.activeBlockIds.length > 0) {
+        consumedMessageIds.push(mid);
+        for (const bid of entry.activeBlockIds) owningBlockIds.add(bid);
+      }
     }
+    details.push({
+      index: i,
+      consumedMessageIds: consumedMessageIds.slice(0, 8),
+      owningBlockIds: [...owningBlockIds].sort((a, b) => a - b)
+    });
   }
-  return null;
+  return { phantomIndices, details };
+}
+function buildPhantomErrorMessage(details) {
+  const lines = details.map((d) => {
+    const ids = d.consumedMessageIds.length > 0 ? d.consumedMessageIds.join(", ") : "(empty effective set)";
+    const blocks = d.owningBlockIds.length > 0 ? d.owningBlockIds.map((b) => `b${b}`).join(", ") : "(no active block \u2014 likely a stale ref)";
+    return `  \u2022 Entry ${d.index + 1}: all messages already compressed. Consumed IDs (sample): ${ids}. Owning block(s): ${blocks}.`;
+  });
+  const noun = details.length === 1 ? "One compress entry" : `${details.length} compress entries`;
+  return `${noun} contain only already-compressed messages (0 new direct messages, 0 tokens saved):
+` + lines.join("\n") + `
+Nothing to compress in those entries \u2014 pick ranges with visible, uncompressed content. Use \`acp_status({scope:"uncompressed"})\` to see which ranges are still compressible.`;
+}
+function partitionPhantomPlans(identification, totalPlans) {
+  if (identification.phantomIndices.length === 0) {
+    return { kind: "clean" };
+  }
+  if (identification.phantomIndices.length === totalPlans) {
+    return { kind: "all-phantom", details: identification.details };
+  }
+  return {
+    kind: "partial",
+    dropIndices: identification.phantomIndices,
+    details: identification.details,
+    notice: buildPhantomSkipNotice(identification)
+  };
+}
+function buildPhantomSkipNotice(identification) {
+  const skippedNums = identification.details.map((d) => `#${d.index + 1}`).join(", ");
+  const noun = identification.phantomIndices.length === 1 ? "entry" : "entries";
+  return `Skipped ${identification.phantomIndices.length} already-compressed ${noun} (${skippedNums}) \u2014 they are no-ops; the remaining entries were compressed.`;
 }
 
 // lib/compress/keep-markers.ts
@@ -5944,7 +5996,7 @@ function createCompressRangeTool(factoryCtx) {
         toolCtx,
         `Compress Range: ${input.topic ?? "(batch)"}`
       );
-      const resolvedPlans = resolveRanges(input, searchContext, ctx.state);
+      const resolvedPlans = resolveRanges(input, searchContext, ctx.state, ctx.logger);
       validateNonOverlapping(resolvedPlans);
       const filteredPlans = resolvedPlans.map((plan) => ({
         ...plan,
@@ -5997,7 +6049,7 @@ function createCompressRangeTool(factoryCtx) {
         }
       }
       const notifications = [];
-      const preparedPlans = [];
+      let preparedPlans = [];
       let totalCompressedMessages = 0;
       for (const plan of filteredPlans) {
         const parsedPlaceholders = parseBlockPlaceholders(plan.entry.summary);
@@ -6066,14 +6118,35 @@ function createCompressRangeTool(factoryCtx) {
           consumedBlockIds: mergeConsumedBlockIds
         });
       }
-      const phantomError = checkPhantomBlock(
-        ctx.state,
-        preparedPlans.map((p) => ({
-          messageIds: p.selection.messageIds,
-          consumedBlockIds: p.consumedBlockIds
-        }))
+      const partition = partitionPhantomPlans(
+        identifyPhantomPlans(
+          ctx.state,
+          preparedPlans.map((p) => ({
+            messageIds: p.selection.messageIds,
+            consumedBlockIds: p.consumedBlockIds
+          }))
+        ),
+        preparedPlans.length
       );
-      if (phantomError) throw phantomError;
+      let phantomSkipNotice = null;
+      if (partition.kind === "all-phantom") {
+        ctx.logger.warn("Batch compress: ALL entries phantom", {
+          totalCount: preparedPlans.length,
+          details: partition.details
+        });
+        throw new Error(buildPhantomErrorMessage(partition.details));
+      }
+      if (partition.kind === "partial") {
+        ctx.logger.warn("Batch compress: phantom entries detected", {
+          phantomCount: partition.dropIndices.length,
+          totalCount: preparedPlans.length,
+          phantomIndices: partition.dropIndices,
+          details: partition.details
+        });
+        const dropSet = new Set(partition.dropIndices);
+        preparedPlans = preparedPlans.filter((_, i) => !dropSet.has(i));
+        phantomSkipNotice = partition.notice;
+      }
       const acknowledgeRisk = args.acknowledgeRisk === true;
       const qualityGateRetryPendingBefore = ctx.state.qualityGateRetryPending;
       if (acknowledgeRisk && !ctx.state.qualityGateRetryPending) {
@@ -6149,19 +6222,16 @@ function createCompressRangeTool(factoryCtx) {
             summaryTokens
           });
         }
-        await finalizeSession(
-          ctx,
-          toolCtx,
-          rawMessages,
-          notifications,
-          input.topic
-        );
+        await finalizeSession(ctx, toolCtx, rawMessages, notifications, input.topic);
       } catch (error) {
         restoreCompressionState(ctx.state, snapshot);
         ctx.state.qualityGateRetryPending = qualityGateRetryPendingBefore;
         throw error;
       }
-      return `Compressed ${totalCompressedMessages} messages into ${COMPRESSED_BLOCK_HEADER}.
+      const skippedNote = phantomSkipNotice !== null ? `
+\u26A0\uFE0F ${phantomSkipNotice}
+` : "";
+      return `Compressed ${totalCompressedMessages} messages into ${COMPRESSED_BLOCK_HEADER}.${skippedNote}
 IMPORTANT: This was an automatic context compression. You MUST continue your previous task exactly where you left off. Do NOT ask the user what to do next.
 \u{1F4A1} Tip: Use search_context('keyword') to find compressed content when you need it later.`;
     }
@@ -8283,16 +8353,46 @@ function hasMeaningfulContent(parts) {
 
 // lib/compress/hide-consumed.ts
 var KEEP_LAST_ORPHANED = 2;
+function isLiveBlock(block) {
+  return block.active && !block.deactivatedByUser && !block.deactivatedByUserDeep;
+}
+function rangeKey(startId, endId) {
+  return `${startId}::${endId}`;
+}
+function rewriteCompressInput(part, liveKeys) {
+  if (part.type !== "tool") return null;
+  const state = part.state;
+  const input = state?.input;
+  if (!input || typeof input !== "object") return null;
+  const content = input.content;
+  if (!Array.isArray(content) || content.length === 0) return null;
+  const kept = content.filter((entry) => {
+    if (!entry || typeof entry !== "object") return false;
+    const s = typeof entry.startId === "string" ? entry.startId : "";
+    const e = typeof entry.endId === "string" ? entry.endId : "";
+    return liveKeys.has(rangeKey(s, e));
+  });
+  if (kept.length === content.length || kept.length === 0) return null;
+  return {
+    ...part,
+    state: { ...state, input: { ...input, content: kept } }
+  };
+}
 function hideConsumedCompressCalls(state, messages) {
-  const activeCallIds = /* @__PURE__ */ new Set();
   const allBlockCallIds = /* @__PURE__ */ new Set();
+  const liveRangeKeysByCallId = /* @__PURE__ */ new Map();
+  const activeCallIds = /* @__PURE__ */ new Set();
   for (const block of state.prune.messages.blocksById.values()) {
-    if (block.compressCallId) {
-      allBlockCallIds.add(block.compressCallId);
-      if (block.active && !block.deactivatedByUser && !block.deactivatedByUserDeep) {
-        activeCallIds.add(block.compressCallId);
-      }
+    if (!block.compressCallId) continue;
+    allBlockCallIds.add(block.compressCallId);
+    if (!isLiveBlock(block)) continue;
+    activeCallIds.add(block.compressCallId);
+    let keys = liveRangeKeysByCallId.get(block.compressCallId);
+    if (!keys) {
+      keys = /* @__PURE__ */ new Set();
+      liveRangeKeysByCallId.set(block.compressCallId, keys);
     }
+    keys.add(rangeKey(block.startId, block.endId));
   }
   const lastOrphanedCallIds = [];
   for (let i = messages.length - 1; i >= 0 && lastOrphanedCallIds.length < KEEP_LAST_ORPHANED; i--) {
@@ -8310,15 +8410,28 @@ function hideConsumedCompressCalls(state, messages) {
     const msg = messages[i];
     const parts = Array.isArray(msg.parts) ? msg.parts : [];
     let changed = false;
-    const remaining = parts.filter((p) => {
+    const remaining = [];
+    for (const p of parts) {
       if (p.type === "tool" && p.tool === "compress") {
-        if (p.callID && keepCallIds.has(p.callID)) return true;
-        hidden++;
-        changed = true;
-        return false;
+        if (!p.callID || !keepCallIds.has(p.callID)) {
+          hidden++;
+          changed = true;
+          continue;
+        }
+        const liveKeys = liveRangeKeysByCallId.get(p.callID);
+        if (liveKeys && liveKeys.size > 0) {
+          const rewritten = rewriteCompressInput(p, liveKeys);
+          if (rewritten) {
+            remaining.push(rewritten);
+            changed = true;
+            continue;
+          }
+        }
+        remaining.push(p);
+      } else {
+        remaining.push(p);
       }
-      return true;
-    });
+    }
     if (changed) {
       if (hasMeaningfulContent(remaining)) {
         messages[i] = { ...msg, parts: remaining };
@@ -8835,7 +8948,7 @@ import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
 import { join as join3 } from "path";
 import { existsSync as existsSync3 } from "fs";
 import { homedir as homedir3 } from "os";
-var LOG_VERSION = true ? "1.14.13-dev.1" : "dev";
+var LOG_VERSION = true ? "1.14.14-dev.1" : "dev";
 var Logger = class {
   logDir;
   enabled;