opencode-acp 1.11.4 → 1.12.0

package/dist/index.js

@@ -905,6 +905,7 @@ var VALID_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "compress.maxSummaryLengthHard",
   "compress.minCompressRange",
   "compress.maxVisibleSegments",
+  "compress.keepEmbedMaxChars",
   "gc",
   "gc.algorithm",
   "gc.promotionThreshold",
@@ -1200,6 +1201,20 @@ function validateConfigTypes(config) {
           actual: `${compress.maxVisibleSegments}`
         });
       }
+      if (compress.keepEmbedMaxChars !== void 0 && typeof compress.keepEmbedMaxChars !== "number") {
+        errors.push({
+          key: "compress.keepEmbedMaxChars",
+          expected: "number",
+          actual: typeof compress.keepEmbedMaxChars
+        });
+      }
+      if (typeof compress.keepEmbedMaxChars === "number" && compress.keepEmbedMaxChars < 100) {
+        errors.push({
+          key: "compress.keepEmbedMaxChars",
+          expected: "positive number (>= 100)",
+          actual: `${compress.keepEmbedMaxChars}`
+        });
+      }
       if (typeof compress.iterationNudgeThreshold === "number" && compress.iterationNudgeThreshold < 1) {
         errors.push({
           key: "compress.iterationNudgeThreshold",
@@ -1515,7 +1530,8 @@ var defaultConfig = {
     protectUserMessages: false,
     maxSummaryLengthHard: 1e4,
     minCompressRange: 2e3,
-    maxVisibleSegments: 50
+    maxVisibleSegments: 50,
+    keepEmbedMaxChars: 2e3
   },
   strategies: {
     deduplication: {
@@ -1672,7 +1688,8 @@ function mergeCompress(base, override) {
     protectUserMessages: override.protectUserMessages ?? base.protectUserMessages,
     maxSummaryLengthHard: override.maxSummaryLengthHard ?? base.maxSummaryLengthHard,
     minCompressRange: override.minCompressRange ?? base.minCompressRange,
-    maxVisibleSegments: override.maxVisibleSegments ?? base.maxVisibleSegments
+    maxVisibleSegments: override.maxVisibleSegments ?? base.maxVisibleSegments,
+    keepEmbedMaxChars: override.keepEmbedMaxChars ?? base.keepEmbedMaxChars
   };
 }
 function mergeCommands(base, override) {
@@ -3645,8 +3662,10 @@ function resetOnCompaction(state) {
     iterationNudgeAnchors: /* @__PURE__ */ new Set(),
     lastPerMessageNudgeTurn: 0,
     lastPerMessageNudgeTokens: void 0,
+    lastNudgeShownTokens: void 0,
     lastToolOutputNudgeTokens: void 0,
-    shouldInjectThisTurn: void 0
+    shouldInjectThisTurn: void 0,
+    compressBaselineSet: false
   };
   state.messageIds = {
     byRawId: /* @__PURE__ */ new Map(),
@@ -3719,7 +3738,9 @@ async function saveSessionState(sessionState, logger, sessionName) {
       iterationNudgeAnchors: Array.from(sessionState.nudges.iterationNudgeAnchors),
       lastPerMessageNudgeTurn: sessionState.nudges.lastPerMessageNudgeTurn ?? 0,
       lastPerMessageNudgeTokens: sessionState.nudges.lastPerMessageNudgeTokens,
-      lastToolOutputNudgeTokens: sessionState.nudges.lastToolOutputNudgeTokens
+      lastNudgeShownTokens: sessionState.nudges.lastNudgeShownTokens,
+      lastToolOutputNudgeTokens: sessionState.nudges.lastToolOutputNudgeTokens,
+      compressBaselineSet: sessionState.nudges.compressBaselineSet
     },
     stats: sessionState.stats,
     lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
@@ -4291,8 +4312,10 @@ function createSessionState() {
       iterationNudgeAnchors: /* @__PURE__ */ new Set(),
       lastPerMessageNudgeTurn: 0,
       lastPerMessageNudgeTokens: void 0,
+      lastNudgeShownTokens: void 0,
       lastToolOutputNudgeTokens: void 0,
-      shouldInjectThisTurn: void 0
+      shouldInjectThisTurn: void 0,
+      compressBaselineSet: false
     },
     stats: {
       pruneTokenCounter: 0,
@@ -4332,8 +4355,10 @@ function resetSessionState(state) {
     iterationNudgeAnchors: /* @__PURE__ */ new Set(),
     lastPerMessageNudgeTurn: 0,
     lastPerMessageNudgeTokens: void 0,
+    lastNudgeShownTokens: void 0,
     lastToolOutputNudgeTokens: void 0,
-    shouldInjectThisTurn: void 0
+    shouldInjectThisTurn: void 0,
+    compressBaselineSet: false
   };
   state.stats = {
     pruneTokenCounter: 0,
@@ -4386,7 +4411,9 @@ async function ensureSessionInitialized(client, state, sessionId, logger, messag
   );
   state.nudges.lastPerMessageNudgeTurn = persisted.nudges.lastPerMessageNudgeTurn ?? 0;
   state.nudges.lastPerMessageNudgeTokens = persisted.nudges.lastPerMessageNudgeTokens;
+  state.nudges.lastNudgeShownTokens = persisted.nudges.lastNudgeShownTokens;
   state.nudges.lastToolOutputNudgeTokens = persisted.nudges.lastToolOutputNudgeTokens;
+  state.nudges.compressBaselineSet = persisted.nudges.compressBaselineSet ?? false;
   state.stats = {
     pruneTokenCounter: persisted.stats?.pruneTokenCounter || 0,
     totalPruneTokens: persisted.stats?.totalPruneTokens || 0
@@ -4869,6 +4896,7 @@ function formatPrunedItemsList(pruneToolIds, toolMetadata, workingDirectory) {
 var TOAST_BODY_MAX_LINES = 12;
 var TOAST_SUMMARY_MAX_CHARS = 600;
 var NOTIFICATION_SUMMARY_MAX_CHARS = 1500;
+var DETAILED_NOTIFICATION_SUMMARY_MAX_CHARS = 1e4;
 function truncateToastBody(body, maxLines = TOAST_BODY_MAX_LINES) {
   const lines = body.split("\n");
   if (lines.length <= maxLines) {
@@ -4889,18 +4917,24 @@ function buildCompressionSummary(entries, state) {
   if (entries.length === 1) {
     return entries[0]?.summary ?? "";
   }
+  const perEntryMax = Math.floor(NOTIFICATION_SUMMARY_MAX_CHARS / entries.length);
   let result = "";
-  for (const entry of entries) {
+  let shown = 0;
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
     const topic = state.prune.messages.blocksById.get(entry.blockId)?.topic ?? "(unknown topic)";
+    const truncated = entry.summary.length > perEntryMax ? entry.summary.slice(0, perEntryMax - 3) + "..." : entry.summary;
     const section = `### ${topic}
-${entry.summary}`;
+${truncated}`;
     if (result.length + section.length + 2 > NOTIFICATION_SUMMARY_MAX_CHARS) {
-      result += `
-
-... and ${entries.length - entries.indexOf(entry)} more`;
+      const remaining = entries.length - shown;
+      if (remaining > 0) {
+        result += (result ? "\n\n" : "") + `... and ${remaining} more`;
+      }
       break;
     }
     result += (result ? "\n\n" : "") + section;
+    shown++;
   }
   return result;
 }
@@ -5011,7 +5045,8 @@ ${progressBar}`;
       message += ` compressed`;
     }
     if (config.compress.showCompression) {
-      const displaySummary = summary.length > NOTIFICATION_SUMMARY_MAX_CHARS ? truncateToastSummary(summary, NOTIFICATION_SUMMARY_MAX_CHARS) : summary;
+      const maxChars = config.pruneNotification === "detailed" ? DETAILED_NOTIFICATION_SUMMARY_MAX_CHARS : NOTIFICATION_SUMMARY_MAX_CHARS;
+      const displaySummary = summary.length > maxChars ? truncateToastSummary(summary, maxChars) : summary;
       message += `
 \u2192 Compression (~${summaryTokensStr}): ${displaySummary}`;
     }
@@ -5265,6 +5300,113 @@ function createCompressMessageTool(ctx) {
 
 // lib/compress/range.ts
 import { tool as tool3 } from "@opencode-ai/plugin";
+
+// lib/compress/keep-markers.ts
+var KEEP_REGEX = /\[\[KEEP:(m\d+)\]\]/g;
+var REF_REGEX = /\[\[REF:(m\d+)\|([^\]]+)\]\]/g;
+function resolveKeepMarkers(summary, messages, state, config) {
+  const msgByRef = /* @__PURE__ */ new Map();
+  for (const msg of messages) {
+    const ref = state.messageIds.byRawId.get(msg.info.id);
+    if (ref) msgByRef.set(ref, msg);
+  }
+  const maxChars = config.compress?.keepEmbedMaxChars ?? 2e3;
+  let expandedCount = 0;
+  let refCount = 0;
+  const unresolvedRefs = [];
+  const expanded = summary.replace(KEEP_REGEX, (match, ref) => {
+    const msg = msgByRef.get(ref);
+    if (!msg) {
+      unresolvedRefs.push(ref);
+      return match;
+    }
+    expandedCount++;
+    return formatKeptMessage(msg, ref, maxChars);
+  }).replace(REF_REGEX, (_match, ref, desc) => {
+    const msg = msgByRef.get(ref);
+    if (!msg) {
+      unresolvedRefs.push(ref);
+      return _match;
+    }
+    refCount++;
+    return `[\u2192 ${ref}: ${desc.trim()}]`;
+  });
+  return { summary: expanded, expandedCount, refCount, unresolvedRefs };
+}
+function formatKeptMessage(msg, ref, maxChars) {
+  const formatted = formatByType(msg);
+  const truncated = truncate2(formatted, maxChars);
+  return `
+--- [${ref}: ${labelForMessage(msg)}] ---
+${truncated}
+--- end ---
+`;
+}
+function formatByType(msg) {
+  for (const part of msg.parts || []) {
+    if (part.type === "text" && typeof part.text === "string") {
+      return part.text;
+    }
+    if (part.type === "tool") {
+      const tool7 = part.tool || "unknown";
+      const state = part.state || {};
+      const input = state.input || {};
+      const output = state.output || "";
+      switch (tool7) {
+        case "bash":
+        case "interactive_bash": {
+          const cmd = typeof input === "string" ? input : input.command || JSON.stringify(input);
+          return `$ ${cmd}
+${output}`;
+        }
+        case "read": {
+          const fp = input.filePath || input.path || input.file || "";
+          return output;
+        }
+        case "write":
+        case "edit": {
+          const fp = input.filePath || input.path || "";
+          const content = input.content || input.newString || "";
+          return `${fp}:
+${content}`;
+        }
+        case "reply": {
+          return output || "[reply posted]";
+        }
+        case "grep":
+        case "glob": {
+          return output;
+        }
+        default: {
+          if (output && typeof output === "string" && output.length > 0) {
+            return output;
+          }
+          const compact = JSON.stringify({ tool: tool7, input }, null, 0);
+          return compact.length > 500 ? compact.slice(0, 500) + "..." : compact;
+        }
+      }
+    }
+  }
+  return "[empty message]";
+}
+function labelForMessage(msg) {
+  for (const part of msg.parts || []) {
+    if (part.type === "tool") {
+      const tool7 = part.tool || "unknown";
+      const input = part.state?.input || {};
+      const fp = input.filePath || input.path || input.command || "";
+      return fp ? `${tool7}: ${String(fp).slice(0, 60)}` : tool7;
+    }
+  }
+  return msg.info.role === "user" ? "user" : "text";
+}
+function truncate2(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  return text.slice(0, maxChars) + `
+... [truncated, ${text.length} chars total]`;
+}
+
+// lib/compress/range.ts
 function buildSchema2(maxSummaryLengthHard) {
   return {
     topic: tool3.schema.string().describe("Short label (3-5 words) for display - e.g., 'Auth System Exploration'"),
@@ -5420,6 +5562,13 @@ function createCompressRangeTool(ctx) {
       const runId = allocateRunId(ctx.state);
       for (const preparedPlan of preparedPlans) {
         const blockId = allocateBlockId(ctx.state);
+        const keepResult = resolveKeepMarkers(
+          preparedPlan.finalSummary,
+          rawMessages,
+          ctx.state,
+          ctx.config
+        );
+        preparedPlan.finalSummary = keepResult.summary;
         const storedSummary = wrapCompressedSummary(blockId, preparedPlan.finalSummary);
         const summaryTokens = countTokens2(storedSummary);
         const applied = applyCompressionState(
@@ -6358,8 +6507,7 @@ function buildContextUsageGuidance(config, currentTokens, modelContextLimit) {
   const formatK = (n) => n >= 1e3 ? `${(n / 1e3).toFixed(1)}K` : String(n);
   return `
 
-Context: ${formatK(currentTokens)} tokens.
-All compression serves the primary task, but be frugal. Context capacity is precious. Save context by compressing consumed outputs, not by avoiding tools. Compress by need, not by percentage.`;
+Context: ${formatK(currentTokens)} tokens.`;
 }
 function applyAnchoredNudges(state, config, messages, prompts, compressionPriorities, currentTokens, modelContextLimit, suffixMessage) {
   const turnNudgeAnchors = collectTurnNudgeAnchors2(state, config, messages);
@@ -6527,8 +6675,78 @@ function estimateContextComposition(messages, state) {
     toolTypeBreakdown
   };
 }
+function buildCompressibleRanges(messages, state) {
+  const msgInfo = [];
+  for (const msg of messages) {
+    if (isSyntheticMessage(msg)) continue;
+    const ref = state.messageIds.byRawId.get(msg.info.id);
+    if (!ref) continue;
+    let tokens = 0;
+    let isTool = false;
+    for (const part of msg.parts || []) {
+      if (part.type === "text" && typeof part.text === "string") {
+        tokens += Math.round(part.text.length / 4);
+      } else if (part.type !== "text" && part.type !== "reasoning") {
+        tokens += Math.round(JSON.stringify(part).length / 4);
+        isTool = true;
+      }
+    }
+    const refNum = parseInt(ref.slice(1), 10);
+    msgInfo.push({ ref, refNum, tokens, isTool, isUser: msg.info.role === "user" });
+  }
+  if (msgInfo.length === 0) return [];
+  const groups = [];
+  let cur = null;
+  let prevRefNum = -2;
+  for (const info of msgInfo) {
+    const hasGap = info.refNum > prevRefNum + 1;
+    if (cur && (info.isUser && cur.count >= 3 || hasGap)) {
+      groups.push(cur);
+      cur = null;
+    }
+    prevRefNum = info.refNum;
+    if (!cur) {
+      cur = {
+        startRef: info.ref,
+        endRef: info.ref,
+        count: 1,
+        tokens: info.tokens,
+        toolPct: info.isTool ? 100 : 0,
+        textPct: info.isTool ? 0 : 100
+      };
+    } else {
+      cur.endRef = info.ref;
+      cur.count++;
+      cur.tokens += info.tokens;
+      if (info.isTool) {
+        cur.toolPct = Math.round((cur.toolPct * (cur.count - 1) + 100) / cur.count);
+      } else {
+        cur.toolPct = Math.round(cur.toolPct * (cur.count - 1) / cur.count);
+      }
+      cur.textPct = 100 - cur.toolPct;
+    }
+  }
+  if (cur) groups.push(cur);
+  return groups.filter((g) => g.tokens > 0);
+}
+function formatCompressibleRanges(ranges) {
+  if (ranges.length === 0) return "";
+  const fmt = (n) => n >= 1e3 ? `${(n / 1e3).toFixed(1)}K` : String(n);
+  const lines = ranges.map((r, i) => {
+    const suffix = i === ranges.length - 1 ? "  (recent \u2014 may still be in active use)" : "";
+    return `  ${r.startRef}\u2013${r.endRef}  ${r.count} msgs  ${fmt(r.tokens)} [tool ${r.toolPct}% | text ${r.textPct}%]${suffix}`;
+  });
+  return `Compressible ranges (oldest first):
+${lines.join("\n")}`;
+}
 
 // lib/prompts/compression-rules.ts
+var COMPRESS_PHILOSOPHY = `Compression Philosophy:
+- All compression serves the primary task, but be frugal.
+- Context capacity is precious. Save context by compressing consumed outputs, not by avoiding tools.
+- Compress by need, not by percentage.
+- Work from summaries, not raw tool outputs. All listed ranges (user prompts, tool outputs, code, logs, exploration, intermediate steps) should be compressed to summary format \u2014 the ONLY exceptions are protected content, content the current step is actively using, or critical content you cannot reconstruct.
+- Curate summaries like a well-structured document. User prompts, compressed tool outputs, code, logs, or skill-call intermediate results that are critically important should be preserved \u2014 not by exempting them from compression, but by embedding them in the summary via [[KEEP:mNNNNN]] (auto-expanded verbatim) and [[REF:mNNNNN|description]] (compact link).`;
 var HOW_TO_COMPRESS_RULES = `HOW TO COMPRESS
 
 When you call \`compress\`, the summary you write becomes the only record of the replaced conversation. Make it self-contained and complete: every user request, experiment purpose, and work task in the range must be accurately captured. A later reader (or you, after decompressing) should be able to continue the task WITHOUT needing the original.
@@ -6557,6 +6775,8 @@ DROP \u2014 extract the signal, discard the vessel:
 
 For each significant item you DROP (scripts, reports, large analyses, long tool outputs), add a one-line CONTENT description of what it covers \u2014 not where it lives. Bad: "probe script at /path/probe_kvnet.py". Good: "probe_kvnet.py: tests n-gram baseline, generation quality, long-range dependency, position sensitivity, op pipeline, QUERY attention." This lets a later decompress target the right block by relevance, not by guessing locations.
 
+KEEP MARKERS: \`[[KEEP:mNNNNN]]\` expands original message content into the summary (truncated to a max length). Do NOT use KEEP for verbose command output, diagnostic scripts, log dumps, or any content whose value is in the conclusion rather than the raw output \u2014 summarize these or use \`[[REF:mNNNNN|desc]]\` instead.
+
 PRIORITY \u2014 when the summary must be compact, preserve in this order:
 1. User's overall goal, goal evolution, intent, and hard constraints (losing these changes the task).
 2. Decisions and rationale.
@@ -6575,7 +6795,7 @@ function createSuffixMessage(messages) {
   messages.push(synthetic);
   return synthetic;
 }
-var injectCompressNudges = (state, config, logger, messages, prompts, compressionPriorities) => {
+var injectCompressNudges = (state, config, logger, messages, prompts, compressionPriorities, debugNotify) => {
   if (compressPermission(state, config) === "deny") {
     return;
   }
@@ -6592,18 +6812,29 @@ var injectCompressNudges = (state, config, logger, messages, prompts, compressio
     modelId,
     messages
   );
-  if (lastAssistantMessage && messageHasCompress(lastAssistantMessage)) {
+  const lastUserIdx = messages.findLastIndex(
+    (m) => m.info.role === "user" && !isIgnoredUserMessage(m)
+  );
+  const currentTurnStart = lastUserIdx >= 0 ? lastUserIdx + 1 : 0;
+  const currentTurnHasCompress = messages.slice(currentTurnStart).some((m) => m.info.role === "assistant" && messageHasCompress(m));
+  if (currentTurnHasCompress) {
     state.nudges.contextLimitAnchors.clear();
     state.nudges.turnNudgeAnchors.clear();
     state.nudges.iterationNudgeAnchors.clear();
-    state.nudges.lastPerMessageNudgeTokens = void 0;
+    state.nudges.lastNudgeShownTokens = void 0;
     state.nudges.lastToolOutputNudgeTokens = void 0;
+    if (!state.nudges.compressBaselineSet) {
+      state.nudges.lastPerMessageNudgeTokens = currentTokens;
+      state.nudges.compressBaselineSet = true;
+    }
     saveSessionState(state, logger).catch(() => {
     });
     return;
   }
+  state.nudges.compressBaselineSet = false;
   let anchorsChanged = false;
   let baselineReEstablished = false;
+  let baselineCorrected = false;
   if (!overMinLimit) {
     const hadTurnAnchors = state.nudges.turnNudgeAnchors.size > 0;
     const hadIterationAnchors = state.nudges.iterationNudgeAnchors.size > 0;
@@ -6666,15 +6897,20 @@ var injectCompressNudges = (state, config, logger, messages, prompts, compressio
   const nudgeGrowthTokens = config.compress?.nudgeGrowthTokens ?? resolveAdaptiveNudgeGrowth(modelContextLimit);
   if (currentTokens !== void 0 && state.nudges.lastPerMessageNudgeTokens !== void 0 && currentTokens < state.nudges.lastPerMessageNudgeTokens - nudgeGrowthTokens) {
     state.nudges.lastPerMessageNudgeTokens = currentTokens;
+    state.nudges.lastNudgeShownTokens = void 0;
+    baselineCorrected = true;
   }
+  const hasPendingNudge = state.nudges.lastNudgeShownTokens !== void 0;
+  const effectiveThreshold = hasPendingNudge ? Math.floor(nudgeGrowthTokens / 2) : nudgeGrowthTokens;
+  const growthReference = state.nudges.lastNudgeShownTokens ?? state.nudges.lastPerMessageNudgeTokens;
   const decision = computeShouldNudge({
     currentTokens,
     modelContextLimit,
     overMinLimit,
     overMaxLimit,
-    lastNudgeTokens: state.nudges.lastPerMessageNudgeTokens,
+    lastNudgeTokens: growthReference,
     minNudgeContextPercent: config.compress?.minNudgeContextPercent ?? 15,
-    nudgeGrowthTokens
+    nudgeGrowthTokens: effectiveThreshold
   });
   state.nudges.shouldInjectThisTurn = decision.shouldNudge;
   if (state.nudges.lastPerMessageNudgeTokens === void 0 && currentTokens !== void 0) {
@@ -6682,24 +6918,6 @@ var injectCompressNudges = (state, config, logger, messages, prompts, compressio
     baselineReEstablished = true;
   }
   const composition = estimateContextComposition(messages, state);
-  const toolOutputThreshold = config.compress?.toolOutputNudgeThreshold ?? nudgeGrowthTokens;
-  let toolOutputReminder = null;
-  if (composition.toolTokens > 0) {
-    if (state.nudges.lastToolOutputNudgeTokens === void 0) {
-      state.nudges.lastToolOutputNudgeTokens = composition.toolTokens;
-    } else {
-      const toolGrowth = composition.toolTokens - state.nudges.lastToolOutputNudgeTokens;
-      if (toolGrowth >= toolOutputThreshold) {
-        const fmt = (n) => n >= 1e3 ? `${(n / 1e3).toFixed(1)}K` : String(n);
-        const topRanges = composition.largestRanges.slice(0, 15).map((r) => `${r.ref} (${fmt(r.tokens)})`).join(", ");
-        toolOutputReminder = `
-
-\u26A0\uFE0F ${fmt(toolGrowth)} new tool outputs accumulated (${fmt(composition.toolTokens)} total). Largest: ${topRanges}. Use compress tool to compress these ranges now.`;
-        state.nudges.lastToolOutputNudgeTokens = composition.toolTokens;
-        anchorsChanged = true;
-      }
-    }
-  }
   let tipsText = null;
   if (decision.shouldNudge) {
     injectContextUsage(suffixMessage, config, currentTokens, modelContextLimit);
@@ -6710,28 +6928,17 @@ var injectCompressNudges = (state, config, logger, messages, prompts, compressio
       const growthStr = growth > 0 ? ` (+${fmt(growth)} since last nudge)` : "";
       const plainTextTokens = composition.textTokens;
       const efficiencyNote = decision.tipsVariant !== "maxLimit" ? `
-This is an efficiency nudge to compress early and keep context lean \u2014 not an overflow warning. A separate, stronger alert will appear if the context is actually full.` : "";
+This is an efficiency nudge to compress early and keep context lean \u2014 not an overflow warning. A separate, stronger alert will appear if the context is actually full.
+
+${COMPRESS_PHILOSOPHY}` : "";
       let breakdown = `${efficiencyNote}
 Breakdown: ${fmt(composition.toolTokens)} tool (${pct2(composition.toolTokens)}%) | ${fmt(composition.summaryTokens)} summaries (${pct2(composition.summaryTokens)}%) | ${fmt(composition.codeTokens)} code (${pct2(composition.codeTokens)}%) | ${fmt(plainTextTokens)} text (${pct2(plainTextTokens)}%)${growthStr}`;
-      const topToolTypes = composition.toolTypeBreakdown.slice(0, 3);
-      if (topToolTypes.length > 0) {
-        breakdown += `
-Top tools: ${topToolTypes.map((t) => `${t.tool} (${pct2(t.tokens)}%)`).join(", ")}`;
-      }
-      if (composition.largestToolRanges.length > 0) {
-        breakdown += `
-Largest tool outputs: ${composition.largestToolRanges.slice(0, 10).map((r) => `${r.ref} (${fmt(r.tokens)})${r.tool ? " " + r.tool : ""}`).join(", ")}`;
-      }
-      if (composition.largestCodeRanges.length > 0) {
-        breakdown += `
-Largest code messages: ${composition.largestCodeRanges.map((r) => `${r.ref} (${fmt(r.tokens)})`).join(", ")}`;
-      }
-      if (composition.largestMessageRanges.length > 0) {
+      const ranges = buildCompressibleRanges(messages, state);
+      if (ranges.length > 0) {
         breakdown += `
-Largest text messages: ${composition.largestMessageRanges.map((r) => `${r.ref} (${fmt(r.tokens)})`).join(", ")}`;
+
+${formatCompressibleRanges(ranges)}`;
       }
-      breakdown += `
-\u{1F4A1} Compress incrementally: target the ranges above whose content you have already extracted for this step. Size alone is not a reason to compress \u2014 if a large range is still needed in full, keep it.`;
       if (decision.tipsVariant !== "maxLimit") {
         breakdown += `
 
@@ -6742,8 +6949,7 @@ ${HOW_TO_COMPRESS_RULES}`;
     if (decision.tipsVariant === "maxLimit") {
       tipsText = '\n\n\u26A0\uFE0F Context limit reached \u2014 compress now. Prioritize consumed tool outputs.\n\n{ "topic": "...", "content": [{ "startId": "<ID>", "endId": "<ID>", "summary": "..." }] }\n\nOnly use IDs from visible messages above. Compress older work first.';
     }
-    state.nudges.lastPerMessageNudgeTokens = currentTokens;
-    state.nudges.lastPerMessageNudgeTurn = state.currentTurn ?? 0;
+    state.nudges.lastNudgeShownTokens = currentTokens;
     if (config.compress.mode !== "message") {
       const visibleMessageIds = new Set(
         messages.map((message) => message.info.id)
@@ -6763,12 +6969,15 @@ ${HOW_TO_COMPRESS_RULES}`;
     }
     injectVisibleIdRange(state, config, messages, suffixMessage);
   }
-  if (toolOutputReminder && suffixMessage) {
-    appendToLastTextPart(suffixMessage, toolOutputReminder);
-  }
   if (suffixMessage) {
     if (hasContent(suffixMessage)) {
       appendToLastTextPart(suffixMessage, "\n");
+      if (debugNotify) {
+        const text = suffixMessage.parts.filter((p) => p.type === "text").map((p) => p.text || "").join("\n").trim();
+        if (text) {
+          debugNotify(text);
+        }
+      }
     } else {
       const idx = messages.lastIndexOf(suffixMessage);
       if (idx !== -1) {
@@ -6776,7 +6985,7 @@ ${HOW_TO_COMPRESS_RULES}`;
       }
     }
   }
-  if (anchorsChanged || decision.shouldNudge || baselineReEstablished) {
+  if (anchorsChanged || decision.shouldNudge || baselineReEstablished || baselineCorrected) {
     saveSessionState(state, logger).catch(() => {
     });
   }
@@ -7415,19 +7624,17 @@ ${content}`;
 
 // lib/compress/status.ts
 import { tool as tool5 } from "@opencode-ai/plugin";
-var ACP_STATUS_TOOL_DESCRIPTION = `Show context status \u2014 overview or drill down into compressed/uncompressed sections.
+var ACP_STATUS_TOOL_DESCRIPTION = `Show context status \u2014 overview includes compressible ranges by default.
 
-No args: Overview of both visible (uncompressed) context and compressed blocks.
-scope:"uncompressed": Drill into all visible messages \u2014 list each with ref, tokens, tool type. Add tool:"bash" to filter by tool type.
+No args: Overview with totals, compressed blocks, and compressible ranges.
+scope:"uncompressed": Compressible ranges only (default view:"ranges"). Add view:"messages" for per-message listing with tool/sort filters.
 scope:"compressed": Drill into compressed blocks \u2014 list each with full details (age, generation, consumed lineage).
 
-Sort options: "size" (default, largest first), "time" (chronological), "tool" (group by tool type).
-
 Use this tool to:
-- See what's consuming context (overview)
-- Find all messages of a specific tool type to batch-compress
-- Check block details before decompressing
-- Find compression candidates when context grows`;
+- See what's consuming context + compressible ranges in one call (no args)
+- Focus on ranges only (scope:"uncompressed")
+- Find all messages of a specific tool type (scope:"uncompressed", view:"messages", tool:"bash")
+- Check block details before decompressing (scope:"compressed")`;
 function formatTokens(n) {
   if (!Number.isFinite(n) || n <= 0) return "0";
   return n >= 1e3 ? `${(n / 1e3).toFixed(1)}K` : String(n);
@@ -7477,7 +7684,7 @@ function collectVisibleMessages(rawMessages, ctx) {
   });
   return { messages: result, summaryTokens };
 }
-function renderOverview(visibleMessages, summaryTokens, blocks, fetchFailed) {
+function renderOverview(visibleMessages, summaryTokens, blocks, fetchFailed, rawMessages, ctx) {
   const lines = [];
   const toolTypeMap = /* @__PURE__ */ new Map();
   for (const m of visibleMessages) {
@@ -7522,9 +7729,45 @@ function renderOverview(visibleMessages, summaryTokens, blocks, fetchFailed) {
       lines.push(`  b${b.blockId}  ${formatTokens(b.compressedTokens)}\u2192${formatTokens(b.summaryTokens)}  ${ageStr}  ${range}  "${topic}"`);
     }
   }
+  if (!fetchFailed) {
+    const pruneMap = ctx.state.prune.messages.byMessageId;
+    const visibleRaw = rawMessages.filter((msg) => {
+      const msgId = msg.info?.id || "";
+      const entry = pruneMap.get(msgId);
+      return !entry || entry.activeBlockIds.length === 0;
+    });
+    const ranges = buildCompressibleRanges(visibleRaw, ctx.state);
+    if (ranges.length > 0) {
+      lines.push("");
+      lines.push(formatCompressibleRanges(ranges));
+    }
+  }
   lines.push("");
   const hintTool = topToolName || "bash";
-  lines.push(`Tip: acp_status({scope:"uncompressed", tool:"${hintTool}", sort:"size"}) \u2014 mix any params freely`);
+  lines.push(`Tip: acp_status({scope:"uncompressed", view:"messages", tool:"${hintTool}"}) for per-message listing`);
+  return lines;
+}
+function renderUncompressedRanges(rawMessages, ctx) {
+  const pruneMap = ctx.state.prune.messages.byMessageId;
+  const visibleMessages = rawMessages.filter((msg) => {
+    const msgId = msg.info?.id || "";
+    const entry = pruneMap.get(msgId);
+    return !entry || entry.activeBlockIds.length === 0;
+  });
+  const ranges = buildCompressibleRanges(visibleMessages, ctx.state);
+  const totalTokens = ranges.reduce((s, r) => s + r.tokens, 0);
+  const totalMsgs = ranges.reduce((s, r) => s + r.count, 0);
+  const lines = [];
+  lines.push(`UNCOMPRESSED \u2014 ${formatTokens(totalTokens)} | ${totalMsgs} msgs in ${ranges.length} ranges`);
+  lines.push("");
+  if (ranges.length === 0) {
+    lines.push("  (no compressible ranges)");
+  } else {
+    lines.push(formatCompressibleRanges(ranges));
+  }
+  lines.push("");
+  lines.push(`Per-message listing: acp_status({scope:"uncompressed", view:"messages"})`);
+  lines.push(`Filter by tool: acp_status({scope:"uncompressed", view:"messages", tool:"bash"})`);
   return lines;
 }
 function renderUncompressedDrilldown(visibleMessages, toolFilter, sort, limit) {
@@ -7608,12 +7851,14 @@ function createAcpStatusTool(ctx) {
     description: ACP_STATUS_TOOL_DESCRIPTION,
     args: {
       scope: tool5.schema.string().optional().describe('Drill down: "compressed" or "uncompressed". No arg = overview of both.'),
-      tool: tool5.schema.string().optional().describe('Filter by tool type (only with scope:"uncompressed"). e.g., "bash", "todowrite", "write"'),
+      view: tool5.schema.string().optional().describe('Display format for scope:"uncompressed": "ranges" (default, grouped by turn \u2014 matches nudge format) or "messages" (per-message listing with sort/filter)'),
+      tool: tool5.schema.string().optional().describe('Filter by tool type (only with scope:"uncompressed", view:"messages"). e.g., "bash", "todowrite", "write"'),
       sort: tool5.schema.string().optional().describe('Sort order: "size" (default), "time", or "tool"'),
       limit: tool5.schema.number().optional().describe("Max items to list (default 30)")
     },
     async execute(args, toolCtx) {
       const scope = args.scope === "compressed" || args.scope === "uncompressed" ? args.scope : void 0;
+      const view = args.view === "messages" ? "messages" : "ranges";
       const toolFilter = typeof args.tool === "string" ? args.tool : void 0;
       const sort = args.sort === "time" || args.sort === "tool" || args.sort === "age" ? args.sort : "size";
       const limit = Number.isFinite(args.limit) && args.limit > 0 ? Math.min(args.limit, 200) : 30;
@@ -7628,8 +7873,9 @@ function createAcpStatusTool(ctx) {
       let visibleMsgs = [];
       let summaryTokens = 0;
       let fetchFailed = false;
+      let rawMessages = [];
       try {
-        const rawMessages = await fetchSessionMessages(ctx.client, toolCtx.sessionID);
+        rawMessages = await fetchSessionMessages(ctx.client, toolCtx.sessionID);
         const result = collectVisibleMessages(rawMessages, ctx);
         visibleMsgs = result.messages;
         summaryTokens = result.summaryTokens;
@@ -7638,9 +7884,13 @@ function createAcpStatusTool(ctx) {
       }
       if (scope === "uncompressed") {
         if (fetchFailed) return "(unable to fetch messages)";
-        lines.push(...renderUncompressedDrilldown(visibleMsgs, toolFilter, sort, limit));
+        if (view === "messages") {
+          lines.push(...renderUncompressedDrilldown(visibleMsgs, toolFilter, sort, limit));
+        } else {
+          lines.push(...renderUncompressedRanges(rawMessages, ctx));
+        }
       } else {
-        lines.push(...renderOverview(visibleMsgs, summaryTokens, allBlocks, fetchFailed));
+        lines.push(...renderOverview(visibleMsgs, summaryTokens, allBlocks, fetchFailed, rawMessages, ctx));
       }
       return lines.join("\n");
     }
@@ -7939,7 +8189,7 @@ You have five context-management tools:
 - \`decompress\` \u2014 Restore a previously compressed block's full original content, optionally to a file for large blocks. Use when a summary lacks the exact detail you need. Example: \`decompress({ blockId: "b5" })\` or \`decompress({ blockId: "b5", toFile: "path" })\`.
 - \`search_context\` \u2014 Search compressed block summaries (and optionally visible messages) by keyword. Use BEFORE decompressing to find the right block. Example: \`search_context({ query: "auth token refresh" })\`.
 - \`prune\` \u2014 Remove old tool outputs by tool type, keeping only recent calls. Unlike compress (which creates summaries), prune directly strips outputs. Use for disposable outputs like old todowrite states or edit echoes. Example: \`prune({ toolType: "todowrite", keepLatest: 3 })\`.
-- \`acp_status\` \u2014 Context status with drilldown. No args = overview. \`scope:"uncompressed"\` lists all visible messages; add \`tool:"bash"\` to filter by tool type. \`scope:"compressed"\` shows block details. Example: \`acp_status({scope:"uncompressed", tool:"todowrite"})\`.
+- \`acp_status\` \u2014 Context status with compressible ranges. No args = overview + ranges. \`scope:"uncompressed"\` for range view; add \`view:"messages"\` for per-message listing with \`tool\`/\`sort\` filters. \`scope:"compressed"\` for block details.
 
 COMPRESSION PHILOSOPHY
 
@@ -7947,9 +8197,9 @@ Two failure modes to avoid:
 - Over-compression: Compressing too aggressively loses critical details, decisions, and state needed for your task. This directly harms task quality.
 - Under-compression: Failing to compress verbose outputs causes context overflow, reducing accuracy and eventually blocking your work.
 
-Balance is key. The single test for whether to compress is: "Is this content still needed by the current task step?" If yes, keep it. If no, it is a candidate. When uncertain, lean toward keeping content.
+Balance is key. The single test for whether to compress is: "Is this content still needed by the current task step?" If yes, keep it. If no, compress it. All ranges listed in the context breakdown should be compressed to summary format \u2014 the only exceptions are protected content, content the current step is actively using, or critical content you cannot reconstruct.
 
-Be frugal with context. Compress obvious waste proactively \u2014 verbose outputs you have already used, duplicate reads, abandoned explorations. Do not wait until context is critically full; that harms retrieval quality and risks overflow. When compressing, cover the largest range you can in a single call \u2014 aim for 20+ messages. Compressing 3-5 messages at a time creates many small summaries that collectively waste more tokens than they save. But never let the urge to compress distract from the actual task.
+Be frugal with context. Compress obvious waste proactively \u2014 verbose outputs you have already used, duplicate reads, abandoned explorations. Do not wait until context is critically full; that harms retrieval quality and risks overflow. But never let the urge to compress distract from the actual task.
 
 WHEN TO COMPRESS
 
@@ -7966,7 +8216,7 @@ WHEN NOT TO COMPRESS
 
 - Content the current task step is actively reading or reasoning about.
 - Important user messages \u2014 preserve their exact intent, constraints, and acceptance criteria verbatim, not just the most recent one.
-- Outputs from protected tools (e.g. \`task\`, \`skill\`, \`todowrite\`, \`write\`, \`edit\`) \u2014 these are appended to summaries automatically, not compressed away.
+- Protected tool outputs (default: \`skill\` only) \u2014 hard-excluded from compression ranges, survive intact in visible context.
 
 ${HOW_TO_COMPRESS_RULES}
 
@@ -7991,9 +8241,9 @@ Breakdown: 12.3K tool (40%) | 3.1K summaries (10%) | 8.5K code (28%) | 6.5K text
 - "code" = messages containing code blocks
 - "text" = plain text messages
 
-Below the breakdown, the system lists the largest ranges in each category (e.g. \`Largest tool outputs: m00175 (20.7K), m00200 (8.1K)\`). These are high-value compression candidates \u2014 compress those whose content you have already consumed (extracted the facts you need). Keep any you still need to reference.
+Below the breakdown, the system lists compressible ranges grouped by conversation turn. All listed ranges should be compressed to summary format \u2014 the only exceptions are protected content, content the current step is actively using, or critical content you cannot reconstruct. Compress the largest ranges first when the current step no longer needs them.
 
-Compress incrementally: target one large consumed range per compress call (e.g. m00150\u2013m00200), not the entire context at once. Each compression creates a reusable summary block you can decompress later if needed.
+Each compression creates a reusable summary block you can decompress later if needed.
 `;
 
 // lib/prompts/compress-range.ts
@@ -8033,6 +8283,23 @@ Rules:
 
 BATCHING
 When multiple independent ranges are ready and their boundaries do not overlap, include all of them as separate entries in the \`content\` array of a single tool call. Each entry should have its own \`startId\`, \`endId\`, and \`summary\`.
+
+KEEP AND REF MARKERS
+When writing a summary, you may embed markers that reference specific messages in the compressed range. The system resolves them automatically:
+
+- \`[[KEEP:mNNNNN]]\` \u2014 Expands to the original message content inline (truncated to a max length). Use for critical content you want preserved verbatim in the summary without re-typing it: key function definitions, important error messages, essential file contents.
+- \`[[REF:mNNNNN|short description]]\` \u2014 Creates a compact link like \`[\u2192 m00065: key function definition]\`. Use for content the reader can decompress later if needed. Does not expand \u2014 saves space.
+
+Example:
+\`\`\`
+Implemented the QuotaMonitor feature. Key design: observer pattern.
+
+[[KEEP:m00065]]
+
+The rest of the bash calls were repetitive export commands. See [[REF:m00078|test results]] for details.
+\`\`\`
+
+Use KEEP sparingly \u2014 each expansion adds to the summary length. Prefer REF for content that is important but not immediately critical.
 `;
 
 // lib/prompts/compress-message.ts
@@ -9825,7 +10092,18 @@ function createChatMessageTransformHandler(client, state, logger, config, prompt
       logger,
       output.messages,
       prompts.getRuntimePrompts(),
-      compressionPriorities
+      compressionPriorities,
+      config.debug && state.sessionId ? (text) => {
+        sendIgnoredMessage(
+          client,
+          state.sessionId,
+          `[ACP Debug] Nudge injected:
+${text}`,
+          {},
+          logger
+        ).catch(() => {
+        });
+      } : void 0
     );
     injectMessageIds(state, config, output.messages, compressionPriorities);
     applyPendingManualTrigger(state, output.messages, logger);