opencode-acp 1.18.1-pr.439.185 → 1.18.2-pr.440.187

package/dist/index.js

@@ -903,6 +903,7 @@ var VALID_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "compress.protectUserMessages",
   "compress.maxSummaryLengthHard",
   "compress.minCompressRange",
+  "compress.smartPlanRequired",
   "compress.minNudgeGrowthRatio",
   "compress.minNudgeGrowthFloor",
   "compress.emergencyThresholdPercent",
@@ -1151,6 +1152,13 @@ function validateConfigTypes(config) {
           actual: `${compress.minCompressRange}`
         });
       }
+      if (compress.smartPlanRequired !== void 0 && typeof compress.smartPlanRequired !== "boolean") {
+        errors.push({
+          key: "compress.smartPlanRequired",
+          expected: "boolean",
+          actual: typeof compress.smartPlanRequired
+        });
+      }
       if (compress.minNudgeGrowthRatio !== void 0 && typeof compress.minNudgeGrowthRatio !== "number") {
         errors.push({
           key: "compress.minNudgeGrowthRatio",
@@ -1396,6 +1404,7 @@ function validateConfigTypes(config) {
         protectedTools: "stringArray",
         maxSummaryLengthHard: "positiveNumber",
         minCompressRange: "nonNegativeNumber",
+        smartPlanRequired: "boolean",
         maxVisibleSegments: "positiveNumber",
         keepEmbedMaxChars: "nonNegativeNumber",
         preserveRecentMessages: "nonNegativeNumber",
@@ -1773,6 +1782,7 @@ var defaultConfig = {
     protectUserMessages: false,
     maxSummaryLengthHard: 2e4,
     minCompressRange: 5e3,
+    smartPlanRequired: false,
     minNudgeGrowthRatio: 0.45,
     minNudgeGrowthFloor: 5e3,
     nudgeGrowthTokens: 5e4,
@@ -1947,6 +1957,7 @@ function mergeCompress(base, override) {
     protectUserMessages: override.protectUserMessages ?? base.protectUserMessages,
     maxSummaryLengthHard: override.maxSummaryLengthHard ?? base.maxSummaryLengthHard,
     minCompressRange: override.minCompressRange ?? base.minCompressRange,
+    smartPlanRequired: override.smartPlanRequired ?? base.smartPlanRequired,
     minNudgeGrowthRatio: override.minNudgeGrowthRatio ?? base.minNudgeGrowthRatio,
     minNudgeGrowthFloor: override.minNudgeGrowthFloor ?? base.minNudgeGrowthFloor,
     emergencyThresholdPercent: override.emergencyThresholdPercent ?? base.emergencyThresholdPercent,
@@ -2756,11 +2767,6 @@ function resetOnCompaction(state) {
     compressBaselineSet: false,
     lastProcessedCompressMessageId: void 0
   };
-  state.messageIds = {
-    byRawId: /* @__PURE__ */ new Map(),
-    byRef: /* @__PURE__ */ new Map(),
-    nextRef: 1
-  };
 }
 function resolveEffectiveContextLimit(state, config) {
   if (typeof state.modelContextLimit === "number" && state.modelContextLimit > 0) {
@@ -3124,6 +3130,52 @@ function assignMessageRefs(state, messages) {
   }
   return assigned;
 }
+function repairNonMonotonicMessageRefs(state, messages) {
+  const eligible = messages.filter((message) => {
+    if (isIgnoredUserMessage(message)) return false;
+    const id = message.info.id;
+    return typeof id === "string" && id.length > 0 && !id.startsWith("msg_dcp_summary_") && !id.startsWith("msg_dcp_text_");
+  });
+  let previous = 0;
+  let corrupted = false;
+  for (const message of eligible) {
+    const ref = state.messageIds.byRawId.get(message.info.id);
+    const parsed = ref ? parseMessageRef(ref) : null;
+    if (parsed === null) continue;
+    if (parsed <= previous) {
+      corrupted = true;
+      break;
+    }
+    previous = parsed;
+  }
+  if (!corrupted) return false;
+  const oldRawIds = [...state.messageIds.byRawId.keys()];
+  state.messageIds.byRawId.clear();
+  state.messageIds.byRef.clear();
+  state.messageIds.nextRef = 1;
+  for (const message of eligible) {
+    const rawId = message.info.id;
+    const ref = allocateNextMessageRef(state);
+    state.messageIds.byRawId.set(rawId, ref);
+    state.messageIds.byRef.set(ref, rawId);
+  }
+  for (const rawId of oldRawIds) {
+    if (state.messageIds.byRawId.has(rawId)) continue;
+    const ref = allocateNextMessageRef(state);
+    state.messageIds.byRawId.set(rawId, ref);
+    state.messageIds.byRef.set(ref, rawId);
+  }
+  for (const block of state.prune.messages.blocksById.values()) {
+    const ids = [.../* @__PURE__ */ new Set([...block.effectiveMessageIds, ...block.directMessageIds])].filter((id) => state.messageIds.byRawId.has(id)).sort(
+      (left, right) => (parseMessageRef(state.messageIds.byRawId.get(left)) ?? 0) - (parseMessageRef(state.messageIds.byRawId.get(right)) ?? 0)
+    );
+    if (ids.length === 0) continue;
+    block.startId = state.messageIds.byRawId.get(ids[0]);
+    block.endId = state.messageIds.byRawId.get(ids[ids.length - 1]);
+  }
+  state.prune.messages.structureVersion = (state.prune.messages.structureVersion ?? 0) + 1;
+  return true;
+}
 function allocateNextMessageRef(state) {
   let candidate = Number.isInteger(state.messageIds.nextRef) ? Math.max(MESSAGE_REF_MIN_INDEX, state.messageIds.nextRef) : MESSAGE_REF_MIN_INDEX;
   while (candidate <= MESSAGE_REF_MAX_INDEX) {
@@ -4661,21 +4713,21 @@ function rebuildRangeInvocation(state, input, searchContext, invocation, protect
   const runId = allocateRunId(state);
   let created = 0;
   for (const plan of plans) {
-    const filteredSelection = filterProtectedToolMessages(
+    const filteredSelection2 = filterProtectedToolMessages(
       plan.selection,
       searchContext,
       protectedTools,
       protectedFilePatterns
     );
-    if (filteredSelection.messageIds.length === 0) {
+    if (filteredSelection2.messageIds.length === 0) {
       continue;
     }
     const boundaryConsumed = extractBoundaryConsumedBlocks(
-      filteredSelection.startReference,
-      filteredSelection.endReference
+      filteredSelection2.startReference,
+      filteredSelection2.endReference
     );
     const consumedBlockIds = dedupeBlockIds([
-      ...filteredSelection.requiredBlockIds,
+      ...filteredSelection2.requiredBlockIds,
       ...boundaryConsumed
     ]);
     const blockId = allocateBlockId(state);
@@ -4694,7 +4746,7 @@ function rebuildRangeInvocation(state, input, searchContext, invocation, protect
         compressCallId: invocation.callId,
         summaryTokens
       },
-      filteredSelection,
+      filteredSelection2,
       plan.anchorMessageId,
       blockId,
       storedSummary,
@@ -7015,10 +7067,7 @@ function resolveContextTokenLimit(config, state, providerId, modelId, threshold)
   return parseLimitValue(globalLimit);
 }
 function isContextOverLimits(config, state, providerId, modelId, messages) {
-  const summaryTokenExtension = config.compress.summaryBuffer ? getActiveSummaryTokenUsage(
-    state,
-    new Set(messages.map((m) => m.info.id))
-  ) : 0;
+  const summaryTokenExtension = config.compress.summaryBuffer ? getActiveSummaryTokenUsage(state, new Set(messages.map((m) => m.info.id))) : 0;
   const resolvedMaxContextLimit = resolveContextTokenLimit(
     config,
     state,
@@ -7402,7 +7451,15 @@ function buildCompressibleRanges(messages, state, protectedTools = [], protected
       lastUserRefIdx.length = 0;
       lastUserRefIdx.push(msgInfo.length);
     }
-    msgInfo.push({ ref, refNum: rn, tokens, effectiveTokens: 0, meaningful: hasMeaningfulPart, isTool, isUser: msg.info.role === "user" });
+    msgInfo.push({
+      ref,
+      refNum: rn,
+      tokens,
+      effectiveTokens: 0,
+      meaningful: hasMeaningfulPart,
+      isTool,
+      isUser: msg.info.role === "user"
+    });
   }
   const lastUserIdx = lastUserRefIdx.length > 0 ? lastUserRefIdx[0] : -1;
   for (let i = 0; i < msgInfo.length; i++) {
@@ -7421,7 +7478,7 @@ function buildCompressibleRanges(messages, state, protectedTools = [], protected
       prevRefNum = info.refNum;
       continue;
     }
-    const hasGap = info.refNum > prevRefNum + 1;
+    const hasGap = info.refNum !== prevRefNum + 1;
     if (cur && (info.isUser && cur.count >= 3 || hasGap)) {
       groups.push(cur);
       cur = null;
@@ -7501,9 +7558,7 @@ function filterRecommendedRanges(compressible, _protectedRanges, options) {
     const effective = r.effectiveTokens ?? r.tokens;
     return effective > 0 && effective >= floor;
   });
-  const result = kept.map(
-    (r, i) => i === kept.length - 1 ? { ...r, dangerous: true } : r
-  );
+  const result = kept.map((r, i) => i === kept.length - 1 ? { ...r, dangerous: true } : r);
   log?.("filterRecommendedRanges: effective-token floor applied", {
     inputRanges: compressible.length,
     outputRanges: result.length,
@@ -7637,12 +7692,160 @@ function computeProtectedRefs(messages, state, compress) {
 }
 function excludeProtectedRanges(ranges, protectedRefs) {
   if (protectedRefs.size === 0) return ranges;
-  return ranges.filter(
-    (r) => !protectedRefs.has(r.startRef) && !protectedRefs.has(r.endRef)
+  return ranges.filter((r) => !protectedRefs.has(r.startRef) && !protectedRefs.has(r.endRef));
+}
+
+// lib/compress/smart-plan.ts
+var SMART_PLAN_TTL_MS = 10 * 60 * 1e3;
+var armedPlans = /* @__PURE__ */ new Map();
+var visibleMessageIdsBySession = /* @__PURE__ */ new Map();
+function refNumber(ref) {
+  const value = Number.parseInt(ref.slice(1), 10);
+  return Number.isFinite(value) ? value : -1;
+}
+function mergeAdjacentSafeRanges(ranges) {
+  const merged = [];
+  for (const range of ranges.filter((candidate) => !candidate.dangerous)) {
+    const previous = merged.at(-1);
+    if (previous && refNumber(range.startRef) === refNumber(previous.endRef) + 1) {
+      const previousEffective = previous.effectiveTokens ?? previous.tokens;
+      previous.endRef = range.endRef;
+      previous.count += range.count;
+      previous.tokens += range.tokens;
+      previous.effectiveTokens = previousEffective + (range.effectiveTokens ?? range.tokens);
+      continue;
+    }
+    merged.push({ ...range });
+  }
+  return merged;
+}
+function recordVisibleMessages(sessionID, messages) {
+  visibleMessageIdsBySession.set(sessionID, new Set(messages.map((message) => message.info.id)));
+}
+function getVisibleMessageIds(sessionID) {
+  return visibleMessageIdsBySession.get(sessionID);
+}
+function clearSmartPlan(sessionID) {
+  armedPlans.delete(sessionID);
+}
+function clearSmartPlanSession(sessionID) {
+  armedPlans.delete(sessionID);
+  visibleMessageIdsBySession.delete(sessionID);
+}
+function consumeSmartPlan(sessionID) {
+  armedPlans.delete(sessionID);
+}
+function filteredSelection(startId, endId, searchContext, ctx) {
+  const [resolved] = resolveRanges(
+    {
+      topic: "ACP smart plan",
+      content: [{ startId, endId, summary: "Pending model-authored summary." }]
+    },
+    searchContext,
+    ctx.state,
+    ctx.logger
+  );
+  if (!resolved) return void 0;
+  let selection = filterProtectedToolMessages(
+    resolved.selection,
+    searchContext,
+    ctx.config.compress.protectedTools,
+    ctx.config.protectedFilePatterns
+  );
+  selection = filterLastUserMessage(selection, searchContext, ctx.state, ctx.config.compress);
+  selection = filterProtectedRecentMessages(
+    selection,
+    searchContext,
+    ctx.state,
+    ctx.config.compress
+  );
+  return selection;
+}
+function armBestSmartPlan(sessionID, ranges, searchContext, ctx, visibleMessageIds, now = Date.now(), targetChars = ctx.config.compress.minCompressRange) {
+  const candidates = [];
+  for (const range of mergeAdjacentSafeRanges(ranges)) {
+    const selection = filteredSelection(range.startRef, range.endRef, searchContext, ctx);
+    if (!selection || selection.messageIds.length === 0) continue;
+    if (visibleMessageIds && !selection.messageIds.every((id) => visibleMessageIds.has(id)))
+      continue;
+    let exactChars = 0;
+    for (const messageId of selection.messageIds) {
+      const message = searchContext.rawMessagesById.get(messageId);
+      if (message) exactChars += countMessageCharacters(message);
+    }
+    if (ctx.config.compress.minCompressRange > 0 && exactChars < ctx.config.compress.minCompressRange) {
+      continue;
+    }
+    candidates.push({
+      sessionID,
+      createdAt: now,
+      structureVersion: ctx.state.prune.messages.structureVersion ?? 0,
+      startId: range.startRef,
+      endId: range.endRef,
+      exactChars,
+      messageIds: [...selection.messageIds],
+      rawStart: selection.startReference.rawIndex
+    });
+  }
+  const sufficient = candidates.filter((candidate) => candidate.exactChars >= targetChars);
+  const pool = sufficient.length > 0 ? sufficient : candidates;
+  pool.sort(
+    (a, b) => sufficient.length > 0 ? a.rawStart - b.rawStart || b.exactChars - a.exactChars : b.exactChars - a.exactChars || a.rawStart - b.rawStart
   );
+  const best = pool[0];
+  if (!best) {
+    clearSmartPlan(sessionID);
+    return void 0;
+  }
+  const { rawStart: _rawStart, ...plan } = best;
+  armedPlans.set(sessionID, plan);
+  return plan;
+}
+function validateSmartPlan(sessionID, startId, endId, messageIds, exactChars, structureVersion, now = Date.now()) {
+  const plan = armedPlans.get(sessionID);
+  const preflight = 'Use the exact SMART PLAN range from the latest ACP nudge, or call acp_status({scope:"uncompressed"}) to refresh it.';
+  if (!plan) throw new Error(`No smart compression plan is armed. ${preflight}`);
+  if (now - plan.createdAt > SMART_PLAN_TTL_MS) {
+    clearSmartPlan(sessionID);
+    throw new Error(`Smart compression plan expired. ${preflight}`);
+  }
+  if (plan.structureVersion !== structureVersion) {
+    clearSmartPlan(sessionID);
+    throw new Error(
+      `Smart compression plan is stale because compression state changed. ${preflight}`
+    );
+  }
+  if (plan.startId !== startId || plan.endId !== endId) {
+    throw new Error(
+      `Range does not match the armed smart plan (${plan.startId}-${plan.endId}). Do not sort, merge, or batch ranges.`
+    );
+  }
+  const idsMatch = plan.messageIds.length === messageIds.length && plan.messageIds.every((id, i) => id === messageIds[i]);
+  const charsDiff = Math.abs(plan.exactChars - exactChars);
+  const charsMatch = charsDiff === 0 || charsDiff <= 300 || charsDiff / Math.max(plan.exactChars, 1) < 0.02;
+  if (!idsMatch || !charsMatch) {
+    clearSmartPlan(sessionID);
+    throw new Error(
+      `Smart compression plan no longer resolves to the armed messages. ${preflight}`
+    );
+  }
+  const visibleMessageIds = getVisibleMessageIds(sessionID);
+  if (visibleMessageIds && !plan.messageIds.every((id) => visibleMessageIds.has(id))) {
+    clearSmartPlan(sessionID);
+    throw new Error(
+      `Smart compression plan moved outside the model's visible context. ${preflight}`
+    );
+  }
+  return plan;
 }
 
 // lib/compress/range.ts
+function requiresSmartPlan(smartPlanRequired, content) {
+  const isBlockCompression = content.every(
+    (entry) => entry.startId.startsWith("b") && entry.endId.startsWith("b")
+  );
+  return smartPlanRequired && !isBlockCompression;
+}
 function buildSchema(maxSummaryLengthHard) {
   return {
     topic: tool2.schema.string().optional().describe(
@@ -7705,13 +7908,32 @@ function createCompressRangeTool(factoryCtx) {
         ...ctx0,
         config: applyCompressOverrides(ctx0.config, providerId, modelId)
       };
-      const { plans: filteredPlans } = prepareExecutableRangePlans(
+      const needsSmartPlan = requiresSmartPlan(
+        ctx.config.compress.smartPlanRequired === true,
+        input.content
+      );
+      if (needsSmartPlan && input.content.length !== 1) {
+        throw new Error(
+          'Raw-message compression accepts exactly one canonical SMART PLAN range per call. Use the latest ACP nudge, or call acp_status({scope:"uncompressed"}) to refresh it.'
+        );
+      }
+      const { plans: filteredPlans, totalChars } = prepareExecutableRangePlans(
         input,
         searchContext,
         ctx.state,
         ctx.config,
         ctx.logger
       );
+      if (needsSmartPlan) {
+        validateSmartPlan(
+          toolCtx.sessionID,
+          filteredPlans[0].entry.startId,
+          filteredPlans[0].entry.endId,
+          filteredPlans[0].selection.messageIds,
+          totalChars,
+          ctx.state.prune.messages.structureVersion ?? 0
+        );
+      }
       const notifications = [];
       let preparedPlans = [];
       let totalCompressedMessages = 0;
@@ -7889,6 +8111,7 @@ function createCompressRangeTool(factoryCtx) {
           });
         }
         await finalizeSession(ctx, toolCtx, rawMessages, notifications, input.topic);
+        if (needsSmartPlan) consumeSmartPlan(toolCtx.sessionID);
       } catch (error) {
         restoreCompressionState(ctx.state, snapshot);
         ctx.state.qualityGateRetryPending = qualityGateRetryPendingBefore;
@@ -8209,7 +8432,7 @@ COMPRESSION CANDIDATES:
 - 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.
-- Listed candidates were validated against the current conversation when this nudge was built. Compress them directly; do not call \`acp_status\` before compressing. If a \`compress\` call fails on a stale ID, run \`acp_status\` once and re-issue using only the refs it reports.
+- 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>
 `;
@@ -8985,9 +9208,40 @@ var injectCompressNudges = (state, config, logger, messages, prompts, compressio
   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 shouldInjectNudge = nudgeAllowed && !nothingToCompress;
+  let shouldInjectNotice = emergencyNoTargets && noticeCadenceMet;
   let shouldInject = shouldInjectNudge || shouldInjectNotice;
+  let armedSmartPlan;
+  if (shouldInjectNudge && config.compress.smartPlanRequired === true && state.sessionId) {
+    const planningRanges = candidatesEnabled ? candidatePlan.candidates.map((candidate) => ({
+      startRef: candidate.startRef,
+      endRef: candidate.endRef,
+      count: candidate.messageCount,
+      tokens: candidate.estimatedTokens,
+      effectiveTokens: candidate.estimatedTokens,
+      toolPct: candidate.toolPct,
+      textPct: candidate.textPct
+    })) : recommendedRanges;
+    const maxLimit = resolveContextTokenLimit(config, state, providerId, modelId, "max");
+    const reclaimTargetChars = Math.max(
+      config.compress.minCompressRange,
+      maxLimit === void 0 || currentTokens === void 0 ? 0 : Math.max(0, currentTokens - maxLimit + 8192) * 4
+    );
+    armedSmartPlan = armBestSmartPlan(
+      state.sessionId,
+      planningRanges,
+      buildSearchContext(state, messages),
+      { state, config, logger },
+      new Set(messages.map((message) => message.info.id)),
+      Date.now(),
+      reclaimTargetChars
+    );
+    if (!armedSmartPlan) {
+      shouldInjectNudge = false;
+      shouldInjectNotice = emergencyOverride && noticeCadenceMet;
+      shouldInject = shouldInjectNotice;
+    }
+  }
   if (shouldInjectNudge) {
     const effectivePrompts = candidatesEnabled ? {
       ...prompts,
@@ -9195,13 +9449,22 @@ Breakdown: ${sysPart}${fmt(composition.toolTokens)} tool (${pct2(composition.too
 ${HOW_TO_COMPRESS_RULES}
 
 ${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: [{...}, {...}]`).";
+        if (armedSmartPlan) {
+          breakdown += `
+
+SMART PLAN ARMED: ${armedSmartPlan.startId}-${armedSmartPlan.endId} | ${armedSmartPlan.exactChars} effective chars`;
+          breakdown += `
+Next: compress exactly this one range now. acp_status is optional; use it only to inspect or refresh a stale plan.`;
+        } else {
+          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 += `
+      breakdown += armedSmartPlan ? `
+Use \`acp_status({scope:"uncompressed"})\` only to inspect or refresh a stale plan, or \`acp_status\` for compressed block details.` : `
 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) {
+    if (effectiveTipsVariant === "maxLimit" && shouldInjectNudge) {
       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;
@@ -10457,13 +10720,85 @@ function createAcpStatusTool(factoryCtx) {
         rawMessages = [];
       }
       hideConsumedCompressCalls(ctx.state, rawMessages);
-      return buildStatusReport({ state: ctx.state, config: ctx.config }, rawMessages, {
-        scope,
-        view,
-        tool: toolFilter,
-        sort,
-        limit
-      });
+      assignMessageRefs(ctx.state, rawMessages);
+      if (repairNonMonotonicMessageRefs(ctx.state, rawMessages)) {
+        ctx.logger.warn("Repaired non-monotonic message aliases after native compaction", {
+          session: toolCtx.sessionID,
+          messages: rawMessages.length
+        });
+        await saveSessionState(ctx.state, ctx.logger);
+      }
+      const { providerId, modelId } = getModelInfo(rawMessages);
+      const effectiveCtx = {
+        ...ctx,
+        config: applyCompressOverrides(ctx.config, providerId, modelId)
+      };
+      let smartPlanSuffix = "";
+      if (effectiveCtx.config.compress?.smartPlanRequired === true && scope === "uncompressed" && view !== "messages") {
+        const lastModelView = getVisibleMessageIds(toolCtx.sessionID);
+        const visibleRaw = rawMessages.filter((message) => {
+          const entry = effectiveCtx.state.prune.messages.byMessageId.get(message.info.id);
+          return (!entry || entry.activeBlockIds.length === 0) && (!lastModelView || lastModelView.has(message.info.id));
+        });
+        const protectedRefs = computeProtectedRefs(
+          visibleRaw,
+          effectiveCtx.state,
+          effectiveCtx.config.compress
+        );
+        const contextRanges = buildCompressibleRanges(
+          visibleRaw,
+          effectiveCtx.state,
+          effectiveCtx.config.compress.protectedTools,
+          effectiveCtx.config.protectedFilePatterns,
+          protectedRefs
+        );
+        const ranges = filterRecommendedRanges(
+          contextRanges.compressible,
+          contextRanges.protected,
+          {
+            logger: effectiveCtx.logger,
+            minEffectiveTokens: resolveEffectiveFloor(effectiveCtx.config)
+          }
+        );
+        const composition = estimateContextComposition(
+          visibleRaw,
+          effectiveCtx.state,
+          effectiveCtx.config.compress.protectedTools,
+          effectiveCtx.config.protectedFilePatterns
+        );
+        const targetLimit = resolveContextTokenLimit(
+          effectiveCtx.config,
+          effectiveCtx.state,
+          providerId,
+          modelId,
+          "max"
+        );
+        const targetChars = Math.max(
+          effectiveCtx.config.compress.minCompressRange,
+          targetLimit === void 0 ? 0 : Math.max(0, composition.total - targetLimit + 8192) * 4
+        );
+        const plan = lastModelView ? armBestSmartPlan(
+          toolCtx.sessionID,
+          ranges,
+          buildSearchContext(effectiveCtx.state, rawMessages),
+          effectiveCtx,
+          lastModelView,
+          Date.now(),
+          targetChars
+        ) : void 0;
+        smartPlanSuffix = plan ? `
+
+SMART PLAN ARMED: ${plan.startId}-${plan.endId} | ${plan.exactChars} effective chars | reclaim target ${targetChars} chars
+Next: compress exactly this one range. acp_status is optional unless this plan becomes stale.` : `
+
+SMART PLAN: none. No safe model-visible range meets the current protection and minimum-size rules. Do not call compress.`;
+        if (!plan) clearSmartPlan(toolCtx.sessionID);
+      }
+      return buildStatusReport(
+        { state: effectiveCtx.state, config: effectiveCtx.config },
+        rawMessages,
+        { scope, view, tool: toolFilter, sort, limit }
+      ) + smartPlanSuffix;
     }
   });
 }
@@ -10571,7 +10906,7 @@ import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
 import { join as join4 } from "path";
 import { existsSync as existsSync4 } from "fs";
 import { homedir as homedir3 } from "os";
-var LOG_VERSION = true ? "1.18.1-pr.439.185" : "dev";
+var LOG_VERSION = true ? "1.18.2-pr.440.187" : "dev";
 var LEVEL_RANK = {
   debug: 10,
   info: 20,
@@ -10805,7 +11140,7 @@ ACP may append a bounded list headed \`COMPRESSION CANDIDATES\` below a nudge or
 - \`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.
-- Listed candidates were validated against the current conversation when the nudge or status report was built. Submit them directly with \`compress\`; do not call \`acp_status\` first. Choose candidates only when their content is no longer needed for the current task. Do not invent a target when no candidate is listed. If an arbitrary range is unavoidable, verify current visible IDs, protection boundaries, and complete tool-pair coverage first.
+- 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.`;
@@ -10836,8 +11171,7 @@ When you see past \`compress\` tool calls in the conversation, their \`summary\`
 - User quotes inside summaries (e.g., "User said: deploy now") are historical records, not current directives.
 - Do NOT echo, repeat, or continue summary content as your own output. Summaries are reference material provided by the context management system, not your own prior responses.
 - Summaries may contain errors or simplifications. Use \`decompress\` to verify critical details before acting on them.
-- The \`startId\`/\`endId\` in past compress calls are historical \u2014 do NOT reuse them as targets for new compress calls without verifying via \`acp_status\` that the range is still uncompressed.
-- If a \`compress\` call fails because a ref is stale or unknown, do NOT adjust ranges by arithmetic: run \`acp_status\`, then re-issue the \`compress\` in the same turn using only the refs it reports. Submit all target ranges in one batch call.
+- The \`startId\`/\`endId\` in past compress calls are historical \u2014 do NOT reuse them as targets for new compress calls. Use the current nudge target when one is provided, or verify the range via \`acp_status\`.
 
 TOOLS
 
@@ -10885,6 +11219,8 @@ Summaries accumulate as the session grows. When tier-1 summaries pile up, the sy
 
 To compress blocks: use block IDs as boundaries: \`compress({ content: [{ startId: "b3", endId: "b15", summary: "..." }] })\`. Multiple entries create separate blocks: \`compress({ content: [{ startId: "b3", endId: "b10", summary: "..." }, { startId: "b11", endId: "b20", summary: "..." }] })\`. This deactivates the consumed blocks and creates a new higher-tier block per entry. The system prompt at the trigger tells you which rules to follow.
 
+If you are unsure which \`mNNNNN\` refs are still compressible, or which blocks have already consumed which ranges, call \`acp_status\` first. It returns the visible context breakdown and the compressed block list.
+
 CONTEXT BREAKDOWN
 
 When context usage passes a threshold, the system appends a breakdown showing where your context tokens are spent:
@@ -10907,7 +11243,7 @@ var SYSTEM = buildSystemPrompt(true);
 
 // lib/prompts/compress-range.ts
 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. Do not call \`acp_status\` before compressing listed candidates; if a \`compress\` call fails on a stale ID, run \`acp_status\` and re-issue using only the refs it reports.`;
+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}
 
@@ -12823,6 +13159,14 @@ ${text}`);
     hideFailedCompressCalls(output.messages);
     stripStaleMetadata(output.messages);
     dropEmptyMessages(output.messages);
+    const smartPlanEnabled = applyCompressOverrides(
+      config,
+      state.modelProviderID,
+      state.modelID
+    ).compress.smartPlanRequired;
+    if (state.sessionId && smartPlanEnabled === true) {
+      recordVisibleMessages(state.sessionId, output.messages);
+    }
     const postTokens = getCurrentTokenUsage(state, output.messages);
     if (postTokens !== void 0 && effectiveLimit) {
       const budget = effectiveLimit.limit - (state.systemPromptTokens ?? 0) - OUTPUT_RESERVE_TOKENS;
@@ -12938,6 +13282,11 @@ function createTextCompleteHandler(registry4, logger) {
 }
 function createEventHandler(registry4, logger) {
   return async (input) => {
+    if (input.event?.type === "session.idle" || input.event?.type === "session.deleted") {
+      const sessionID = input.event?.properties?.sessionID ?? input.event?.properties?.info?.id;
+      if (typeof sessionID === "string") clearSmartPlanSession(sessionID);
+      return;
+    }
     const eventTime = typeof input.event?.time === "number" && Number.isFinite(input.event.time) ? input.event.time : typeof input.event?.properties?.time === "number" && Number.isFinite(input.event.properties.time) ? input.event.properties.time : void 0;
     if (input.event.type !== "message.part.updated") {
       return;
@@ -13275,7 +13624,7 @@ var server = (async (ctx) => {
   }
   const logger = new Logger(config.debug, config.debug ? "debug" : config.logLevel);
   logger.info("ACP plugin initialized", {
-    version: true ? "1.18.1-pr.439.185" : "dev",
+    version: true ? "1.18.2-pr.440.187" : "dev",
     workspace: ctx.directory,
     logLevel: logger.level,
     debug: config.debug,