opencode-acp 1.17.1 → 1.18.0-pr.392.149

package/dist/index.js

@@ -885,6 +885,7 @@ var VALID_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "compress.permission",
   "compress.showCompression",
   "compress.summaryBuffer",
+  "compress.candidates",
   "compress.maxContextLimit",
   "compress.minContextLimit",
   "compress.modelMaxLimits",
@@ -1759,6 +1760,7 @@ var defaultConfig = {
     permission: "allow",
     showCompression: true,
     summaryBuffer: true,
+    candidates: false,
     maxContextLimit: "80%",
     minContextLimit: "80%",
     contextLimitFallback: 128e3,
@@ -1927,6 +1929,7 @@ function mergeCompress(base, override) {
     permission: override.permission ?? base.permission,
     showCompression: override.showCompression ?? base.showCompression,
     summaryBuffer: override.summaryBuffer ?? base.summaryBuffer,
+    candidates: override.candidates ?? base.candidates,
     maxContextLimit: override.maxContextLimit ?? base.maxContextLimit,
     minContextLimit: override.minContextLimit ?? base.minContextLimit,
     modelMaxLimits: override.modelMaxLimits ?? base.modelMaxLimits,
@@ -2513,12 +2516,12 @@ function serializePruneMessagesState(messagesState) {
     markedForCleanup: Array.from(messagesState.markedForCleanup)
   };
 }
-async function isSubAgentSession(client, sessionID) {
+async function getSessionParentId(client, sessionID) {
   try {
     const result = await client.session.get({ path: { id: sessionID } });
-    return !!result.data?.parentID;
+    return typeof result.data?.parentID === "string" ? result.data.parentID : void 0;
   } catch (error) {
-    return false;
+    return void 0;
   }
 }
 function findLastCompactionTimestamp(messages) {
@@ -2559,7 +2562,8 @@ function createPruneMessagesState() {
     activeByAnchorMessageId: /* @__PURE__ */ new Map(),
     nextBlockId: 1,
     nextRunId: 1,
-    markedForCleanup: /* @__PURE__ */ new Set()
+    markedForCleanup: /* @__PURE__ */ new Set(),
+    membershipsVerified: false
   };
 }
 function loadPruneMessagesState(persisted) {
@@ -3691,7 +3695,7 @@ function clampMessageRef(requested, context, state) {
   if (maxIndex < 0 || requested.index <= maxIndex) return null;
   return { ref: formatMessageRef(maxIndex) };
 }
-function resolveSelection(context, startReference, endReference) {
+function resolveSelection(context, startReference, endReference, options) {
   const startRawIndex = startReference.rawIndex;
   const endRawIndex = endReference.rawIndex;
   const messageIds = [];
@@ -3714,7 +3718,7 @@ function resolveSelection(context, startReference, endReference) {
       messageSeen.add(messageId);
       messageIds.push(messageId);
     }
-    if (!messageTokenById.has(messageId)) {
+    if (options?.includeTokenAccounting !== false && !messageTokenById.has(messageId)) {
       messageTokenById.set(messageId, estimateAllMessageTokensFast(rawMessage));
     }
     const parts = Array.isArray(rawMessage.parts) ? rawMessage.parts : [];
@@ -3825,10 +3829,10 @@ function buildBoundaryLookup(context, state) {
   }
   return lookup;
 }
-var SEARCH_CONTEXT_TOOL_DESCRIPTION = `Search through all compressed block summaries AND visible messages to find relevant content. Use this BEFORE decompressing to find the right block. Returns a hit list with block/message IDs, relevance scores, and previews.
+var SEARCH_CONTEXT_TOOL_DESCRIPTION = `Search through active compressed block summaries to find relevant content. Use this BEFORE decompressing to find the right block. Returns a hit list with block IDs, relevance scores, and previews.
 
 Examples:
-- search_context({ query: "decoder accuracy" }) \u2014 find blocks/messages about decoder accuracy
+- search_context({ query: "decoder accuracy" }) \u2014 find compressed blocks about decoder accuracy
 - search_context({ query: "training loss PPL" }) \u2014 find training results
 - search_context({ query: "architecture design", limit: 5 }) \u2014 top 5 results`;
 function countOccurrences(text, term) {
@@ -3859,7 +3863,7 @@ function createSearchContextTool(factoryCtx) {
       query: tool.schema.string().describe("Search query \u2014 keywords or phrase to find"),
       limit: tool.schema.number().optional().describe("Maximum results to return (default: 10)"),
       deep: tool.schema.boolean().optional().describe(
-        "If true, also search visible (uncompressed) messages. Slower but more thorough (default: false)"
+        "Reserved for compatibility; the current search indexes active compressed block summaries."
       )
     },
     async execute(args, toolCtx) {
@@ -4311,7 +4315,7 @@ function validateArgs(args) {
     }
   }
 }
-function resolveRanges(args, searchContext, state, logger) {
+function resolveRanges(args, searchContext, state, logger, options) {
   return args.content.map((entry, index) => {
     const normalizedEntry = {
       topic: typeof entry.topic === "string" && entry.topic.trim().length > 0 ? entry.topic.trim() : void 0,
@@ -4326,7 +4330,7 @@ function resolveRanges(args, searchContext, state, logger) {
       normalizedEntry.endId,
       logger
     );
-    const selection = resolveSelection(searchContext, startReference, endReference);
+    const selection = resolveSelection(searchContext, startReference, endReference, options);
     return {
       index,
       entry: normalizedEntry,
@@ -4359,6 +4363,54 @@ function validateNonOverlapping(plans) {
     );
   }
 }
+function prepareExecutableRangePlans(args, searchContext, state, config, logger, options) {
+  const normalizedArgs = "content" in args ? args : {
+    content: [args]
+  };
+  const resolvedPlans = resolveRanges(normalizedArgs, searchContext, state, logger, options);
+  validateNonOverlapping(resolvedPlans);
+  const plans = resolvedPlans.map((plan) => ({
+    ...plan,
+    selection: filterProtectedToolMessages(
+      plan.selection,
+      searchContext,
+      config.compress.protectedTools,
+      config.protectedFilePatterns
+    )
+  })).map((plan) => ({
+    ...plan,
+    selection: filterLastUserMessage(plan.selection, searchContext, state, config.compress)
+  })).map((plan) => ({
+    ...plan,
+    selection: filterProtectedRecentMessages(
+      plan.selection,
+      searchContext,
+      state,
+      config.compress
+    )
+  })).filter((plan) => plan.selection.messageIds.length > 0);
+  if (plans.length === 0) {
+    throw new Error(
+      "All selected messages were filtered out (protected tool outputs and/or the last user message). They must remain in visible context."
+    );
+  }
+  const counted = /* @__PURE__ */ new Set();
+  let totalChars = 0;
+  for (const plan of plans) {
+    for (const messageId of plan.selection.messageIds) {
+      if (counted.has(messageId)) continue;
+      counted.add(messageId);
+      const rawMessage = searchContext.rawMessagesById.get(messageId);
+      if (rawMessage) totalChars += countMessageCharacters(rawMessage);
+    }
+  }
+  if (config.compress.minCompressRange > 0 && totalChars < config.compress.minCompressRange) {
+    throw new Error(
+      `Range too small (${totalChars} chars, min ${config.compress.minCompressRange}). Not worth compressing \u2014 overhead exceeds savings.`
+    );
+  }
+  return { plans, totalChars };
+}
 function parseBlockPlaceholders(summary) {
   const placeholders = [];
   const regex = new RegExp(BLOCK_PLACEHOLDER_REGEX);
@@ -4430,6 +4482,7 @@ function appendMissingBlockSummaries(summary, _missingBlockIds, _summaryByBlockI
 }
 
 // lib/state/rebuild.ts
+import { createHash } from "crypto";
 function collectCompressInvocations(messages) {
   const invocations = [];
   for (const message of messages) {
@@ -4481,6 +4534,128 @@ function dedupeBlockIds(ids) {
   }
   return result;
 }
+function fingerprintMessage(message) {
+  const parts = (message.parts ?? []).map((part) => {
+    if (part.type === "text") {
+      return { type: "text", text: part.text };
+    }
+    if (part.type === "tool") {
+      if (part.tool === "compress") {
+        return { type: "tool", tool: part.tool, status: part.state?.status };
+      }
+      return {
+        type: "tool",
+        tool: part.tool,
+        status: part.state?.status,
+        input: part.state?.input,
+        output: part.state?.status === "completed" ? part.state.output : void 0
+      };
+    }
+    return { type: part.type };
+  });
+  return createHash("sha256").update(JSON.stringify({ role: message.info.role, parts })).digest("hex");
+}
+function mapForkIds(state, parent, parentMessages, forkMessages) {
+  const parentRefs = parent.messageIds?.byRef;
+  if (!parentRefs) return null;
+  const parentById = new Map(parentMessages.map((message) => [message.info.id, message]));
+  const forkById = new Map(forkMessages.map((message) => [message.info.id, message]));
+  const messages = /* @__PURE__ */ new Map();
+  const tools = /* @__PURE__ */ new Map();
+  for (const [ref, parentId] of Object.entries(parentRefs)) {
+    const forkId = state.messageIds.byRef.get(ref);
+    if (!forkId) continue;
+    const parentMessage = parentById.get(parentId);
+    const forkMessage = forkById.get(forkId);
+    if (!parentMessage || !forkMessage) continue;
+    if (fingerprintMessage(parentMessage) !== fingerprintMessage(forkMessage)) continue;
+    messages.set(parentId, forkId);
+    for (let index = 0; index < parentMessage.parts.length; index++) {
+      const parentPart = parentMessage.parts[index];
+      const forkPart = forkMessage.parts[index];
+      if (parentPart?.type === "tool" && typeof parentPart.callID === "string" && forkPart?.type === "tool" && forkPart.tool === parentPart.tool && typeof forkPart.callID === "string") {
+        tools.set(parentPart.callID, forkPart.callID);
+      }
+    }
+  }
+  return { messages, tools };
+}
+function translateIds(ids, mapped) {
+  const translated = ids.map((id) => mapped.get(id));
+  return translated.some((id) => !id) ? null : translated;
+}
+function restoreForkCompressionState(state, forkMessages, parent, parentMessages, logger) {
+  if (!parent.prune.messages || !parent.messageIds) return 0;
+  assignMessageRefs(state, forkMessages);
+  const mapped = mapForkIds(state, parent, parentMessages, forkMessages);
+  if (!mapped) return 0;
+  const parentBlocks = Object.values(parent.prune.messages.blocksById);
+  const translatedBlocks = /* @__PURE__ */ new Map();
+  for (const block of parentBlocks) {
+    const anchorMessageId = mapped.messages.get(block.anchorMessageId);
+    const compressMessageId = mapped.messages.get(block.compressMessageId);
+    const directMessageIds = translateIds(block.directMessageIds, mapped.messages);
+    const effectiveMessageIds = translateIds(block.effectiveMessageIds, mapped.messages);
+    const directToolIds = translateIds(block.directToolIds, mapped.tools);
+    const effectiveToolIds = translateIds(block.effectiveToolIds, mapped.tools);
+    const compressCallId = block.compressCallId ? mapped.tools.get(block.compressCallId) : void 0;
+    if (!anchorMessageId || !compressMessageId || !directMessageIds || !effectiveMessageIds || !directToolIds || !effectiveToolIds || block.compressCallId && !compressCallId) {
+      continue;
+    }
+    translatedBlocks.set(block.blockId, {
+      ...block,
+      anchorMessageId,
+      compressMessageId,
+      compressCallId,
+      directMessageIds,
+      directToolIds,
+      effectiveMessageIds,
+      effectiveToolIds
+    });
+  }
+  const activeParentIds = new Set(parent.prune.messages.activeBlockIds);
+  if (activeParentIds.size === 0 || Array.from(activeParentIds).some((blockId) => !translatedBlocks.has(blockId))) {
+    return 0;
+  }
+  const copiedBlockIds = new Set(translatedBlocks.keys());
+  for (const block of translatedBlocks.values()) {
+    if (block.active && [...block.consumedBlockIds, ...block.includedBlockIds].some(
+      (blockId) => !copiedBlockIds.has(blockId)
+    )) {
+      return 0;
+    }
+  }
+  const messagesState = createPruneMessagesState();
+  for (const block of translatedBlocks.values()) {
+    messagesState.blocksById.set(block.blockId, block);
+    if (block.active) {
+      messagesState.activeBlockIds.add(block.blockId);
+      messagesState.activeByAnchorMessageId.set(block.anchorMessageId, block.blockId);
+    }
+  }
+  for (const [parentMessageId, entry] of Object.entries(parent.prune.messages.byMessageId)) {
+    const forkMessageId = mapped.messages.get(parentMessageId);
+    if (!forkMessageId) continue;
+    const allBlockIds = entry.allBlockIds.filter((blockId) => copiedBlockIds.has(blockId));
+    if (allBlockIds.length === 0) continue;
+    messagesState.byMessageId.set(forkMessageId, {
+      tokenCount: entry.tokenCount,
+      allBlockIds,
+      activeBlockIds: allBlockIds.filter(
+        (blockId) => messagesState.activeBlockIds.has(blockId)
+      )
+    });
+  }
+  messagesState.nextBlockId = Math.max(parent.prune.messages.nextBlockId, ...copiedBlockIds) + 1;
+  messagesState.nextRunId = parent.prune.messages.nextRunId;
+  messagesState.membershipsVerified = true;
+  state.prune.messages = messagesState;
+  logger.info("fork: restored compression state from parent", {
+    blocks: copiedBlockIds.size,
+    activeBlocks: messagesState.activeBlockIds.size
+  });
+  return copiedBlockIds.size;
+}
 function rebuildRangeInvocation(state, input, searchContext, invocation, protectedTools, protectedFilePatterns, gcConfig, logger) {
   const plans = resolveRanges(input, searchContext, state);
   const runId = allocateRunId(state);
@@ -4547,12 +4722,7 @@ function resolveMessageEntry(entry, searchContext, state) {
     return null;
   }
   try {
-    const { startReference, endReference } = resolveBoundaryIds(
-      searchContext,
-      state,
-      ref,
-      ref
-    );
+    const { startReference, endReference } = resolveBoundaryIds(searchContext, state, ref, ref);
     const selection = resolveSelection(searchContext, startReference, endReference);
     return {
       selection,
@@ -4856,8 +5026,9 @@ async function ensureSessionInitialized(client, state, sessionId, logger, messag
   resetSessionState(state);
   state.sessionId = sessionId;
   state.storageDir = config?.storagePath ? resolveStorageDir(config.storagePath, projectDir ?? cwd()) : void 0;
-  const isSubAgent = await isSubAgentSession(client, sessionId);
-  state.isSubAgent = isSubAgent;
+  const parentSessionId = await getSessionParentId(client, sessionId);
+  const isChildSession = parentSessionId !== void 0;
+  state.isSubAgent = isChildSession;
   state.lastCompaction = findLastCompactionTimestamp(messages);
   state.currentTurn = countTurns(state, messages);
   state.nudges.turnNudgeAnchors = collectTurnNudgeAnchors(messages);
@@ -4871,13 +5042,42 @@ async function ensureSessionInitialized(client, state, sessionId, logger, messag
       );
     }
     if (config) {
-      const rebuilt = rebuildCompressionState(state, messages, config, logger);
-      if (rebuilt > 0) {
+      let restored = 0;
+      if (parentSessionId) {
+        try {
+          const parent = await loadSessionState(parentSessionId, logger);
+          const response = parent ? await client.session.messages({ path: { id: parentSessionId } }) : void 0;
+          const parentMessages = Array.isArray(response?.data) ? response.data : Array.isArray(response) ? response : [];
+          if (parent && parentMessages.length > 0) {
+            state.isSubAgent = false;
+            try {
+              restored = restoreForkCompressionState(
+                state,
+                messages,
+                parent,
+                parentMessages,
+                logger
+              );
+            } finally {
+              state.isSubAgent = isChildSession;
+            }
+          }
+        } catch (error) {
+          logger.warn("fork: parent state transfer unavailable, replaying history", {
+            parentSessionId,
+            error: error?.message
+          });
+        }
+      }
+      const rebuilt = restored > 0 ? 0 : rebuildCompressionState(state, messages, config, logger);
+      if (restored > 0 || rebuilt > 0) {
         await saveSessionState(state, logger);
       }
     }
+    state.isSubAgent = isChildSession;
     return;
   }
+  state.isSubAgent = isChildSession;
   state.prune.messages = loadPruneMessagesState(persisted.prune.messages);
   state.nudges.contextLimitAnchors = new Set(persisted.nudges.contextLimitAnchors || []);
   state.nudges.turnNudgeAnchors = /* @__PURE__ */ new Set([
@@ -6588,12 +6788,12 @@ ${afterClose}`;
 }
 
 // lib/messages/utils.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 var SUMMARY_ID_HASH_LENGTH = 16;
 var DCP_PAIRED_TAG_REGEX = /<(?:dcp|acp)[^>]*>[\s\S]*?<\/(?:dcp|acp)[^>]*>/gi;
 var DCP_UNPAIRED_TAG_REGEX = /<\/?(?:dcp|acp)[^>]*>/gi;
 var generateStableId = (prefix, seed) => {
-  const hash = createHash("sha256").update(seed).digest("hex").slice(0, SUMMARY_ID_HASH_LENGTH);
+  const hash = createHash2("sha256").update(seed).digest("hex").slice(0, SUMMARY_ID_HASH_LENGTH);
   return `${prefix}_${hash}`;
 };
 var createSyntheticMessage = (baseMessage, content, stableSeed, role = "user") => {
@@ -7590,58 +7790,13 @@ function createCompressRangeTool(factoryCtx) {
         ...ctx0,
         config: applyCompressOverrides(ctx0.config, providerId, modelId)
       };
-      const resolvedPlans = resolveRanges(input, searchContext, ctx.state, ctx.logger);
-      validateNonOverlapping(resolvedPlans);
-      const filteredPlans = resolvedPlans.map((plan) => ({
-        ...plan,
-        selection: filterProtectedToolMessages(
-          plan.selection,
-          searchContext,
-          ctx.config.compress.protectedTools,
-          ctx.config.protectedFilePatterns
-        )
-      })).map((plan) => ({
-        ...plan,
-        selection: filterLastUserMessage(
-          plan.selection,
-          searchContext,
-          ctx.state,
-          ctx.config.compress
-        )
-      })).map((plan) => ({
-        ...plan,
-        selection: filterProtectedRecentMessages(
-          plan.selection,
-          searchContext,
-          ctx.state,
-          ctx.config.compress
-        )
-      })).filter((plan) => plan.selection.messageIds.length > 0);
-      if (filteredPlans.length === 0) {
-        throw new Error(
-          "All selected messages were filtered out (protected tool outputs and/or the last user message). They must remain in visible context."
-        );
-      }
-      const minCompressRange = ctx.config.compress.minCompressRange;
-      if (minCompressRange > 0) {
-        let totalChars = 0;
-        const counted = /* @__PURE__ */ new Set();
-        for (const plan of filteredPlans) {
-          for (const messageId of plan.selection.messageIds) {
-            if (counted.has(messageId)) continue;
-            counted.add(messageId);
-            const rawMessage = searchContext.rawMessagesById.get(messageId);
-            if (rawMessage) {
-              totalChars += countMessageCharacters(rawMessage);
-            }
-          }
-        }
-        if (totalChars < minCompressRange) {
-          throw new Error(
-            `Range too small (${totalChars} chars, min ${minCompressRange}). Not worth compressing \u2014 overhead exceeds savings.`
-          );
-        }
-      }
+      const { plans: filteredPlans } = prepareExecutableRangePlans(
+        input,
+        searchContext,
+        ctx.state,
+        ctx.config,
+        ctx.logger
+      );
       const notifications = [];
       let preparedPlans = [];
       let totalCompressedMessages = 0;
@@ -7746,7 +7901,9 @@ function createCompressRangeTool(factoryCtx) {
       const bypassQuality = acknowledgeRisk && ctx.state.qualityGateRetryPending;
       const ignoredAcknowledgeRisk = acknowledgeRisk && !ctx.state.qualityGateRetryPending;
       if (ignoredAcknowledgeRisk) {
-        ctx.logger.warn("compress: acknowledgeRisk ignored \u2014 no quality gate rejection pending");
+        ctx.logger.warn(
+          "compress: acknowledgeRisk ignored \u2014 no quality gate rejection pending"
+        );
       }
       ctx.state.qualityGateRetryPending = false;
       if (!bypassQuality) {
@@ -7916,10 +8073,24 @@ function sortBlocksByCreation(a, b) {
   }
   return a.blockId - b.blockId;
 }
+function sameBlockIds(left, right) {
+  if (left.size !== right.size) return false;
+  return Array.from(left).every((id) => right.has(id));
+}
 var syncCompressionBlocks = (state, logger, messages) => {
   const messagesState = state.prune.messages;
   if (!messagesState?.blocksById?.size) {
-    return;
+    if (!messagesState.membershipsVerified) {
+      messagesState.activeBlockIds.clear();
+      messagesState.activeByAnchorMessageId.clear();
+      for (const entry of messagesState.byMessageId.values()) {
+        entry.allBlockIds = Array.isArray(entry.allBlockIds) ? [...new Set(entry.allBlockIds.filter((id) => Number.isInteger(id) && id > 0))] : [];
+        entry.activeBlockIds = [];
+      }
+      messagesState.membershipsVerified = true;
+      return true;
+    }
+    return false;
   }
   const messageIds = new Set(messages.map((msg) => msg.info.id));
   const structureVersion = messagesState.structureVersion ?? 0;
@@ -7937,11 +8108,12 @@ var syncCompressionBlocks = (state, logger, messages) => {
         previous.set(anchor, id);
       }
     }
-    return;
+    return false;
   }
   const previousActiveBlockIds = new Set(
     Array.from(messagesState.blocksById.values()).filter((block) => block.active).map((block) => block.blockId)
   );
+  const indexedActiveBlockIds = new Set(messagesState.activeBlockIds);
   messagesState.activeBlockIds.clear();
   messagesState.activeByAnchorMessageId.clear();
   const now = Date.now();
@@ -7981,10 +8153,14 @@ var syncCompressionBlocks = (state, logger, messages) => {
       messagesState.activeByAnchorMessageId.set(block.anchorMessageId, block.blockId);
     }
   }
-  for (const entry of messagesState.byMessageId.values()) {
-    const allBlockIds = Array.isArray(entry.allBlockIds) ? [...new Set(entry.allBlockIds.filter((id) => Number.isInteger(id) && id > 0))] : [];
-    entry.allBlockIds = allBlockIds;
-    entry.activeBlockIds = allBlockIds.filter((id) => messagesState.activeBlockIds.has(id));
+  const membershipsRebuilt = !messagesState.membershipsVerified || !sameBlockIds(indexedActiveBlockIds, messagesState.activeBlockIds);
+  if (membershipsRebuilt) {
+    for (const entry of messagesState.byMessageId.values()) {
+      const allBlockIds = Array.isArray(entry.allBlockIds) ? [...new Set(entry.allBlockIds.filter((id) => Number.isInteger(id) && id > 0))] : [];
+      entry.allBlockIds = allBlockIds;
+      entry.activeBlockIds = allBlockIds.filter((id) => messagesState.activeBlockIds.has(id));
+    }
+    messagesState.membershipsVerified = true;
   }
   const nextActiveBlockIds = messagesState.activeBlockIds;
   let deactivatedCount = 0;
@@ -8006,6 +8182,7 @@ var syncCompressionBlocks = (state, logger, messages) => {
     });
   }
   messagesState.lastSyncedStructureVersion = structureVersion;
+  return membershipsRebuilt || deactivatedCount > 0 || reactivatedCount > 0;
 };
 
 // lib/host-permissions.ts
@@ -8080,6 +8257,484 @@ var syncCompressPermissionState = (state, config, hostPermissions, messages) =>
   );
 };
 
+// lib/prompts/context-limit-nudge.ts
+var CONTEXT_LIMIT_NUDGE = `
+<system-reminder>
+\u26A0\uFE0F Context limit reached \u2014 time to compress the largest ranges you no longer need. Prioritize completed tool outputs and resolved work. You can decompress specific blocks later if you need details. Keeping context lean helps you stay accurate.
+
+If mid-atomic-operation, finish that step first, then compress.
+
+HOW TO CALL COMPRESS:
+{
+  "topic": "Short Label",
+  "content": [
+    {
+      "startId": "<ID from early in this conversation>",
+      "endId": "<ID from later in this conversation>",
+      "summary": "Complete technical summary of everything in the range"
+    }
+  ]
+}
+
+\u26A0\uFE0F ID RULES \u2014 MOST COMMON CAUSE OF ERRORS:
+- ONLY use IDs you can see in  tags in the messages ABOVE.
+- Do NOT copy IDs from this example. Do NOT invent IDs.
+- Do NOT use IDs from compressed block summaries \u2014 they are stale.
+- startId must appear BEFORE endId in the conversation.
+
+RANGE STRATEGY:
+- Prefer one large range over multiple small ones.
+- Compress OLDER resolved history first. Keep recent active work.
+</system-reminder>
+`;
+var CANDIDATE_GUIDANCE = `
+<system-reminder>
+COMPRESSION CANDIDATES:
+- MICRO identifies one large message or complete tool transaction.
+- EPISODE identifies a contiguous historical segment made from smaller units.
+- Candidate entries are independent and non-overlapping, so they can be batched in one \`content[]\` array.
+- Candidates are suggestions, not mandatory targets. Choose only content no longer needed for the current task and do not invent a target when none is listed.
+- Use \`acp_status\` for a fresh candidate view if the list is stale or missing.
+- When the context limit is reached and candidates are listed, select at least one clearly stale candidate and call the \`compress\` tool in your next reply. Batch only additional candidates that are also clearly stale. Do not merely recommend compression.
+</system-reminder>
+`;
+
+// lib/prompts/turn-nudge.ts
+var TURN_NUDGE = `
+<system-reminder>
+Context is getting full. If you've finished reading tool outputs or exploration results, compress them \u2014 you can decompress later if needed. This keeps your focus on the current task and improves accuracy.
+
+{
+  "topic": "Short Label",
+  "content": [{ "startId": "<visible message ID>", "endId": "<visible message ID>", "summary": "..." }]
+}
+
+\u26A0\uFE0F ONLY use IDs from  tags visible above. Do NOT invent or copy example IDs.
+</system-reminder>
+`;
+var TURN_CANDIDATE_GUIDANCE = `
+MICRO candidates are complete large messages or tool transactions. EPISODE candidates are contiguous historical segments. They are independent suggestions and may be batched, but compress only content no longer needed for the current task. Do not compress active work or every candidate.
+`;
+
+// lib/prompts/iteration-nudge.ts
+var ITERATION_NUDGE = `
+<system-reminder>
+You've been iterating for a while. If any earlier work is closed and unlikely to be referenced, compress it now.
+
+{
+  "topic": "Short Label",
+  "content": [{ "startId": "<visible message ID>", "endId": "<visible message ID>", "summary": "..." }]
+}
+
+\u26A0\uFE0F ONLY use IDs from  tags visible above. Do NOT invent or copy example IDs.
+</system-reminder>
+`;
+var ITERATION_CANDIDATE_GUIDANCE = `
+MICRO candidates are complete large messages or tool transactions. EPISODE candidates are contiguous historical segments. They are independent suggestions and may be batched, but preserve anything still needed for the current task. Do not compress active work or every candidate.
+`;
+
+// lib/messages/inject/candidates.ts
+function partToolNames(message) {
+  const names = /* @__PURE__ */ new Set();
+  for (const part of message.parts ?? []) {
+    if (part.type === "tool" && part.tool !== "compress") {
+      names.add(part.tool);
+    }
+  }
+  return [...names];
+}
+function hasNonCompressTool(message) {
+  return partToolNames(message).length > 0;
+}
+function collectToolSpans(messages) {
+  const spansByCallId = /* @__PURE__ */ new Map();
+  for (let index = 0; index < messages.length; index++) {
+    const message = messages[index];
+    if (!message) continue;
+    const callIds = /* @__PURE__ */ new Set();
+    for (const part of message.parts ?? []) {
+      if (part.type !== "tool" || part.tool === "compress" || !part.callID) continue;
+      callIds.add(part.callID);
+    }
+    for (const callID of callIds) {
+      const existing = spansByCallId.get(callID);
+      if (existing) {
+        existing.endIndex = index;
+      } else {
+        spansByCallId.set(callID, { startIndex: index, endIndex: index });
+      }
+    }
+  }
+  return [...spansByCallId.values()].sort(
+    (left, right) => left.startIndex - right.startIndex || left.endIndex - right.endIndex
+  );
+}
+function mergeOverlappingSpans(messages, spans) {
+  const merged = [];
+  for (const span of spans) {
+    const last = merged[merged.length - 1];
+    if (last && span.startIndex <= last.endIndex) {
+      last.endIndex = Math.max(last.endIndex, span.endIndex);
+    } else {
+      merged.push({ ...span });
+    }
+  }
+  const result = [];
+  let spanIndex = 0;
+  let index = 0;
+  while (index < messages.length) {
+    while (spanIndex < merged.length && merged[spanIndex].endIndex < index) {
+      spanIndex++;
+    }
+    const span = merged[spanIndex];
+    if (span?.startIndex === index) {
+      result.push(span);
+      index = span.endIndex + 1;
+      continue;
+    }
+    result.push({ startIndex: index, endIndex: index });
+    index++;
+  }
+  return result;
+}
+function buildAtomicUnits(messages, state) {
+  const omissions = [];
+  const spans = mergeOverlappingSpans(messages, collectToolSpans(messages));
+  const units = [];
+  for (const span of spans) {
+    const source = messages.slice(span.startIndex, span.endIndex + 1);
+    const refs = source.map((message) => state.messageIds.byRawId.get(message.info.id));
+    const startRef = refs[0];
+    const endRef = refs[refs.length - 1];
+    if (!startRef || !endRef) {
+      omissions.push({ kind: "micro", startRef, endRef, reason: "missing-reference" });
+      continue;
+    }
+    const invalidShape = source.some(
+      (message) => isSyntheticMessage(message) || isIgnoredUserMessage(message)
+    );
+    if (invalidShape) {
+      omissions.push({ kind: "micro", startRef, endRef, reason: "synthetic-or-ignored" });
+      continue;
+    }
+    const active = source.some((message) => {
+      const entry = state.prune.messages.byMessageId.get(message.info.id);
+      return entry !== void 0 && entry.activeBlockIds.length > 0;
+    });
+    if (active) {
+      omissions.push({ kind: "micro", startRef, endRef, reason: "active-compression" });
+      continue;
+    }
+    let isTool = false;
+    const toolNames = /* @__PURE__ */ new Set();
+    let retainedChars = 0;
+    let toolMessageCount = 0;
+    let textMessageCount = 0;
+    for (const message of source) {
+      retainedChars += countMessageCharacters(message);
+      if (hasNonCompressTool(message)) {
+        isTool = true;
+        toolMessageCount++;
+      } else {
+        textMessageCount++;
+      }
+      for (const toolName of partToolNames(message)) toolNames.add(toolName);
+    }
+    units.push({
+      startIndex: span.startIndex,
+      endIndex: span.endIndex,
+      messages: source,
+      sourceMessageIds: source.map((message) => message.info.id),
+      startRef,
+      endRef,
+      retainedChars,
+      estimatedTokens: Math.ceil(retainedChars / 4),
+      isTool,
+      toolNames: [...toolNames],
+      toolMessageCount,
+      textMessageCount
+    });
+  }
+  return { units, omissions };
+}
+function draftCandidateLabel(kind, units) {
+  if (kind === "episode") return "historical conversation segment";
+  const toolNames = [...new Set(units.flatMap((unit) => unit.toolNames))];
+  if (toolNames.length > 0) {
+    return `${toolNames.slice(0, 3).join("/")} transaction`;
+  }
+  return "large conversation message";
+}
+function mergeUnits(units) {
+  const first = units[0];
+  const last = units[units.length - 1];
+  const toolNames = /* @__PURE__ */ new Set();
+  for (const unit of units) {
+    for (const toolName of unit.toolNames) toolNames.add(toolName);
+  }
+  return {
+    startIndex: first.startIndex,
+    endIndex: last.endIndex,
+    messages: units.flatMap((unit) => unit.messages),
+    sourceMessageIds: units.flatMap((unit) => unit.sourceMessageIds),
+    startRef: first.startRef,
+    endRef: last.endRef,
+    retainedChars: units.reduce((total, unit) => total + unit.retainedChars, 0),
+    estimatedTokens: units.reduce((total, unit) => total + unit.estimatedTokens, 0),
+    isTool: units.some((unit) => unit.isTool),
+    toolNames: [...toolNames],
+    toolMessageCount: units.reduce((total, unit) => total + unit.toolMessageCount, 0),
+    textMessageCount: units.reduce((total, unit) => total + unit.textMessageCount, 0)
+  };
+}
+function buildDrafts(units, minChars, state, config, protectedRefs) {
+  const drafts = [];
+  const omissions = [];
+  const residual = [];
+  for (const unit of units) {
+    const recentProtected = unit.sourceMessageIds.some(
+      (id) => protectedRefs.has(state.messageIds.byRawId.get(id) ?? "")
+    );
+    const protectedToolOrFile = unit.messages.some(
+      (message) => messageContainsProtectedTool(
+        message,
+        config.compress.protectedTools,
+        config.protectedFilePatterns
+      )
+    );
+    if (recentProtected || protectedToolOrFile) {
+      if (residual.length > 0) {
+        const merged = mergeUnits(residual);
+        if (merged.retainedChars >= minChars) {
+          drafts.push({ kind: "episode", units: [...residual] });
+        }
+        residual.length = 0;
+      }
+      omissions.push({
+        kind: unit.retainedChars >= minChars ? "micro" : "episode",
+        startRef: unit.startRef,
+        endRef: unit.endRef,
+        reason: recentProtected ? "recent-protection" : "protected-tool-or-file"
+      });
+      continue;
+    }
+    if (unit.retainedChars > 0 && (minChars <= 0 || unit.retainedChars >= minChars)) {
+      drafts.push({ kind: "micro", units: [unit] });
+    } else if (minChars > 0 && unit.retainedChars > 0) {
+      residual.push(unit);
+    }
+  }
+  let episode = [];
+  const flushEpisode = () => {
+    if (episode.length === 0) return;
+    const merged = mergeUnits(episode);
+    if (merged.retainedChars >= minChars) {
+      drafts.push({ kind: "episode", units: [...episode] });
+    }
+    episode = [];
+  };
+  for (let index = 0; index < residual.length; index++) {
+    const unit = residual[index];
+    const previous = residual[index - 1];
+    if (previous && unit.startIndex !== previous.endIndex + 1) flushEpisode();
+    episode.push(unit);
+  }
+  flushEpisode();
+  return { drafts, omissions };
+}
+function compareIds(left, right) {
+  const leftNumber = Number.parseInt(left.slice(1), 10);
+  const rightNumber = Number.parseInt(right.slice(1), 10);
+  return leftNumber - rightNumber || left.localeCompare(right);
+}
+function candidateDraftRange(draft) {
+  return mergeUnits(draft.units);
+}
+function selectionMatchesSource(result, sourceMessageIds, unit) {
+  if (result.plans.length !== 1) return false;
+  const plan = result.plans[0];
+  if (!plan) return false;
+  if (plan.selection.startReference.rawIndex !== unit.startIndex || plan.selection.endReference.rawIndex !== unit.endIndex) {
+    return false;
+  }
+  if (plan.selection.messageIds.length !== sourceMessageIds.length) return false;
+  return plan.selection.messageIds.every((id, index) => id === sourceMessageIds[index]);
+}
+function validateDraft(draft, unit, messages, state, config, protectedRefs, prepared) {
+  const source = messages.slice(unit.startIndex, unit.endIndex + 1);
+  if (source.some(
+    (message) => protectedRefs.has(state.messageIds.byRawId.get(message.info.id) ?? "")
+  )) {
+    return {
+      omission: {
+        kind: draft.kind,
+        startRef: unit.startRef,
+        endRef: unit.endRef,
+        reason: "recent-protection"
+      }
+    };
+  }
+  if (source.some(
+    (message) => messageContainsProtectedTool(
+      message,
+      config.compress.protectedTools,
+      config.protectedFilePatterns
+    )
+  )) {
+    return {
+      omission: {
+        kind: draft.kind,
+        startRef: unit.startRef,
+        endRef: unit.endRef,
+        reason: "protected-tool-or-file"
+      }
+    };
+  }
+  if (config.compress.minCompressRange > 0 && unit.retainedChars < config.compress.minCompressRange) {
+    return {
+      omission: {
+        kind: draft.kind,
+        startRef: unit.startRef,
+        endRef: unit.endRef,
+        reason: "below-minimum"
+      }
+    };
+  }
+  try {
+    let result = prepared;
+    if (!result) {
+      const searchContext = buildSearchContext(state, messages);
+      result = prepareExecutableRangePlans(
+        {
+          content: [
+            {
+              topic: draftCandidateLabel(draft.kind, draft.units),
+              startId: unit.startRef,
+              endId: unit.endRef,
+              summary: "candidate"
+            }
+          ]
+        },
+        searchContext,
+        state,
+        config
+      );
+    }
+    if (!selectionMatchesSource(result, unit.sourceMessageIds, unit)) {
+      return {
+        omission: {
+          kind: draft.kind,
+          startRef: unit.startRef,
+          endRef: unit.endRef,
+          reason: "executor-selection-drift"
+        }
+      };
+    }
+    return {
+      candidate: {
+        kind: draft.kind,
+        startRef: unit.startRef,
+        endRef: unit.endRef,
+        messageCount: unit.sourceMessageIds.length,
+        retainedChars: unit.retainedChars,
+        estimatedTokens: unit.estimatedTokens,
+        toolPct: Math.round(unit.toolMessageCount / unit.sourceMessageIds.length * 100),
+        textPct: Math.round(unit.textMessageCount / unit.sourceMessageIds.length * 100),
+        label: draftCandidateLabel(draft.kind, draft.units),
+        sourceMessageIds: [...unit.sourceMessageIds]
+      }
+    };
+  } catch {
+    return {
+      omission: {
+        kind: draft.kind,
+        startRef: unit.startRef,
+        endRef: unit.endRef,
+        reason: "executor-rejected"
+      }
+    };
+  }
+}
+function planCompressionCandidates(messages, state, config) {
+  const protectedRefs = computeProtectedRefs(messages, state, config.compress);
+  const { units, omissions } = buildAtomicUnits(messages, state);
+  const minChars = config.compress.minCompressRange ?? 5e3;
+  const draftResult = buildDrafts(units, minChars, state, config, protectedRefs);
+  const drafts = draftResult.drafts;
+  const candidates = [];
+  const allOmissions = [...omissions, ...draftResult.omissions];
+  let batchResult;
+  try {
+    const searchContext = buildSearchContext(state, messages);
+    const entries = drafts.map((draft) => {
+      const unit = candidateDraftRange(draft);
+      return {
+        topic: draftCandidateLabel(draft.kind, draft.units),
+        startId: unit.startRef,
+        endId: unit.endRef,
+        summary: "candidate"
+      };
+    });
+    if (entries.length > 0) {
+      batchResult = prepareExecutableRangePlans(
+        { content: entries },
+        searchContext,
+        state,
+        config,
+        void 0,
+        { includeTokenAccounting: false }
+      );
+    }
+  } catch {
+  }
+  const preparedPlansByIndex = new Map(batchResult?.plans.map((plan) => [plan.index, plan]));
+  for (let draftIndex = 0; draftIndex < drafts.length; draftIndex++) {
+    const draft = drafts[draftIndex];
+    const unit = candidateDraftRange(draft);
+    const preparedPlan = preparedPlansByIndex.get(draftIndex);
+    const prepared = batchResult ? {
+      plans: preparedPlan ? [preparedPlan] : [],
+      totalChars: preparedPlan ? unit.retainedChars : 0
+    } : void 0;
+    const validated = validateDraft(
+      draft,
+      unit,
+      messages,
+      state,
+      config,
+      protectedRefs,
+      prepared
+    );
+    if ("candidate" in validated) {
+      candidates.push(validated.candidate);
+    } else {
+      allOmissions.push(validated.omission);
+    }
+  }
+  candidates.sort((left, right) => {
+    return right.estimatedTokens - left.estimatedTokens || (left.kind === "micro" ? -1 : 1) - (right.kind === "micro" ? -1 : 1) || compareIds(left.startRef, right.startRef) || compareIds(left.endRef, right.endRef);
+  });
+  const maxCandidates = 12;
+  const bounded = candidates.slice(0, maxCandidates);
+  return {
+    candidates: bounded,
+    omitted: allOmissions,
+    truncatedCount: Math.max(0, candidates.length - bounded.length)
+  };
+}
+function formatCompressionCandidates(plan) {
+  if (plan.candidates.length === 0) return "";
+  const fmt = (value) => value >= 1e3 ? `${(value / 1e3).toFixed(1)}K` : String(value);
+  const lines = plan.candidates.map((candidate) => {
+    const range = `${candidate.startRef}\u2013${candidate.endRef}`;
+    return `  ${candidate.kind.toUpperCase().padEnd(7)} ${range}  ${candidate.messageCount} msg${candidate.messageCount === 1 ? "" : "s"}  ${fmt(candidate.estimatedTokens)} tokens  ${candidate.label}`;
+  });
+  const suffix = plan.truncatedCount > 0 ? `
+  ...${plan.truncatedCount} additional candidate${plan.truncatedCount === 1 ? "" : "s"} omitted` : "";
+  return `COMPRESSION CANDIDATES (independent; batchable)
+${lines.join("\n")}${suffix}`;
+}
+
 // lib/messages/inject/inject.ts
 var ACP_SUFFIX_SEED = "acp-dynamic-guidance";
 function createSuffixMessage(messages) {
@@ -8089,7 +8744,7 @@ function createSuffixMessage(messages) {
   messages.push(synthetic);
   return synthetic;
 }
-var injectCompressNudges = (state, config, logger, messages, prompts, compressionPriorities, debugNotify, preCompressTokens) => {
+var injectCompressNudges = (state, config, logger, messages, prompts, compressionPriorities, debugNotify, preCompressTokens, candidateMessages) => {
   if (compressPermission(state, config) === "deny") {
     return;
   }
@@ -8201,7 +8856,10 @@ var injectCompressNudges = (state, config, logger, messages, prompts, compressio
           (message) => message.info.id === lastUserMessage.info.id
         );
         if (lastUserMessageIndex >= 0) {
-          const messagesSinceUser = countMessagesAfterIndex(messages, lastUserMessageIndex);
+          const messagesSinceUser = countMessagesAfterIndex(
+            messages,
+            lastUserMessageIndex
+          );
           const iterationThreshold = getIterationNudgeThreshold(config);
           if (lastMessage.index > lastUserMessageIndex && messagesSinceUser >= iterationThreshold) {
             const interval = getNudgeFrequency(config);
@@ -8276,24 +8934,69 @@ var injectCompressNudges = (state, config, logger, messages, prompts, compressio
     config.protectedFilePatterns,
     protectedRefs
   ) : { compressible: [], protected: [] };
-  const unprotectedCompressible = excludeProtectedRanges(contextRanges.compressible, protectedRefs);
+  const unprotectedCompressible = excludeProtectedRanges(
+    contextRanges.compressible,
+    protectedRefs
+  );
   const recommendedRanges = filterRecommendedRanges(
     unprotectedCompressible,
     contextRanges.protected,
     { logger, minEffectiveTokens: resolveEffectiveFloor(config) }
   );
-  const hasRecommendations = recommendedRanges.length > 0;
+  let candidatePlan = {
+    candidates: [],
+    omitted: [],
+    truncatedCount: 0
+  };
+  const candidatesEnabled = config.compress.candidates === true;
+  if (nudgeAllowed && candidatesEnabled) {
+    try {
+      candidatePlan = planCompressionCandidates(candidateMessages ?? messages, state, config);
+    } catch (error) {
+      logger.warn("Compression candidate planning failed closed", {
+        session: state.sessionId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  const candidateText = candidatesEnabled ? formatCompressionCandidates(candidatePlan) || (candidateMessages === void 0 && recommendedRanges.length > 0 ? formatCompressibleRanges(recommendedRanges, contextRanges.protected) : "") : recommendedRanges.length > 0 ? formatCompressibleRanges(recommendedRanges, contextRanges.protected) : "";
   const allProtected = contextRanges.compressible.length === 0 && contextRanges.protected.length > 0;
   const allInProtectedZone = protectedRefs.size > 0 && unprotectedCompressible.length === 0;
   const allBelowMin = contextRanges.compressible.length > 0 && recommendedRanges.length === 0;
-  const nothingToCompress = allProtected || allInProtectedZone || allBelowMin;
+  const noExecutableCandidates = candidatesEnabled && nudgeAllowed && candidateMessages !== void 0 && candidatePlan.candidates.length === 0;
+  const nothingToCompress = candidatesEnabled && candidateMessages !== void 0 ? noExecutableCandidates : allProtected || allInProtectedZone || allBelowMin;
   const emergencyNoTargets = emergencyOverride && nothingToCompress;
   const noticeCadenceMet = state.nudges.lastNudgeShownTokens === void 0 || growthSinceBaseline !== void 0 && growthSinceBaseline >= growthFloor;
   const shouldInjectNudge = nudgeAllowed && !nothingToCompress;
   const shouldInjectNotice = emergencyNoTargets && noticeCadenceMet;
   let shouldInject = shouldInjectNudge || shouldInjectNotice;
   if (shouldInjectNudge) {
-    applyAnchoredNudges(state, config, messages, prompts, compressionPriorities, currentTokens, modelContextLimit, suffixMessage);
+    const effectivePrompts = candidatesEnabled ? {
+      ...prompts,
+      contextLimitNudge: prompts.contextLimitNudge ? `${prompts.contextLimitNudge}
+
+${CANDIDATE_GUIDANCE}` : CANDIDATE_GUIDANCE,
+      turnNudge: prompts.turnNudge ? `${prompts.turnNudge}
+
+${TURN_CANDIDATE_GUIDANCE}` : TURN_CANDIDATE_GUIDANCE,
+      iterationNudge: prompts.iterationNudge ? `${prompts.iterationNudge}
+
+${ITERATION_CANDIDATE_GUIDANCE}` : ITERATION_CANDIDATE_GUIDANCE
+    } : prompts;
+    applyAnchoredNudges(
+      state,
+      config,
+      messages,
+      effectivePrompts,
+      compressionPriorities,
+      currentTokens,
+      modelContextLimit,
+      suffixMessage
+    );
+    if (candidatesEnabled && suffixMessage && candidateText && effectiveTipsVariant !== "maxLimit") {
+      const actionHint = hasPendingNudge ? "\n\n\u26A0\uFE0F This compression nudge has already been shown without a compression. If candidates are clearly stale, call the `compress` tool for one clearly stale candidate before continuing. Do not compress active work or things needed to proceed well." : "\n\n\u{1F4A1} If one listed candidate is clearly complete and no longer needed, call the `compress` tool in this reply before continuing. Do not compress active work or every candidate.";
+      appendToLastTextPart(suffixMessage, actionHint);
+    }
   }
   if (state.nudges.lastPerMessageNudgeTokens === void 0 && currentTokens !== void 0) {
     state.nudges.lastPerMessageNudgeTokens = currentTokens;
@@ -8302,14 +9005,26 @@ var injectCompressNudges = (state, config, logger, messages, prompts, compressio
   if (suffixMessage && !shouldInject) {
     const tierUsage = tierUsageEarly;
     const tierChecks = [
-      { triggerTier: 2, targetTier: 1, tokens: tierUsage.tier1Tokens, lastNudge: state.nudges.lastTier2NudgeTokens },
-      { triggerTier: 3, targetTier: 2, tokens: tierUsage.tier2Tokens, lastNudge: state.nudges.lastTier3NudgeTokens }
+      {
+        triggerTier: 2,
+        targetTier: 1,
+        tokens: tierUsage.tier1Tokens,
+        lastNudge: state.nudges.lastTier2NudgeTokens
+      },
+      {
+        triggerTier: 3,
+        targetTier: 2,
+        tokens: tierUsage.tier2Tokens,
+        lastNudge: state.nudges.lastTier3NudgeTokens
+      }
     ];
     for (const tc of tierChecks) {
       if (tc.tokens < nudgeGrowthTokens) continue;
       const cadenceMet = tc.lastNudge === void 0 || currentTokens !== void 0 && currentTokens - tc.lastNudge >= growthFloor;
       if (!cadenceMet) continue;
-      let candidates = [...state.prune.messages.activeBlockIds].map((id) => state.prune.messages.blocksById.get(id)).filter((b) => b !== void 0 && b.active && (b.tier ?? 1) === tc.targetTier).sort((a, b) => a.blockId - b.blockId);
+      let candidates = [...state.prune.messages.activeBlockIds].map((id) => state.prune.messages.blocksById.get(id)).filter(
+        (b) => b !== void 0 && b.active && (b.tier ?? 1) === tc.targetTier
+      ).sort((a, b) => a.blockId - b.blockId);
       if (candidates.length >= 2) {
         const firstId = candidates[0].blockId;
         const lastId = candidates[candidates.length - 1].blockId;
@@ -8357,7 +9072,9 @@ var injectCompressNudges = (state, config, logger, messages, prompts, compressio
       const fmt = (n) => n >= 1e3 ? `${(n / 1e3).toFixed(1)}K` : String(n);
       const sourceTier = tc.triggerTier === 2 ? "Tier 1" : "Tier 2";
       const action = tc.triggerTier === 2 ? "Distill" : "Condense";
-      const blockList = candidates.slice(0, 10).map((b) => `b${b.blockId} (age=${b.survivedCount}, ${fmt(b.summaryTokens)}tok): "${b.topic}"`).join("\n");
+      const blockList = candidates.slice(0, 10).map(
+        (b) => `b${b.blockId} (age=${b.survivedCount}, ${fmt(b.summaryTokens)}tok): "${b.topic}"`
+      ).join("\n");
       const extraCount = candidates.length > 10 ? `
 ...and ${candidates.length - 10} more` : "";
       const tierText = `
@@ -8398,7 +9115,19 @@ ${rules}`;
       usagePct,
       growthSinceBaseline,
       growthFloor,
-      recommendedRanges: recommendedRanges.length
+      candidateCount: candidatePlan.candidates.length,
+      microCandidates: candidatePlan.candidates.filter(
+        (candidate) => candidate.kind === "micro"
+      ).length,
+      episodeCandidates: candidatePlan.candidates.filter(
+        (candidate) => candidate.kind === "episode"
+      ).length,
+      estimatedCandidateTokens: candidatePlan.candidates.reduce(
+        (total, candidate) => total + candidate.estimatedTokens,
+        0
+      ),
+      omittedCandidates: candidatePlan.omitted.length,
+      truncatedCandidates: candidatePlan.truncatedCount
     });
   } else if (shouldInjectNotice) {
     logger.info("Emergency /compact notice injected (no compressible targets)", {
@@ -8409,7 +9138,7 @@ ${rules}`;
   } else if (nudgeAllowed && nothingToCompress) {
     logger.info("Nudge suppressed: nothing to compress", {
       session: state.sessionId,
-      reason: allProtected ? "all_protected" : allInProtectedZone ? "in_protected_zone" : "below_effective_floor",
+      reason: allProtected ? "all_protected" : allInProtectedZone ? "in_protected_zone" : allBelowMin ? "below_effective_floor" : "no_executable_candidates",
       currentTokens,
       usagePct,
       compressibleRanges: contextRanges.compressible.length
@@ -8421,7 +9150,7 @@ ${rules}`;
     const lines = [
       `[ACP Debug] Recommendation filter:`,
       `  Input: ${compressible.length} range(s), ${fmt(compressible.reduce((s, r) => s + r.tokens, 0))} tokens`,
-      `  Output: ${recommendedRanges.length} range(s) (last segment marked dangerous)`
+      `  Output: ${candidatePlan.candidates.length} candidate(s) (${candidatePlan.truncatedCount} truncated)`
     ];
     logger.debug(lines.join("\n"));
   }
@@ -8433,10 +9162,7 @@ ${rules}`;
       const growth = currentTokens !== void 0 && (state.nudges.lastNudgeShownTokens ?? state.nudges.lastPerMessageNudgeTokens) !== void 0 ? currentTokens - (state.nudges.lastNudgeShownTokens ?? state.nudges.lastPerMessageNudgeTokens) : 0;
       const growthStr = growth > 0 ? ` (+${fmt(growth)} since last nudge)` : "";
       const plainTextTokens = composition.textTokens;
-      const efficiencyNote = effectiveTipsVariant !== "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.
-
-${COMPRESS_PHILOSOPHY}` : "";
+      const efficiencyNote = effectiveTipsVariant !== "maxLimit" ? "\nThis is an efficiency nudge to compress early when content is no longer needed and keep context lean \u2014 not an overflow warning. A separate, stronger alert will appear if the context is actually full.\n\n" + COMPRESS_PHILOSOPHY : "";
       const sysPart = composition.systemTokens > 0 ? `${fmt(composition.systemTokens)} system (${pct2(composition.systemTokens)}%) | ` : "";
       let breakdown = `${efficiencyNote}
 Breakdown: ${sysPart}${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)}%) | ${fmt(composition.reasoningTokens)} reasoning (${pct2(composition.reasoningTokens)}%)${growthStr}`;
@@ -8445,21 +9171,20 @@ Breakdown: ${sysPart}${fmt(composition.toolTokens)} tool (${pct2(composition.too
         breakdown += `
 \u26A0\uFE0F ${fmt(composition.protectedTokens)} tokens are protected (environment-managed tools) \u2014 not compressible. Effective compressible: ~${fmt(compressibleTokens)}.`;
       }
-      if (recommendedRanges.length > 0) {
+      if (candidateText) {
         breakdown += `
 
 ${HOW_TO_COMPRESS_RULES}
 
-${formatCompressibleRanges(recommendedRanges, contextRanges.protected)}`;
-        breakdown += `
-\u{1F4A1} Compress all ranges in one call (pass multiple content entries: \`content: [{...}, {...}]\`).`;
+${candidateText}`;
+        breakdown += candidatesEnabled ? "\n\u{1F4A1} You may batch selected independent candidates in one call (pass multiple content entries: `content: [{...}, {...}]`); omit any candidate whose content is still needed." : "\n\u{1F4A1} Compress all ranges in one call (pass multiple content entries: `content: [{...}, {...}]`).";
       }
       breakdown += `
 Use \`acp_status({scope:"uncompressed"})\` to re-fetch compressible ranges after compressing, or \`acp_status\` for compressed block details.`;
       appendToLastTextPart(suffixMessage, breakdown);
     }
     if (effectiveTipsVariant === "maxLimit" && !emergencyNoTargets) {
-      tipsText = "\n\n\u26A0\uFE0F Context limit reached \u2014 compress now. Prioritize consumed tool outputs.\n\n" + HOW_TO_COMPRESS_RULES + '\n\n{ "topic": "...", "content": [{ "startId": "<ID>", "endId": "<ID>", "summary": "..." }] }\n\nOnly use IDs from visible messages above. Compress older work first.';
+      tipsText = candidatesEnabled ? "\n\n\u26A0\uFE0F Context limit reached \u2014 compress now. Select at least one listed candidate whose content is no longer needed and call the `compress` tool in your next reply. Do not merely recommend compression. Candidates are advisory about selection: preserve current intent and active work, and never compress content still needed for the current task.\n\n" + HOW_TO_COMPRESS_RULES + '\n\n{ "topic": "...", "content": [{ "startId": "<ID>", "endId": "<ID>", "summary": "..." }] }\n\nOnly use IDs from visible messages above. If several selected candidates are stale, older work may be preferable; never override semantic judgment or compress content still needed for the current task.' : "\n\n\u26A0\uFE0F Context limit reached \u2014 compress now. Prioritize consumed tool outputs.\n\n" + HOW_TO_COMPRESS_RULES + '\n\n{ "topic": "...", "content": [{ "startId": "<ID>", "endId": "<ID>", "summary": "..." }] }\n\nOnly use IDs from visible messages above. Compress older work first.';
     } else if (shouldInjectNotice) {
       const emergencyPct = currentTokens !== void 0 && modelContextLimit !== void 0 && modelContextLimit > 0 ? Math.round(currentTokens / modelContextLimit * 100) : void 0;
       tipsText = `
@@ -8474,9 +9199,7 @@ Then stop retrying and await the user's response.`;
     }
     state.nudges.lastNudgeShownTokens = currentTokens;
     {
-      const visibleMessageIds = new Set(
-        messages.map((message) => message.info.id)
-      );
+      const visibleMessageIds = new Set(messages.map((message) => message.info.id));
       const blockGuidance = buildCompressedBlockGuidance(state, {
         currentTokens,
         modelContextLimit,
@@ -9260,14 +9983,14 @@ function hideConsumedCompressCalls(state, messages) {
 }
 
 // lib/compress/status.ts
-var ACP_STATUS_TOOL_DESCRIPTION = `Show context status \u2014 overview includes compressible ranges by default.
+var ACP_STATUS_TOOL_DESCRIPTION = `Show context status \u2014 overview includes compressible ranges (compression candidates when compress.candidates is enabled).
 
-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.
+No args: Overview with totals, compressed blocks, and compressible ranges (or candidates when enabled).
+scope:"uncompressed": Compressible ranges by default (view:"candidates" when compress.candidates is enabled). Use view:"ranges" for raw grouped ranges or view:"messages" for per-message listing.
 scope:"compressed": Drill into compressed blocks \u2014 list each with full details (age, generation, consumed lineage).
 
 Use this tool to:
-- See what's consuming context + compressible ranges in one call (no args)
+- See what's consuming context + compressible targets 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")`;
@@ -9437,25 +10160,16 @@ function renderOverview(visibleMessages, summaryTokens, systemTokens, blocks, fe
       const entry = pruneMap.get(msgId);
       return !entry || entry.activeBlockIds.length === 0;
     });
-    const protectedRefs = ctx.config?.compress ? computeProtectedRefs(visibleRaw, ctx.state, ctx.config.compress) : /* @__PURE__ */ new Set();
-    const contextRanges = buildCompressibleRanges(
-      visibleRaw,
-      ctx.state,
-      ctx.config?.compress?.protectedTools ?? [],
-      ctx.config?.protectedFilePatterns ?? [],
-      protectedRefs
-    );
-    if (contextRanges.compressible.length > 0 || contextRanges.protected.length > 0) {
+    const candidates = renderCompressionCandidates(rawMessages, ctx);
+    if (candidates.length > 0) {
       lines.push("");
-      lines.push(
-        formatCompressibleRanges(contextRanges.compressible, contextRanges.protected)
-      );
+      lines.push(...candidates);
     }
   }
   lines.push("");
   const hintTool = topToolName || "bash";
   lines.push(
-    `Tip: acp_status({scope:"uncompressed", view:"messages", tool:"${hintTool}"}) for per-message listing`
+    `Tip: acp_status({scope:"uncompressed", view:"ranges"}) for raw ranges, or acp_status({scope:"uncompressed", view:"messages", tool:"${hintTool}"}) for per-message listing`
   );
   return lines;
 }
@@ -9492,6 +10206,44 @@ function renderUncompressedRanges(rawMessages, ctx) {
   lines.push(`Filter by tool: acp_status({scope:"uncompressed", view:"messages", tool:"bash"})`);
   return lines;
 }
+function renderCompressionCandidates(rawMessages, ctx) {
+  const lines = ["COMPRESSION CANDIDATES"];
+  if (!ctx.config?.compress || ctx.config.compress.candidates !== true) {
+    return renderUncompressedRanges(rawMessages, ctx);
+  }
+  try {
+    const plan = planCompressionCandidates(rawMessages, ctx.state, ctx.config);
+    const visibleMessages = rawMessages.filter((message) => {
+      const entry = ctx.state.prune.messages.byMessageId.get(message.info.id);
+      return !entry || entry.activeBlockIds.length === 0;
+    });
+    const protectedRefs = computeProtectedRefs(visibleMessages, ctx.state, ctx.config.compress);
+    const contextRanges = buildCompressibleRanges(
+      visibleMessages,
+      ctx.state,
+      ctx.config.compress.protectedTools ?? [],
+      ctx.config.protectedFilePatterns ?? [],
+      protectedRefs
+    );
+    const protectedText = formatCompressibleRanges([], contextRanges.protected);
+    if (plan.candidates.length === 0) {
+      lines.push("  (no eligible candidates)");
+      if (protectedText.includes("PROTECTED")) lines.push("", protectedText);
+      return lines;
+    }
+    lines.length = 0;
+    lines.push(formatCompressionCandidates(plan));
+    if (protectedText.includes("PROTECTED")) lines.push("", protectedText);
+    if (plan.omitted.length > 0) {
+      lines.push(
+        `  ${plan.omitted.length} structurally unsafe or undersized candidate${plan.omitted.length === 1 ? "" : "s"} omitted`
+      );
+    }
+    return lines;
+  } catch {
+    return ["COMPRESSION CANDIDATES", "  (candidate planning unavailable)"];
+  }
+}
 function renderUncompressedDrilldown(visibleMessages, toolFilter, sort, limit) {
   const lines = [];
   let filtered = visibleMessages;
@@ -9594,14 +10346,12 @@ function renderCompressedDrilldown(blocks, sort, limit, blocksById) {
 }
 function buildStatusReport(renderCtx, rawMessages, options) {
   const scope = options?.scope;
-  const view = options?.view ?? "ranges";
+  const view = options?.view ?? "candidates";
   const toolFilter = options?.tool;
   const sort = options?.sort ?? "size";
   const limit = options?.limit ?? 30;
   const msgState = renderCtx.state.prune.messages;
-  const allBlocks = Array.from(msgState.blocksById.values()).sort(
-    (a, b) => a.blockId - b.blockId
-  );
+  const allBlocks = Array.from(msgState.blocksById.values()).sort((a, b) => a.blockId - b.blockId);
   const activeBlocks = allBlocks.filter((b) => b.active);
   const lines = [];
   if (scope === "compressed") {
@@ -9615,8 +10365,10 @@ function buildStatusReport(renderCtx, rawMessages, options) {
   if (scope === "uncompressed") {
     if (view === "messages") {
       lines.push(...renderUncompressedDrilldown(visibleMsgs, toolFilter, sort, limit));
-    } else {
+    } else if (view === "ranges") {
       lines.push(...renderUncompressedRanges(rawMessages, renderCtx));
+    } else {
+      lines.push(...renderCompressionCandidates(rawMessages, renderCtx));
     }
   } else {
     lines.push(
@@ -9640,7 +10392,7 @@ function createAcpStatusTool(factoryCtx) {
     args: {
       scope: tool4.schema.string().optional().describe('Drill down: "compressed" or "uncompressed". No arg = overview of both.'),
       view: tool4.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)'
+        'Display format for scope:"uncompressed": "candidates" (default when compress.candidates is enabled \u2014 otherwise "ranges"), "ranges" (raw grouped ranges), or "messages" (per-message listing with sort/filter)'
       ),
       tool: tool4.schema.string().optional().describe(
         'Filter by tool type (only with scope:"uncompressed", view:"messages"). e.g., "bash", "todowrite", "write"'
@@ -9651,16 +10403,16 @@ function createAcpStatusTool(factoryCtx) {
     async execute(args, toolCtx) {
       const ctx = resolveToolContext(factoryCtx, toolCtx.sessionID);
       const scope = args.scope === "compressed" || args.scope === "uncompressed" ? args.scope : void 0;
-      const view = args.view === "messages" ? "messages" : "ranges";
+      const view = args.view === "messages" || args.view === "ranges" || args.view === "candidates" ? args.view : "candidates";
       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;
       if (scope === "compressed") {
-        return buildStatusReport(
-          { state: ctx.state, config: ctx.config },
-          [],
-          { scope: "compressed", sort, limit }
-        );
+        return buildStatusReport({ state: ctx.state, config: ctx.config }, [], {
+          scope: "compressed",
+          sort,
+          limit
+        });
       }
       let rawMessages = [];
       try {
@@ -9670,11 +10422,13 @@ function createAcpStatusTool(factoryCtx) {
         rawMessages = [];
       }
       hideConsumedCompressCalls(ctx.state, rawMessages);
-      return buildStatusReport(
-        { state: ctx.state, config: ctx.config },
-        rawMessages,
-        { scope, view, tool: toolFilter, sort, limit }
-      );
+      return buildStatusReport({ state: ctx.state, config: ctx.config }, rawMessages, {
+        scope,
+        view,
+        tool: toolFilter,
+        sort,
+        limit
+      });
     }
   });
 }
@@ -9782,7 +10536,7 @@ import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
 import { join as join4 } from "path";
 import { existsSync as existsSync4 } from "fs";
 import { homedir as homedir3 } from "os";
-var LOG_VERSION = true ? "1.17.1" : "dev";
+var LOG_VERSION = true ? "1.18.0-pr.392.149" : "dev";
 var LEVEL_RANK = {
   debug: 10,
   info: 20,
@@ -10005,7 +10759,32 @@ import { join as join5, dirname as dirname2 } from "path";
 import { homedir as homedir4 } from "os";
 
 // lib/prompts/system.ts
-var SYSTEM = `
+var ACP_STATUS_TOOL_LINE_RANGES = `- \`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.`;
+var ACP_STATUS_TOOL_LINE_CANDIDATES = `- \`acp_status\` \u2014 Context status with compression candidates. No args = overview + candidates. \`scope:"uncompressed"\` defaults to independent candidates; use \`view:"ranges"\` for raw grouped ranges or \`view:"messages"\` for per-message listing with \`tool\`/\`sort\` filters. \`scope:"compressed"\` shows block details.`;
+var PHILOSOPHY_TAIL_RANGES = `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.`;
+var PHILOSOPHY_TAIL_CANDIDATES = `Candidate guidance is advisory: a candidate is structurally safe to submit, not a command to compress. Preserve current intent and active work even when a candidate is displayed.`;
+var COMPRESSION_CANDIDATES_SECTION = `COMPRESSION CANDIDATES
+
+ACP may append a bounded list headed \`COMPRESSION CANDIDATES\` below a nudge or status report:
+
+- \`MICRO\` is one large plain message or one complete tool transaction, including every message needed to keep its tool call/result structure valid.
+- \`EPISODE\` is a contiguous historical segment made from smaller adjacent units.
+- Candidate ranges are independent, non-overlapping, and can be submitted together as separate \`content[]\` entries.
+- Choose candidates only when their content is no longer needed for the current task. Do not invent a target when no candidate is listed; call \`acp_status\` for a fresh view. If an arbitrary range is unavoidable, verify current visible IDs, protection boundaries, and complete tool-pair coverage first.
+- Keep summaries self-contained and use the existing \`compress\` tool. Candidate labels do not replace the semantic judgment to preserve useful context.
+- When a nudge lists a clearly stale candidate, call \`compress\` in that reply before continuing. A repeated nudge means compression was not completed; act on one clearly stale candidate rather than merely recommending compression.`;
+var BREAKDOWN_TAIL_RANGES = `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.`;
+var BREAKDOWN_TAIL_CANDIDATES = `Below the breakdown, the system may list independent compression candidates. Prefer a large stale micro-range when it removes an isolated artifact; use an episode range when a completed historical phase is more coherent as one summary. Compress only content the current step no longer needs.`;
+function buildSystemPrompt(candidatesEnabled) {
+  const acpStatusToolLine = candidatesEnabled ? ACP_STATUS_TOOL_LINE_CANDIDATES : ACP_STATUS_TOOL_LINE_RANGES;
+  const philosophyTail = candidatesEnabled ? PHILOSOPHY_TAIL_CANDIDATES : PHILOSOPHY_TAIL_RANGES;
+  const compressionCandidatesBlock = candidatesEnabled ? `
+
+${COMPRESSION_CANDIDATES_SECTION}
+
+` : "\n\n";
+  const breakdownTail = candidatesEnabled ? BREAKDOWN_TAIL_CANDIDATES : BREAKDOWN_TAIL_RANGES;
+  return `
 
 You operate in a context-constrained environment. All compression serves the primary task, but be frugal. Context management helps preserve retrieval quality, but your primary goal is completing the task at hand. Do not let context management distract from the actual work.
 
@@ -10031,7 +10810,7 @@ You have five context-management tools:
 - \`compress\` \u2014 Replace a contiguous range of older conversation with a single detailed summary you write. Use when content is genuinely consumed (no longer needed for the current task step). Single range: \`compress({ topic: "API exploration", content: [{ startId: "m00150", endId: "m00220", summary: "..." }] })\`. Batch (multiple unrelated ranges, each with its own topic): \`compress({ content: [{ topic: "Auth", startId: "m00150", endId: "m00220", summary: "..." }, { topic: "Deploy", startId: "m00300", endId: "m00350", summary: "..." }] })\`.
 - \`decompress\` \u2014 Restore a previously compressed block's content. By default restores one tier up (T2\u2192T1 summaries, not raw messages). Use \`full: true\` to restore all the way to original messages. Use \`toFile\` to write to file instead of inflating context. Example: \`decompress({ blockId: "b5" })\` or \`decompress({ blockId: "b5", toFile: "path" })\` or \`decompress({ blockId: "b5", full: true })\`.
 - \`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" })\`.
-- \`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.
+${acpStatusToolLine}
 
 COMPRESSION PHILOSOPHY
 
@@ -10039,7 +10818,7 @@ 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, 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.
+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. ${philosophyTail}
 
 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.
 
@@ -10060,9 +10839,7 @@ WHEN NOT TO COMPRESS
 - Important user messages \u2014 preserve their exact intent, constraints, and acceptance criteria verbatim, not just the most recent one.
 - Protected tool outputs (default: \`skill\` only) \u2014 hard-excluded from compression ranges, survive intact in visible context.
 
-${HOW_TO_COMPRESS_RULES}
-
-MULTI-TIER COMPRESSION
+${HOW_TO_COMPRESS_RULES}${compressionCandidatesBlock}MULTI-TIER COMPRESSION
 
 Summaries accumulate as the session grows. When tier-1 summaries pile up, the system injects a [Tier 2 Trigger] prompting you to DISTILL old blocks into a single tier-2 summary. If tier-2 summaries also accumulate, a [Tier 3 Trigger] asks you to CONDENSE them further.
 
@@ -10087,13 +10864,21 @@ Breakdown: 4.2K system (21%) | 8.0K tool (40%) | 2.0K summaries (10%) | 2.6K cod
 - "text" = plain text messages
 - "reasoning" = model thinking blocks (counted to match real API usage; freed when their message is compressed)
 
-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.
+${breakdownTail}
 
 Each compression creates a reusable summary block you can decompress later if needed.
 `;
+}
+var SYSTEM = buildSystemPrompt(true);
 
 // lib/prompts/compress-range.ts
-var COMPRESS_RANGE = `Collapse a range in the conversation into a detailed summary.
+var CANDIDATE_GUIDANCE_SECTION = `CANDIDATE GUIDANCE
+ACP may display a \`COMPRESSION CANDIDATES\` list in a nudge or \`acp_status\` report. A \`MICRO\` entry targets one large message or complete tool transaction; an \`EPISODE\` entry targets a contiguous historical segment. Displayed candidates are independent and non-overlapping, so they may be batched, but they are advisory: compress only entries whose content is no longer needed. When a nudge lists a clearly stale candidate, use its exact IDs and call \`compress\` before continuing. Keep current intent and active work visible, and use \`acp_status\` when the candidate list is stale.`;
+function buildCompressRangePrompt(candidatesEnabled) {
+  const candidateGuidanceBlock = candidatesEnabled ? `${CANDIDATE_GUIDANCE_SECTION}
+
+` : "";
+  return `Collapse a range in the conversation into a detailed summary.
 
 COMPRESSED BLOCK PLACEHOLDERS
 The system auto-detects any previously compressed blocks whose anchor messages fall inside your selected range. You do NOT need to manually list \`(bN)\` placeholders in your summary \u2014 every consumed block is tracked automatically.
@@ -10123,7 +10908,7 @@ Rules:
 
 - Pick \`startId\` and \`endId\` directly from injected IDs in context.
 - IDs must exist in the current visible context. If you cannot see an ID in the messages above, it is stale and will fail.
-- \`startId\` must appear before \`endId\`.
+- Prefer \`startId\` before \`endId\` in conversation order. ACP can normalize reversed boundaries, but do not rely on that behavior.
 - Do not invent IDs. Use only IDs that are present in context.
 - NEVER use IDs from compressed block summaries, previous nudges, or your own memory \u2014 only IDs currently visible as XML metadata tags in the conversation.
 
@@ -10140,7 +10925,7 @@ compress({ content: [
 ]})
 \`\`\`
 
-KEEP AND REF MARKERS
+${candidateGuidanceBlock}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.
@@ -10157,65 +10942,8 @@ The rest of the bash calls were repetitive export commands. See [[REF:m00078|tes
 
 Use KEEP sparingly \u2014 each expansion adds to the summary length. Prefer REF for content that is important but not immediately critical.
 `;
-
-// lib/prompts/context-limit-nudge.ts
-var CONTEXT_LIMIT_NUDGE = `
-<system-reminder>
-\u26A0\uFE0F Context limit reached \u2014 time to compress the largest ranges you no longer need. Prioritize completed tool outputs and resolved work. You can decompress specific blocks later if you need details. Keeping context lean helps you stay accurate.
-
-If mid-atomic-operation, finish that step first, then compress.
-
-HOW TO CALL COMPRESS:
-{
-  "topic": "Short Label",
-  "content": [
-    {
-      "startId": "<ID from early in this conversation>",
-      "endId": "<ID from later in this conversation>",
-      "summary": "Complete technical summary of everything in the range"
-    }
-  ]
-}
-
-\u26A0\uFE0F ID RULES \u2014 MOST COMMON CAUSE OF ERRORS:
-- ONLY use IDs you can see in  tags in the messages ABOVE.
-- Do NOT copy IDs from this example. Do NOT invent IDs.
-- Do NOT use IDs from compressed block summaries \u2014 they are stale.
-- startId must appear BEFORE endId in the conversation.
-
-RANGE STRATEGY:
-- Prefer one large range over multiple small ones.
-- Compress OLDER resolved history first. Keep recent active work.
-</system-reminder>
-`;
-
-// lib/prompts/turn-nudge.ts
-var TURN_NUDGE = `
-<system-reminder>
-Context is getting full. If you've finished reading tool outputs or exploration results, compress them \u2014 you can decompress later if needed. This keeps your focus on the current task and improves accuracy.
-
-{
-  "topic": "Short Label",
-  "content": [{ "startId": "<visible message ID>", "endId": "<visible message ID>", "summary": "..." }]
 }
-
-\u26A0\uFE0F ONLY use IDs from  tags visible above. Do NOT invent or copy example IDs.
-</system-reminder>
-`;
-
-// lib/prompts/iteration-nudge.ts
-var ITERATION_NUDGE = `
-<system-reminder>
-You've been iterating for a while. If any earlier work is closed and unlikely to be referenced, compress it now.
-
-{
-  "topic": "Short Label",
-  "content": [{ "startId": "<visible message ID>", "endId": "<visible message ID>", "summary": "..." }]
-}
-
-\u26A0\uFE0F ONLY use IDs from  tags visible above. Do NOT invent or copy example IDs.
-</system-reminder>
-`;
+var COMPRESS_RANGE = buildCompressRangePrompt(true);
 
 // lib/prompts/extensions/system.ts
 var SUBAGENT_SYSTEM_EXTENSION = `<dcp-system-reminder>
@@ -10307,24 +11035,27 @@ var HTML_COMMENT_REGEX = /<!--[\s\S]*?-->/g;
 var LEGACY_INLINE_COMMENT_LINE_REGEX = /^[ \t]*\/\/.*?\/\/[ \t]*$/gm;
 var DCP_SYSTEM_REMINDER_TAG_REGEX = /^\s*<dcp-system-reminder\b[^>]*>[\s\S]*<\/(?:dcp|acp)-system-reminder>\s*$/i;
 var DEFAULTS_README_FILE = "README.md";
-var BUNDLED_EDITABLE_PROMPTS = {
-  system: SYSTEM,
-  compressRange: COMPRESS_RANGE,
-  contextLimitNudge: CONTEXT_LIMIT_NUDGE,
-  turnNudge: TURN_NUDGE,
-  iterationNudge: ITERATION_NUDGE
-};
+function getBundledEditablePrompts(candidatesEnabled) {
+  return {
+    system: buildSystemPrompt(candidatesEnabled),
+    compressRange: buildCompressRangePrompt(candidatesEnabled),
+    contextLimitNudge: CONTEXT_LIMIT_NUDGE,
+    turnNudge: TURN_NUDGE,
+    iterationNudge: ITERATION_NUDGE
+  };
+}
 var INTERNAL_PROMPT_EXTENSIONS = {
   subagentExtension: SUBAGENT_SYSTEM_EXTENSION,
   decompressExtension: DECOMPRESS_SYSTEM_EXTENSION
 };
-function createBundledRuntimePrompts() {
+function createBundledRuntimePrompts(candidatesEnabled) {
+  const bundled = getBundledEditablePrompts(candidatesEnabled);
   return {
-    system: BUNDLED_EDITABLE_PROMPTS.system,
-    compressRange: BUNDLED_EDITABLE_PROMPTS.compressRange,
-    contextLimitNudge: BUNDLED_EDITABLE_PROMPTS.contextLimitNudge,
-    turnNudge: BUNDLED_EDITABLE_PROMPTS.turnNudge,
-    iterationNudge: BUNDLED_EDITABLE_PROMPTS.iterationNudge,
+    system: bundled.system,
+    compressRange: bundled.compressRange,
+    contextLimitNudge: bundled.contextLimitNudge,
+    turnNudge: bundled.turnNudge,
+    iterationNudge: bundled.iterationNudge,
     subagentExtension: INTERNAL_PROMPT_EXTENSIONS.subagentExtension,
     decompressExtension: INTERNAL_PROMPT_EXTENSIONS.decompressExtension
   };
@@ -10469,12 +11200,14 @@ var PromptStore = class {
   logger;
   paths;
   customPromptsEnabled;
+  candidatesEnabled;
   runtimePrompts;
-  constructor(logger, workingDirectory, customPromptsEnabled = false) {
+  constructor(logger, workingDirectory, customPromptsEnabled = false, candidatesEnabled = false) {
     this.logger = logger;
     this.paths = resolvePromptPaths(workingDirectory);
     this.customPromptsEnabled = customPromptsEnabled;
-    this.runtimePrompts = createBundledRuntimePrompts();
+    this.candidatesEnabled = candidatesEnabled;
+    this.runtimePrompts = createBundledRuntimePrompts(this.candidatesEnabled);
     if (this.customPromptsEnabled) {
       this.ensureDefaultFiles();
     }
@@ -10484,13 +11217,13 @@ var PromptStore = class {
     return { ...this.runtimePrompts };
   }
   reload() {
-    const nextPrompts = createBundledRuntimePrompts();
+    const nextPrompts = createBundledRuntimePrompts(this.candidatesEnabled);
     if (!this.customPromptsEnabled) {
       this.runtimePrompts = nextPrompts;
       return;
     }
     for (const definition of PROMPT_DEFINITIONS) {
-      const bundledSource = BUNDLED_EDITABLE_PROMPTS[definition.runtimeField];
+      const bundledSource = getBundledEditablePrompts(this.candidatesEnabled)[definition.runtimeField];
       const bundledEditable = toEditablePromptText(definition, bundledSource);
       const bundledRuntime = wrapRuntimePromptContent(definition, bundledEditable);
       const fallbackValue = bundledRuntime || bundledSource.trim();
@@ -10551,13 +11284,14 @@ var PromptStore = class {
       });
       return;
     }
+    const bundledPrompts = getBundledEditablePrompts(this.candidatesEnabled);
     for (const definition of PROMPT_DEFINITIONS) {
       const bundledEditable = toEditablePromptText(
         definition,
-        BUNDLED_EDITABLE_PROMPTS[definition.runtimeField]
+        bundledPrompts[definition.runtimeField]
       );
       const managedContent = buildDefaultPromptFileContent(
-        bundledEditable || BUNDLED_EDITABLE_PROMPTS[definition.runtimeField]
+        bundledEditable || bundledPrompts[definition.runtimeField]
       );
       const filePath = join5(this.paths.defaultsDir, definition.fileName);
       try {
@@ -12002,8 +12736,8 @@ function createChatMessageTransformHandler(client, registry4, logger, config, pr
     cacheSystemPromptTokens(state, output.messages);
     assignMessageRefs(state, output.messages);
     const activeBlockCountBefore = state.prune.messages.activeBlockIds.size;
-    syncCompressionBlocks(state, logger, output.messages);
-    if (state.prune.messages.activeBlockIds.size !== activeBlockCountBefore) {
+    const compressionStateChanged = syncCompressionBlocks(state, logger, output.messages);
+    if (compressionStateChanged || state.prune.messages.activeBlockIds.size !== activeBlockCountBefore) {
       saveSessionState(state, logger).catch(() => {
       });
     }
@@ -12015,9 +12749,8 @@ function createChatMessageTransformHandler(client, registry4, logger, config, pr
       });
     }
     const prePruneTokens = getCurrentTokenUsage(state, output.messages);
+    const candidateMessages = output.messages.slice();
     prune(state, logger, config, output.messages);
-    truncateLargeToolOutputs(state, config, logger, output.messages);
-    enforceContextBudget(state, config, logger, output.messages);
     hideConsumedCompressCalls(state, output.messages);
     assignMessageRefs(state, output.messages);
     const compressionPriorities = buildPriorityMap(config, state, output.messages);
@@ -12042,8 +12775,16 @@ ${text}`);
         }).catch(() => {
         });
       } : void 0,
-      prePruneTokens
+      prePruneTokens,
+      candidateMessages
+    );
+    truncateLargeToolOutputs(
+      state,
+      config,
+      logger,
+      output.messages.filter((message) => !isSyntheticMessage(message))
     );
+    enforceContextBudget(state, config, logger, output.messages);
     injectMessageIds(state, config, output.messages, compressionPriorities);
     hideFailedCompressCalls(output.messages);
     stripStaleMetadata(output.messages);
@@ -12478,7 +13219,7 @@ var server = (async (ctx) => {
   }
   const logger = new Logger(config.debug, config.debug ? "debug" : config.logLevel);
   logger.info("ACP plugin initialized", {
-    version: true ? "1.17.1" : "dev",
+    version: true ? "1.18.0-pr.392.149" : "dev",
     workspace: ctx.directory,
     logLevel: logger.level,
     debug: config.debug,
@@ -12486,7 +13227,12 @@ var server = (async (ctx) => {
     secureMode: isSecureMode()
   });
   const registry4 = new SessionStateRegistry(logger, ctx.directory);
-  const prompts = new PromptStore(logger, ctx.directory, config.experimental.customPrompts);
+  const prompts = new PromptStore(
+    logger,
+    ctx.directory,
+    config.experimental.customPrompts,
+    config.compress.candidates === true
+  );
   const hostPermissions = {
     global: void 0,
     agents: {}