opencode-acp 1.18.1 → 1.18.2

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) {
@@ -3949,7 +4001,7 @@ function createSearchContextTool(factoryCtx) {
 
 // lib/protected-patterns.ts
 function normalizePath(input) {
-  return input.replaceAll("\\\\", "/");
+  return input.replaceAll("\\", "/");
 }
 function escapeRegExpChar(ch) {
   return /[\\.^$+{}()|\[\]]/.test(ch) ? `\\${ch}` : ch;
@@ -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,
@@ -6822,6 +6874,33 @@ function buildToolIdList(state, messages) {
 var stripHallucinationsFromString = (text) => {
   return text.replace(DCP_PAIRED_TAG_REGEX, "").replace(DCP_UNPAIRED_TAG_REGEX, "");
 };
+var LEAKED_TRAILING_REF_REGEX = /(?:^|\n)[ \t]*(?:m(\d{4,5})|b([1-9]\d*))\b/g;
+var stripLeakedTrailingRefs = (text, bounds) => {
+  if (typeof text !== "string" || text.length === 0) {
+    return text;
+  }
+  const rawMessageBound = bounds.nextMessageRef;
+  const rawBlockBound = bounds.nextBlockRef;
+  const messageBound = typeof rawMessageBound === "number" && Number.isInteger(rawMessageBound) ? rawMessageBound : null;
+  const blockBound = typeof rawBlockBound === "number" && Number.isInteger(rawBlockBound) ? rawBlockBound : null;
+  if (messageBound === null && blockBound === null) {
+    return text;
+  }
+  const pattern = new RegExp(LEAKED_TRAILING_REF_REGEX.source, "g");
+  let match;
+  while ((match = pattern.exec(text)) !== null) {
+    if (match[1] !== void 0) {
+      if (messageBound !== null && Number(match[1]) >= messageBound) {
+        return text.slice(0, match.index).replace(/[ \t\r\n]*$/, "");
+      }
+    } else if (match[2] !== void 0) {
+      if (blockBound !== null && Number(match[2]) >= blockBound) {
+        return text.slice(0, match.index).replace(/[ \t\r\n]*$/, "");
+      }
+    }
+  }
+  return text;
+};
 var stripHallucinations = (messages) => {
   for (const message of messages) {
     for (const part of message.parts) {
@@ -6988,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,
@@ -7375,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++) {
@@ -7394,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;
@@ -7474,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,
@@ -7610,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(
@@ -7678,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;
@@ -7862,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;
@@ -8958,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,
@@ -9168,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;
@@ -10430,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;
     }
   });
 }
@@ -10544,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" : "dev";
+var LOG_VERSION = true ? "1.18.2" : "dev";
 var LEVEL_RANK = {
   debug: 10,
   info: 20,
@@ -10809,7 +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.
+- 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
 
@@ -12797,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;
@@ -12884,13 +13254,39 @@ function createCommandExecuteHandler(client, registry4, logger, config, workingD
     }
   };
 }
-function createTextCompleteHandler() {
-  return async (_input, output) => {
-    output.text = stripHallucinationsFromString(output.text);
+function createTextCompleteHandler(registry4, logger) {
+  return async (input, output) => {
+    if (typeof output.text !== "string" || output.text.length === 0) {
+      return;
+    }
+    let text = stripHallucinationsFromString(output.text);
+    const state = typeof input.sessionID === "string" ? registry4.get(input.sessionID) : void 0;
+    if (state) {
+      const nextBlockId = state.prune?.messages?.nextBlockId;
+      const stripped = stripLeakedTrailingRefs(text, {
+        nextMessageRef: Number.isInteger(state.messageIds.nextRef) ? state.messageIds.nextRef : null,
+        nextBlockRef: Number.isInteger(nextBlockId) ? nextBlockId : null
+      });
+      if (stripped !== text) {
+        logger.warn("Stripped leaked trailing ACP ref from assistant output", {
+          sessionID: input.sessionID,
+          messageID: input.messageID,
+          removedChars: text.length - stripped.length,
+          removedTailPreview: text.slice(stripped.length, stripped.length + 200)
+        });
+        text = stripped;
+      }
+    }
+    output.text = text;
   };
 }
 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;
@@ -13228,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" : "dev",
+    version: true ? "1.18.2" : "dev",
     workspace: ctx.directory,
     logLevel: logger.level,
     debug: config.debug,
@@ -13293,7 +13689,7 @@ var server = (async (ctx) => {
         hostPermissions
       )
     ),
-    "experimental.text.complete": guard(createTextCompleteHandler()),
+    "experimental.text.complete": guard(createTextCompleteHandler(registry4, logger)),
     "command.execute.before": guard(
       createCommandExecuteHandler(
         ctx.client,