opencode-acp 1.18.2-pr.448.192 → 1.18.2-pr.449.193

package/dist/index.js

@@ -6384,24 +6384,32 @@ function computeStats(plan) {
   const retentionPct = originalTokens > 0 ? (summaryChars / (originalTokens * 4) * 100).toFixed(2) : "?";
   return { originalTokens, summaryChars, ratio, retentionPct };
 }
-function buildQualityRejectionError(plan, result) {
+function coreReason(reason) {
+  if (!reason) return "unknown";
+  const candidates = [reason.indexOf(":"), reason.indexOf("(")].filter((i) => i >= 0);
+  const cut = Math.min(...candidates);
+  return (cut > 0 ? reason.slice(0, cut) : reason).trim() || "unknown";
+}
+function buildQualityRejectionError(plan, result, logger) {
   const stats = computeStats(plan);
-  const metrics = [
-    `Reason: ${result.reason || "unknown"}`,
-    `Original: ~${stats.originalTokens} tokens`,
-    `Summary: ${stats.summaryChars} chars`,
-    `Ratio: ${stats.ratio}:1`,
-    `Retention: ${stats.retentionPct}%`,
-    `Gate layer: ${result.layer ?? "unknown"}`,
-    `rougeF1: ${formatMetric(result, "rougeF1")}`,
-    `top20Recall: ${formatMetric(result, "top20Recall")}`
-  ];
+  logger?.warn("quality gate rejected compression", {
+    range: `${plan.startId}\u2013${plan.endId}`,
+    reason: result.reason || "unknown",
+    layer: result.layer ?? "unknown",
+    originalTokens: stats.originalTokens,
+    summaryChars: stats.summaryChars,
+    ratio: stats.ratio,
+    retentionPct: stats.retentionPct,
+    rougeF1: formatMetric(result, "rougeF1"),
+    top20Recall: formatMetric(result, "top20Recall")
+  });
   const message = `\u26A0\uFE0F COMPRESSION REJECTED \u2014 QUALITY GATE FAILURE
 
 Range: ${plan.startId}\u2013${plan.endId}
-${metrics.join("\n")}
+Reason: ${coreReason(result.reason)}
+Original: ~${stats.originalTokens} tokens \xB7 Summary: ${stats.summaryChars} chars \xB7 Retention: ${stats.retentionPct}%
 
-Retry: rewrite a more complete summary that preserves critical details (file paths, decisions, exact values, errors) and call compress again on the same range \u2014 the gate re-evaluates automatically. Full compression rules are already in your system prompt. If you are confident the summary is correct despite the metrics, add "acknowledgeRisk": true to bypass the quality gate on your next compress call.`;
+Retry: write a more complete summary preserving critical details (file paths, decisions, exact values, errors), then call compress again on the same range. If you are confident the summary is adequate despite the metrics, pass "acknowledgeRisk": true.`;
   return new Error(message);
 }
 
@@ -8063,7 +8071,8 @@ function createCompressRangeTool(factoryCtx) {
                 messageIds: plan.selection.messageIds,
                 messageTokenById: plan.selection.messageTokenById
               },
-              result
+              result,
+              ctx.logger
             );
           }
         }
@@ -9823,6 +9832,81 @@ function computeRestoredMessages(messagesState, activeMessagesBefore) {
   }
   return { restoredMessageCount, restoredTokens };
 }
+function collectRequiredDecompressMessageIds(messagesState, targets, options = {}) {
+  const targetBlockIds = /* @__PURE__ */ new Set();
+  for (const target of targets) {
+    for (const block of target.blocks) {
+      targetBlockIds.add(block.blockId);
+    }
+  }
+  if (targetBlockIds.size === 0) {
+    return [];
+  }
+  const consumedClosure = /* @__PURE__ */ new Set();
+  const queue = [];
+  for (const target of targets) {
+    for (const block of target.blocks) {
+      for (const id of block.consumedBlockIds ?? []) {
+        if (!consumedClosure.has(id)) {
+          queue.push(id);
+        }
+      }
+    }
+  }
+  while (queue.length > 0) {
+    const id = queue.shift();
+    if (consumedClosure.has(id)) continue;
+    consumedClosure.add(id);
+    const consumed = messagesState.blocksById.get(id);
+    if (consumed) {
+      for (const nested of consumed.consumedBlockIds ?? []) {
+        if (!consumedClosure.has(nested)) {
+          queue.push(nested);
+        }
+      }
+    }
+  }
+  let shieldedMessageIds = null;
+  if (!options.full) {
+    shieldedMessageIds = /* @__PURE__ */ new Set();
+    for (const id of consumedClosure) {
+      const block = messagesState.blocksById.get(id);
+      if (!block || block.deactivatedByUser || block.deactivatedByUserDeep) continue;
+      for (const messageId of block.effectiveMessageIds ?? []) {
+        shieldedMessageIds.add(messageId);
+      }
+    }
+  }
+  const required = [];
+  for (const [messageId, entry] of messagesState.byMessageId) {
+    if (entry.activeBlockIds.length === 0) continue;
+    let exclusivelyCoveredByTargets = true;
+    for (const blockId of entry.activeBlockIds) {
+      if (!targetBlockIds.has(blockId)) {
+        exclusivelyCoveredByTargets = false;
+        break;
+      }
+    }
+    if (!exclusivelyCoveredByTargets) continue;
+    if (shieldedMessageIds?.has(messageId)) continue;
+    required.push(messageId);
+  }
+  required.sort();
+  return required;
+}
+function checkDecompressSourceAvailability(messagesState, targets, options, presentInHistory) {
+  const requiredMessageIds = collectRequiredDecompressMessageIds(messagesState, targets, options);
+  const available = [];
+  const missing = [];
+  for (const messageId of requiredMessageIds) {
+    if (presentInHistory.has(messageId)) {
+      available.push(messageId);
+    } else {
+      missing.push(messageId);
+    }
+  }
+  return { requiredMessageIds, availableMessageIds: available, missingMessageIds: missing };
+}
 function computeReactivatedBlockIds(messagesState, activeBlockIdsBefore) {
   return Array.from(messagesState.activeBlockIds).filter((blockId) => !activeBlockIdsBefore.has(blockId)).sort((a, b) => a - b);
 }
@@ -10120,6 +10204,28 @@ function createDecompressTool(factoryCtx) {
         const displayIds2 = targets.map((t) => `b${t.displayId}`).join(", ");
         return `Block(s) ${displayIds2} content (${sourceNote}, ${fileContent.length} chars) written to ${targetPath}. Block(s) stay compressed \u2014 context unchanged. Use read tool to access specific parts.`;
       }
+      const availability = checkDecompressSourceAvailability(
+        messagesState,
+        targets,
+        { full: args.full === true },
+        new Set(rawMessages.map((m) => m.info.id))
+      );
+      if (availability.missingMessageIds.length > 0) {
+        const displayIds2 = targets.map((t) => `b${t.displayId}`).join(", ");
+        const missingRefs = availability.missingMessageIds.map(
+          (id) => ctx.state.messageIds.byRawId.get(id) ?? id
+        );
+        const shownRefs = missingRefs.slice(0, 10).join(", ");
+        const extraCount = missingRefs.length - Math.min(missingRefs.length, 10);
+        ctx.logger.warn("Decompress aborted: source messages missing from host history", {
+          targetDisplayIds: displayIds2,
+          full: args.full === true,
+          requiredCount: availability.requiredMessageIds.length,
+          missingCount: availability.missingMessageIds.length,
+          missingRefs
+        });
+        return `Error: Cannot decompress ${displayIds2}: ${availability.missingMessageIds.length} of ${availability.requiredMessageIds.length} source message(s) are no longer present in session history (removed by native compaction or external deletion). Missing: ${shownRefs}` + (extraCount > 0 ? ` (+${extraCount} more)` : "") + `. Block(s) stay compressed \u2014 the summary remains available and nothing was changed. This is a missing-source condition, not a transient fetch failure.`;
+      }
       const activeMessagesBefore = snapshotActiveMessages(messagesState);
       const activeBlockIdsBefore = new Set(messagesState.activeBlockIds);
       for (const target of targets) {
@@ -10931,7 +11037,7 @@ import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
 import { join as join4 } from "path";
 import { existsSync as existsSync4 } from "fs";
 import { homedir as homedir3 } from "os";
-var LOG_VERSION = true ? "1.18.2-pr.448.192" : "dev";
+var LOG_VERSION = true ? "1.18.2-pr.449.193" : "dev";
 var LEVEL_RANK = {
   debug: 10,
   info: 20,
@@ -13649,7 +13755,7 @@ var server = (async (ctx) => {
   }
   const logger = new Logger(config.debug, config.debug ? "debug" : config.logLevel);
   logger.info("ACP plugin initialized", {
-    version: true ? "1.18.2-pr.448.192" : "dev",
+    version: true ? "1.18.2-pr.449.193" : "dev",
     workspace: ctx.directory,
     logLevel: logger.level,
     debug: config.debug,