opencode-acp 1.11.4 → 1.12.1

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) {
@@ -2660,20 +2677,20 @@ function matchesGlob(inputPath, pattern) {
   regex += "$";
   return new RegExp(regex).test(input);
 }
-function getFilePathsFromParameters(tool7, parameters) {
+function getFilePathsFromParameters(tool8, parameters) {
   if (typeof parameters !== "object" || parameters === null) {
     return [];
   }
   const paths = [];
   const params = parameters;
-  if (tool7 === "apply_patch" && typeof params.patchText === "string") {
+  if (tool8 === "apply_patch" && typeof params.patchText === "string") {
     const pathRegex = /\*\*\* (?:Add|Delete|Update) File: ([^\n\r]+)/g;
     let match;
     while ((match = pathRegex.exec(params.patchText)) !== null) {
       paths.push(match[1].trim());
     }
   }
-  if (tool7 === "multiedit") {
+  if (tool8 === "multiedit") {
     if (typeof params.filePath === "string") {
       paths.push(params.filePath);
     }
@@ -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
@@ -4551,13 +4578,13 @@ var deduplicate = (state, logger, config, messages) => {
     logger.debug(`Marked ${newPruneIds.length} duplicate tool calls for pruning`);
   }
 };
-function createToolSignature(tool7, parameters) {
+function createToolSignature(tool8, parameters) {
   if (!parameters) {
-    return tool7;
+    return tool8;
   }
   const normalized = normalizeParameters(parameters);
   const sorted = sortObjectKeys(normalized);
-  return `${tool7}::${JSON.stringify(sorted)}`;
+  return `${tool8}::${JSON.stringify(sorted)}`;
 }
 function normalizeParameters(params) {
   if (typeof params !== "object" || params === null) return params;
@@ -4632,9 +4659,9 @@ var purgeErrors = (state, logger, config, messages) => {
 };
 
 // lib/ui/utils.ts
-function extractParameterKey(tool7, parameters) {
+function extractParameterKey(tool8, parameters) {
   if (!parameters) return "";
-  if (tool7 === "read" && parameters.filePath) {
+  if (tool8 === "read" && parameters.filePath) {
     const offset = parameters.offset;
     const limit = parameters.limit;
     if (offset !== void 0 && limit !== void 0) {
@@ -4648,10 +4675,10 @@ function extractParameterKey(tool7, parameters) {
     }
     return parameters.filePath;
   }
-  if ((tool7 === "write" || tool7 === "edit" || tool7 === "multiedit") && parameters.filePath) {
+  if ((tool8 === "write" || tool8 === "edit" || tool8 === "multiedit") && parameters.filePath) {
     return parameters.filePath;
   }
-  if (tool7 === "apply_patch" && typeof parameters.patchText === "string") {
+  if (tool8 === "apply_patch" && typeof parameters.patchText === "string") {
     const pathRegex = /\*\*\* (?:Add|Delete|Update) File: ([^\n\r]+)/g;
     const paths = [];
     let match;
@@ -4668,51 +4695,51 @@ function extractParameterKey(tool7, parameters) {
     }
     return "patch";
   }
-  if (tool7 === "list") {
+  if (tool8 === "list") {
     return parameters.path || "(current directory)";
   }
-  if (tool7 === "glob") {
+  if (tool8 === "glob") {
     if (parameters.pattern) {
       const pathInfo = parameters.path ? ` in ${parameters.path}` : "";
       return `"${parameters.pattern}"${pathInfo}`;
     }
     return "(unknown pattern)";
   }
-  if (tool7 === "grep") {
+  if (tool8 === "grep") {
     if (parameters.pattern) {
       const pathInfo = parameters.path ? ` in ${parameters.path}` : "";
       return `"${parameters.pattern}"${pathInfo}`;
     }
     return "(unknown pattern)";
   }
-  if (tool7 === "bash") {
+  if (tool8 === "bash") {
     if (parameters.description) return parameters.description;
     if (parameters.command) {
       return parameters.command.length > 50 ? parameters.command.substring(0, 50) + "..." : parameters.command;
     }
   }
-  if (tool7 === "webfetch" && parameters.url) {
+  if (tool8 === "webfetch" && parameters.url) {
     return parameters.url;
   }
-  if (tool7 === "websearch" && parameters.query) {
+  if (tool8 === "websearch" && parameters.query) {
     return `"${parameters.query}"`;
   }
-  if (tool7 === "codesearch" && parameters.query) {
+  if (tool8 === "codesearch" && parameters.query) {
     return `"${parameters.query}"`;
   }
-  if (tool7 === "todowrite") {
+  if (tool8 === "todowrite") {
     return `${parameters.todos?.length || 0} todos`;
   }
-  if (tool7 === "todoread") {
+  if (tool8 === "todoread") {
     return "read todo list";
   }
-  if (tool7 === "task" && parameters.description) {
+  if (tool8 === "task" && parameters.description) {
     return parameters.description;
   }
-  if (tool7 === "skill" && parameters.name) {
+  if (tool8 === "skill" && parameters.name) {
     return parameters.name;
   }
-  if (tool7 === "lsp") {
+  if (tool8 === "lsp") {
     const op = parameters.operation || "lsp";
     const path = parameters.filePath || "";
     const line = parameters.line;
@@ -4725,7 +4752,7 @@ function extractParameterKey(tool7, parameters) {
     }
     return op;
   }
-  if (tool7 === "question") {
+  if (tool8 === "question") {
     const questions = parameters.questions;
     if (Array.isArray(questions) && questions.length > 0) {
       const headers = questions.map((q) => q.header || "").filter(Boolean).slice(0, 3);
@@ -4869,6 +4896,22 @@ function formatPrunedItemsList(pruneToolIds, toolMetadata, workingDirectory) {
 var TOAST_BODY_MAX_LINES = 12;
 var TOAST_SUMMARY_MAX_CHARS = 600;
 var NOTIFICATION_SUMMARY_MAX_CHARS = 1500;
+function formatEntryRanges(entries, state) {
+  const parts = [];
+  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}`);
+    }
+  }
+  return parts.length > 0 ? parts.join(", ") : null;
+}
 function truncateToastBody(body, maxLines = TOAST_BODY_MAX_LINES) {
   const lines = body.split("\n");
   if (lines.length <= maxLines) {
@@ -4889,18 +4932,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;
 }
@@ -4980,6 +5029,7 @@ async function sendCompressNotification(client, logger, config, state, sessionId
     contextTokensBefore,
     contextTokensAfter
   )}`;
+  let displaySummary = summary;
   if (config.pruneNotification === "minimal") {
     message = `${notificationHeader} \u2014 ${compressionLabel}`;
   } else {
@@ -5001,6 +5051,11 @@ async function sendCompressNotification(client, logger, config, state, sessionId
 ${progressBar}`;
     message += `
 \u25A3 ${compressionLabel} ${formatCompressionMetrics(compressedTokens, summaryTokens)}`;
+    const rangeStr = formatEntryRanges(entries, state);
+    if (rangeStr) {
+      message += `
+\u2192 Range: ${rangeStr}`;
+    }
     message += `
 \u2192 Topic: ${topic}`;
     message += `
@@ -5011,24 +5066,17 @@ ${progressBar}`;
       message += ` compressed`;
     }
     if (config.compress.showCompression) {
-      const displaySummary = summary.length > NOTIFICATION_SUMMARY_MAX_CHARS ? truncateToastSummary(summary, NOTIFICATION_SUMMARY_MAX_CHARS) : summary;
+      if (config.pruneNotification === "detailed") {
+        displaySummary = summary;
+      } else {
+        displaySummary = summary.length > NOTIFICATION_SUMMARY_MAX_CHARS ? truncateToastSummary(summary, NOTIFICATION_SUMMARY_MAX_CHARS) : summary;
+      }
       message += `
 \u2192 Compression (~${summaryTokensStr}): ${displaySummary}`;
     }
   }
   if (config.pruneNotificationType === "toast") {
     let toastMessage = message;
-    if (config.compress.showCompression) {
-      const truncatedSummary = truncateToastSummary(summary);
-      if (truncatedSummary !== summary) {
-        toastMessage = toastMessage.replace(
-          `
-\u2192 Compression (~${summaryTokensStr}): ${truncateToastSummary(summary, NOTIFICATION_SUMMARY_MAX_CHARS)}`,
-          `
-\u2192 Compression (~${summaryTokensStr}): ${truncatedSummary}`
-        );
-      }
-    }
     toastMessage = config.pruneNotification === "minimal" ? toastMessage : truncateToastBody(toastMessage);
     await client.tui.showToast({
       body: {
@@ -5127,6 +5175,118 @@ async function finalizeSession(ctx, toolCtx, rawMessages, entries, batchTopic) {
   );
 }
 
+// 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 normalized = normalizeRef(ref);
+    const msg = normalized ? msgByRef.get(normalized) : void 0;
+    if (!msg) {
+      unresolvedRefs.push(ref);
+      return match;
+    }
+    expandedCount++;
+    return formatKeptMessage(msg, normalized, maxChars);
+  }).replace(REF_REGEX, (_match, ref, desc) => {
+    const normalized = normalizeRef(ref);
+    const msg = normalized ? msgByRef.get(normalized) : void 0;
+    if (!msg) {
+      unresolvedRefs.push(ref);
+      return _match;
+    }
+    refCount++;
+    return `[\u2192 ${normalized}: ${desc.trim()}]`;
+  });
+  return { summary: expanded, expandedCount, refCount, unresolvedRefs };
+}
+function normalizeRef(ref) {
+  const idx = parseMessageRef(ref);
+  if (idx === null) return null;
+  return formatMessageRef(idx);
+}
+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 tool8 = part.tool || "unknown";
+      const state = part.state || {};
+      const input = state.input || {};
+      const output = state.output || "";
+      switch (tool8) {
+        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: tool8, 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 tool8 = part.tool || "unknown";
+      const input = part.state?.input || {};
+      const fp = input.filePath || input.path || input.command || "";
+      return fp ? `${tool8}: ${String(fp).slice(0, 60)}` : tool8;
+    }
+  }
+  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/message.ts
 function buildSchema(maxSummaryLengthHard) {
   return {
@@ -5228,7 +5388,14 @@ function createCompressMessageTool(ctx) {
       const runId = allocateRunId(ctx.state);
       for (const { plan, summaryWithTools } of preparedPlans) {
         const blockId = allocateBlockId(ctx.state);
-        const storedSummary = wrapCompressedSummary(blockId, summaryWithTools);
+        const keepResult = resolveKeepMarkers(
+          summaryWithTools,
+          rawMessages,
+          ctx.state,
+          ctx.config
+        );
+        const resolvedSummary = keepResult.summary;
+        const storedSummary = wrapCompressedSummary(blockId, resolvedSummary);
         const summaryTokens = countTokens2(storedSummary);
         applyCompressionState(
           ctx.state,
@@ -5253,7 +5420,7 @@ function createCompressMessageTool(ctx) {
         notifications.push({
           blockId,
           runId,
-          summary: summaryWithTools,
+          summary: resolvedSummary,
           summaryTokens
         });
       }
@@ -5420,6 +5587,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(
@@ -5785,6 +5959,40 @@ var filterCompressedRanges = (state, logger, config, messages) => {
   messages.length = 0;
   messages.push(...result);
 };
+function stripStaleCompressCalls(messages) {
+  const lastUserIdx = messages.findLastIndex(
+    (m) => m.info.role === "user" && !isIgnoredUserMessage(m)
+  );
+  if (lastUserIdx < 0) return 0;
+  let stripped = 0;
+  const result = [];
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (i >= lastUserIdx) {
+      result.push(msg);
+      continue;
+    }
+    const hasCompress = msg.parts.some(
+      (p) => p.type === "tool" && p.tool === "compress"
+    );
+    if (!hasCompress) {
+      result.push(msg);
+      continue;
+    }
+    const remaining = msg.parts.filter(
+      (p) => !(p.type === "tool" && p.tool === "compress")
+    );
+    stripped++;
+    if (remaining.length > 0) {
+      result.push({ ...msg, parts: remaining });
+    }
+  }
+  if (stripped > 0) {
+    messages.length = 0;
+    messages.push(...result);
+  }
+  return stripped;
+}
 
 // lib/messages/sync.ts
 function sortBlocksByCreation(a, b) {
@@ -5933,8 +6141,8 @@ var resolveEffectiveCompressPermission = (basePermission, hostPermissions, agent
     agentName ? hostPermissions.agents[agentName] : void 0
   ) ? "deny" : basePermission;
 };
-var hasExplicitToolPermission = (permissionConfig, tool7) => {
-  return permissionConfig ? Object.prototype.hasOwnProperty.call(permissionConfig, tool7) : false;
+var hasExplicitToolPermission = (permissionConfig, tool8) => {
+  return permissionConfig ? Object.prototype.hasOwnProperty.call(permissionConfig, tool8) : false;
 };
 
 // lib/compress-permission.ts
@@ -6358,8 +6566,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);
@@ -6512,7 +6719,7 @@ function estimateContextComposition(messages, state) {
   perTool.sort((a, b) => b.tokens - a.tokens);
   perCode.sort((a, b) => b.tokens - a.tokens);
   perText.sort((a, b) => b.tokens - a.tokens);
-  const toolTypeBreakdown = Array.from(toolTypeMap.entries()).map(([tool7, tokens]) => ({ tool: tool7, tokens })).sort((a, b) => b.tokens - a.tokens);
+  const toolTypeBreakdown = Array.from(toolTypeMap.entries()).map(([tool8, tokens]) => ({ tool: tool8, tokens })).sort((a, b) => b.tokens - a.tokens);
   return {
     toolTokens,
     codeTokens,
@@ -6527,8 +6734,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 +6834,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 +6854,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, preCompressTokens) => {
   if (compressPermission(state, config) === "deny") {
     return;
   }
@@ -6592,18 +6871,46 @@ 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) {
+    const wasNudgeTriggered = state.nudges.lastNudgeShownTokens !== void 0;
     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 (wasNudgeTriggered && !state.nudges.compressBaselineSet) {
+      const baseline = state.nudges.lastPerMessageNudgeTokens;
+      const postCompress = currentTokens;
+      const preCompress = preCompressTokens;
+      if (baseline !== void 0 && postCompress !== void 0 && preCompress !== void 0 && preCompress > postCompress) {
+        const growth = preCompress - baseline;
+        const compressed = preCompress - postCompress;
+        if (growth > 0 && compressed > 0) {
+          const ratio = Math.min(1, compressed / growth);
+          const adjustment = Math.min(1, ratio * 2);
+          const newBaseline = baseline + Math.round((postCompress - baseline) * adjustment);
+          state.nudges.lastPerMessageNudgeTokens = newBaseline;
+        } else {
+          state.nudges.lastPerMessageNudgeTokens = postCompress;
+        }
+      } else {
+        state.nudges.lastPerMessageNudgeTokens = postCompress;
+      }
+      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 +6973,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 +6994,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 +7004,21 @@ 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) {
+      const ranges = buildCompressibleRanges(messages, state);
+      if (ranges.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) {
+
+${formatCompressibleRanges(ranges)}`;
         breakdown += `
-Largest text messages: ${composition.largestMessageRanges.map((r) => `${r.ref} (${fmt(r.tokens)})`).join(", ")}`;
+\u{1F4A1} Compress all ranges in one call (pass multiple content entries: \`content: [{...}, {...}]\`).`;
       }
       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.`;
+Use \`acp_status({scope:"uncompressed"})\` to re-fetch compressible ranges after compressing, or \`acp_status\` for compressed block details.`;
       if (decision.tipsVariant !== "maxLimit") {
         breakdown += `
 
@@ -6742,8 +7029,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)
@@ -6761,14 +7047,16 @@ ${HOW_TO_COMPRESS_RULES}`;
     if (tipsText && suffixMessage) {
       appendToLastTextPart(suffixMessage, tipsText);
     }
-    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 +7064,7 @@ ${HOW_TO_COMPRESS_RULES}`;
       }
     }
   }
-  if (anchorsChanged || decision.shouldNudge || baselineReEstablished) {
+  if (anchorsChanged || decision.shouldNudge || baselineReEstablished || baselineCorrected) {
     saveSessionState(state, logger).catch(() => {
     });
   }
@@ -6794,86 +7082,6 @@ function injectContextUsage(target, config, currentTokens, modelContextLimit) {
   }
   target.parts.push(createSyntheticTextPart(target, usageTag));
 }
-function refNumber(ref) {
-  const n = parseInt(ref.slice(1), 10);
-  return Number.isNaN(n) ? -1 : n;
-}
-function buildVisibleSegments(state, messages) {
-  const refInfo = /* @__PURE__ */ new Map();
-  for (const msg of messages) {
-    const ref = state.messageIds.byRawId.get(msg.info.id);
-    if (!ref) continue;
-    let tokens = 0;
-    let hasTool = 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);
-        hasTool = true;
-      }
-    }
-    refInfo.set(ref, { tokens, hasTool });
-  }
-  if (refInfo.size === 0) return [];
-  const refs = Array.from(refInfo.keys()).sort((a, b) => refNumber(a) - refNumber(b));
-  const segments = [];
-  let cur = null;
-  let prevNum = -2;
-  for (const ref of refs) {
-    const num = refNumber(ref);
-    const info = refInfo.get(ref);
-    if (cur && num === prevNum + 1) {
-      cur.endRef = ref;
-      cur.count++;
-      cur.tokens += info.tokens;
-      if (info.hasTool) cur.hasTool = true;
-    } else {
-      if (cur) segments.push(cur);
-      cur = { startRef: ref, endRef: ref, count: 1, tokens: info.tokens, hasTool: info.hasTool };
-    }
-    prevNum = num;
-  }
-  if (cur) segments.push(cur);
-  return segments;
-}
-function formatSegment(seg) {
-  return seg.startRef === seg.endRef ? seg.startRef : `${seg.startRef}\u2013${seg.endRef}`;
-}
-function formatVisibleGuidance(segments, maxSegs) {
-  if (segments.length === 0) return "";
-  const totalMsgs = segments.reduce((s, seg) => s + seg.count, 0);
-  const totalSegs = segments.length;
-  const fmt = (n) => n >= 1e3 ? `${(n / 1e3).toFixed(1)}K` : String(n);
-  if (totalSegs <= maxSegs) {
-    return `[Visible: ${segments.map(formatSegment).join(", ")} (${totalMsgs} msg${totalMsgs === 1 ? "" : "s"}, ${totalSegs} segment${totalSegs === 1 ? "" : "s"})]`;
-  }
-  const keepSet = new Set(
-    [...segments].sort((a, b) => {
-      if (a.hasTool !== b.hasTool) return a.hasTool ? -1 : 1;
-      return b.tokens - a.tokens;
-    }).slice(0, maxSegs)
-  );
-  const shown = segments.filter((s) => keepSet.has(s));
-  const omitted = segments.filter((s) => !keepSet.has(s));
-  const omittedTokens = omitted.reduce((sum, s) => sum + s.tokens, 0);
-  const omittedMsgs = omitted.reduce((sum, s) => sum + s.count, 0);
-  return `[Visible (top ${shown.length} of ${totalSegs} segments, ${totalMsgs} msgs): ${shown.map(formatSegment).join(", ")} | +${omitted.length} smaller segment${omitted.length === 1 ? "" : "s"} (~${fmt(omittedTokens)} tokens, ${omittedMsgs} msg${omittedMsgs === 1 ? "" : "s"}) omitted]`;
-}
-function injectVisibleIdRange(state, config, messages, target) {
-  if (!target) return;
-  const segments = buildVisibleSegments(state, messages);
-  if (segments.length === 0) return;
-  const maxSegs = config.compress?.maxVisibleSegments ?? 50;
-  const rangeTag = "\n\n" + formatVisibleGuidance(segments, maxSegs);
-  for (const part of target.parts) {
-    if (part.type === "text") {
-      appendToTextPart(part, rangeTag);
-      return;
-    }
-  }
-  target.parts.push(createSyntheticTextPart(target, rangeTag));
-}
 var injectMessageIds = (state, config, messages, compressionPriorities) => {
   if (compressPermission(state, config) === "deny") {
     return;
@@ -7415,19 +7623,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 +7683,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) {
@@ -7498,7 +7704,7 @@ function renderOverview(visibleMessages, summaryTokens, blocks, fetchFailed) {
     lines.push(
       `  ${formatTokens(total)} total | ${formatTokens(totalTool)} tool (${toolPct}%) | ${formatTokens(totalText)} text (${textPct}%) | ${formatTokens(summaryTokens)} summaries (${summaryPct}%)`
     );
-    const topTypes = Array.from(toolTypeMap.entries()).map(([tool7, tokens]) => ({ tool: tool7, tokens })).sort((a, b) => b.tokens - a.tokens).slice(0, 3);
+    const topTypes = Array.from(toolTypeMap.entries()).map(([tool8, tokens]) => ({ tool: tool8, tokens })).sort((a, b) => b.tokens - a.tokens).slice(0, 3);
     if (topTypes.length > 0) {
       lines.push(`  Top tools: ${topTypes.map((t) => `${t.tool} (${pct(t.tokens, total)}%)`).join(", ")}`);
     }
@@ -7522,9 +7728,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 +7850,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 +7872,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,17 +7883,80 @@ 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");
     }
   });
 }
 
-// lib/compress/prune-tool.ts
+// 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}`;
+}
+var RECAP_TOOL_DESCRIPTION = `Read-only retrieval of compression block summaries.
+
+This tool is primarily system-managed: ACP automatically injects compression summaries into context via this tool's result format. You can also call it directly to re-fetch a specific block's summary without decompressing the full original content.
+
+Args:
+- blockId: optional block number (e.g., 5). If omitted, lists all active blocks with brief info.`;
+function createAcpContextRecapTool(ctx) {
+  return tool6({
+    description: RECAP_TOOL_DESCRIPTION,
+    args: {
+      blockId: tool6.schema.number().optional().describe("Block number to retrieve (e.g., 5). If omitted, lists all active blocks.")
+    },
+    async execute(args) {
+      const msgState = ctx.state.prune.messages;
+      const activeIds = Array.from(msgState.activeBlockIds).sort((a, b) => a - b);
+      if (activeIds.length === 0) {
+        return "No active compression blocks.";
+      }
+      if (args.blockId !== void 0) {
+        const block = msgState.blocksById.get(args.blockId);
+        if (!block) {
+          return `Block b${args.blockId} not found. Active blocks: ${activeIds.map((id) => `b${id}`).join(", ")}`;
+        }
+        if (!block.active) {
+          return `Block b${args.blockId} is inactive (deactivated by GC or nested compression).`;
+        }
+        const range = formatRange(block.startId, block.endId);
+        return `[Compressed conversation section]
+${block.summary}
+
+[Block b${args.blockId} | ${range} | topic: "${block.topic || "(none)"}"]`;
+      }
+      const lines = [];
+      lines.push(`Active compression blocks (${activeIds.length}):`);
+      for (const id of activeIds) {
+        const block = msgState.blocksById.get(id);
+        if (!block || !block.active) continue;
+        const range = formatRange(block.startId, block.endId);
+        const summaryPreview = block.summary.slice(0, 200);
+        lines.push(`
+b${id} | ${range} | "${block.topic || "(none)"}"`);
+        lines.push(`  ${summaryPreview}${block.summary.length > 200 ? "..." : ""}`);
+      }
+      lines.push(`
+Call with blockId to get the full summary: acp_context_recap({ blockId: N })`);
+      return lines.join("\n");
+    }
+  });
+}
+
+// lib/compress/prune-tool.ts
+import { tool as tool7 } from "@opencode-ai/plugin";
 var PRUNE_TOOL_DESCRIPTION = `Remove old tool outputs by tool type \u2014 frees context without compression.
 
 Unlike compress (which creates summaries), prune directly strips tool call outputs from context. Use for disposable tool outputs where the content is no longer needed: old todowrite states, edit success echoes, repeated status checks.
@@ -7658,11 +7966,11 @@ Args:
 - keepLatest: how many recent calls to keep visible (default 3)`;
 function createPruneTool(ctx) {
   ctx.prompts.reload();
-  return tool6({
+  return tool7({
     description: PRUNE_TOOL_DESCRIPTION,
     args: {
-      toolType: tool6.schema.string().describe('Tool name to prune (e.g., "todowrite", "bash", "edit")'),
-      keepLatest: tool6.schema.number().optional().describe("How many recent calls to keep visible (default 3)")
+      toolType: tool7.schema.string().describe('Tool name to prune (e.g., "todowrite", "bash", "edit")'),
+      keepLatest: tool7.schema.number().optional().describe("How many recent calls to keep visible (default 3)")
     },
     async execute(args, toolCtx) {
       const keepLatest = args.keepLatest ?? 3;
@@ -7939,7 +8247,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 +8255,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 +8274,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 +8299,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 +8341,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
@@ -8932,7 +9257,7 @@ var COMPRESS_TRIGGER_PROMPT = [
   "Follow the active compress mode, preserve all critical implementation details, and choose safe targets.",
   "Return after compress with a brief explanation of what content was compressed."
 ].join("\n\n");
-function getTriggerPrompt(tool7, state, config, userFocus) {
+function getTriggerPrompt(tool8, state, config, userFocus) {
   const base = COMPRESS_TRIGGER_PROMPT;
   const compressedBlockGuidance = config.compress.mode === "message" ? "" : buildCompressedBlockGuidance(state, config.gc);
   const sections = [base, compressedBlockGuidance];
@@ -8961,8 +9286,8 @@ async function handleManualToggleCommand(ctx, modeArg) {
   );
   logger.info("Manual mode toggled", { manualMode: state.manualMode });
 }
-async function handleManualTriggerCommand(ctx, tool7, userFocus) {
-  return getTriggerPrompt(tool7, ctx.state, ctx.config, userFocus);
+async function handleManualTriggerCommand(ctx, tool8, userFocus) {
+  return getTriggerPrompt(tool8, ctx.state, ctx.config, userFocus);
 }
 function applyPendingManualTrigger(state, messages, logger) {
   const pending = state.pendingManualTrigger;
@@ -9808,7 +10133,9 @@ function createChatMessageTransformHandler(client, state, logger, config, prompt
       saveSessionState(state, logger).catch(() => {
       });
     }
+    const prePruneTokens = getCurrentTokenUsage(state, output.messages);
     prune(state, logger, config, output.messages);
+    stripStaleCompressCalls(output.messages);
     assignMessageRefs(state, output.messages);
     await injectExtendedSubAgentResults(
       client,
@@ -9825,7 +10152,19 @@ 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,
+      prePruneTokens
     );
     injectMessageIds(state, config, output.messages, compressionPriorities);
     applyPendingManualTrigger(state, output.messages, logger);
@@ -10231,7 +10570,8 @@ var server = (async (ctx) => {
         decompress: createDecompressTool(compressToolContext),
         prune: createPruneTool(compressToolContext),
         search_context: createSearchContextTool(compressToolContext),
-        acp_status: createAcpStatusTool(compressToolContext)
+        acp_status: createAcpStatusTool(compressToolContext),
+        acp_context_recap: createAcpContextRecapTool(compressToolContext)
       }
     },
     config: async (opencodeConfig) => {