opencode-acp 1.8.2 → 1.9.0

package/dist/index.js

@@ -1497,7 +1497,7 @@ var defaultConfig = {
     protectedTools: [...COMPRESS_DEFAULT_PROTECTED_TOOLS],
     protectTags: false,
     protectUserMessages: false,
-    maxSummaryLengthHard: 4e3,
+    maxSummaryLengthHard: 1e4,
     minCompressRange: 2e3
   },
   strategies: {
@@ -2245,20 +2245,39 @@ function resolveBoundaryIds(context, state, startId, endId) {
   }
   let startReference = lookup.get(parsedStartId.ref);
   let endReference = lookup.get(parsedEndId.ref);
+  if (!startReference && parsedStartId.kind === "message") {
+    const clamped = clampMessageRef(parsedStartId, context, state);
+    if (clamped) {
+      startReference = lookup.get(clamped.ref);
+      if (startReference) {
+        parsedStartId.ref = clamped.ref;
+      }
+    }
+  }
+  if (!endReference && parsedEndId.kind === "message") {
+    const clamped = clampMessageRef(parsedEndId, context, state);
+    if (clamped) {
+      endReference = lookup.get(clamped.ref);
+      if (endReference) {
+        parsedEndId.ref = clamped.ref;
+      }
+    }
+  }
   if (!startReference) {
     issues.push(
-      `startId ${parsedStartId.ref} is not available in the current conversation context. Choose an injected ID visible in context.`
+      `startId ${parsedStartId.ref} is not available \u2014 likely consumed by an existing block.`
     );
   }
   if (!endReference) {
     issues.push(
-      `endId ${parsedEndId.ref} is not available in the current conversation context. Choose an injected ID visible in context.`
+      `endId ${parsedEndId.ref} is not available \u2014 likely consumed by an existing block.`
     );
   }
   if (issues.length > 0) {
-    throw new Error(
-      issues.length === 1 ? issues[0] : issues.map((issue) => `- ${issue}`).join("\n")
-    );
+    const hint = buildBoundaryRecoveryHint(context, state);
+    const body = issues.length === 1 ? issues[0] : issues.map((issue) => `- ${issue}`).join("\n");
+    throw new Error(hint ? `${body}
+${hint}` : body);
   }
   if (!startReference || !endReference) {
     throw new Error("Failed to resolve boundary IDs");
@@ -2268,6 +2287,40 @@ function resolveBoundaryIds(context, state, startId, endId) {
   }
   return { startReference, endReference };
 }
+function buildBoundaryRecoveryHint(context, state) {
+  const visibleRefs = [];
+  for (const [messageRef, messageId] of state.messageIds.byRef) {
+    if (context.rawMessagesById.has(messageId)) {
+      visibleRefs.push(messageRef);
+    }
+  }
+  const parts = [];
+  if (visibleRefs.length > 0) {
+    visibleRefs.sort();
+    const first = visibleRefs[0];
+    const last = visibleRefs[visibleRefs.length - 1];
+    parts.push(`Current visible: ${first}\u2013${last} (${visibleRefs.length} msgs).`);
+  }
+  const blockCount = context.summaryByBlockId.size;
+  if (blockCount > 0) {
+    parts.push(`${blockCount} active compressed block${blockCount === 1 ? "" : "s"}.`);
+  }
+  if (parts.length === 0) {
+    return "";
+  }
+  return `${parts.join(" ")} Call acp_status() to see which blocks consumed which IDs, then retry with valid IDs.`;
+}
+function clampMessageRef(requested, context, state) {
+  if (state.messageIds.byRef.has(requested.ref)) return null;
+  let maxIndex = -1;
+  for (const [messageRef, messageId] of state.messageIds.byRef) {
+    if (!context.rawMessagesById.has(messageId)) continue;
+    const idx = parseMessageRef(messageRef);
+    if (idx !== null && idx > maxIndex) maxIndex = idx;
+  }
+  if (maxIndex < 0 || requested.index <= maxIndex) return null;
+  return { ref: formatMessageRef(maxIndex) };
+}
 function resolveSelection(context, startReference, endReference) {
   const startRawIndex = startReference.rawIndex;
   const endRawIndex = endReference.rawIndex;
@@ -3188,6 +3241,7 @@ function resetOnCompaction(state) {
     iterationNudgeAnchors: /* @__PURE__ */ new Set(),
     lastPerMessageNudgeTurn: 0,
     lastPerMessageNudgeTokens: void 0,
+    lastToolOutputNudgeTokens: void 0,
     shouldInjectThisTurn: void 0
   };
   state.messageIds = {
@@ -3198,38 +3252,45 @@ function resetOnCompaction(state) {
 }
 
 // lib/state/persistence.ts
-var LEGACY_STORAGE_DIR = join2(
-  process.env.XDG_DATA_HOME || join2(homedir2(), ".local", "share"),
-  "opencode",
-  "storage",
-  "plugin",
-  "dcp"
-);
-var STORAGE_DIR = join2(
-  process.env.XDG_DATA_HOME || join2(homedir2(), ".local", "share"),
-  "opencode",
-  "storage",
-  "plugin",
-  "acp"
-);
+function getLegacyStorageDir() {
+  return join2(
+    process.env.XDG_DATA_HOME || join2(homedir2(), ".local", "share"),
+    "opencode",
+    "storage",
+    "plugin",
+    "dcp"
+  );
+}
+function getStorageDir() {
+  return join2(
+    process.env.XDG_DATA_HOME || join2(homedir2(), ".local", "share"),
+    "opencode",
+    "storage",
+    "plugin",
+    "acp"
+  );
+}
 function migrateFromLegacyIfNeeded(logger) {
-  if (existsSyncSync(STORAGE_DIR)) return;
-  if (!existsSyncSync(LEGACY_STORAGE_DIR)) return;
+  const storageDir = getStorageDir();
+  const legacyDir = getLegacyStorageDir();
+  if (existsSyncSync(storageDir)) return;
+  if (!existsSyncSync(legacyDir)) return;
   try {
-    cpSync(LEGACY_STORAGE_DIR, STORAGE_DIR, { recursive: true });
-    logger.info(`[ACP] Migrated storage from ${LEGACY_STORAGE_DIR} \u2192 ${STORAGE_DIR}`);
+    cpSync(legacyDir, storageDir, { recursive: true });
+    logger.info(`[ACP] Migrated storage from ${legacyDir} \u2192 ${storageDir}`);
   } catch (e) {
     logger.warn(`[ACP] Storage migration failed: ${e.message}`);
   }
 }
 async function ensureStorageDir(logger) {
-  if (!existsSync2(STORAGE_DIR)) {
+  const storageDir = getStorageDir();
+  if (!existsSync2(storageDir)) {
     migrateFromLegacyIfNeeded(logger);
-    await fs.mkdir(STORAGE_DIR, { recursive: true });
+    await fs.mkdir(storageDir, { recursive: true });
   }
 }
 function getSessionFilePath(sessionId) {
-  return join2(STORAGE_DIR, `${sessionId}.json`);
+  return join2(getStorageDir(), `${sessionId}.json`);
 }
 async function writePersistedSessionState(sessionId, state, logger) {
   await ensureStorageDir(logger);
@@ -3256,7 +3317,8 @@ async function saveSessionState(sessionState, logger, sessionName) {
       turnNudgeAnchors: Array.from(sessionState.nudges.turnNudgeAnchors),
       iterationNudgeAnchors: Array.from(sessionState.nudges.iterationNudgeAnchors),
       lastPerMessageNudgeTurn: sessionState.nudges.lastPerMessageNudgeTurn ?? 0,
-      lastPerMessageNudgeTokens: sessionState.nudges.lastPerMessageNudgeTokens
+      lastPerMessageNudgeTokens: sessionState.nudges.lastPerMessageNudgeTokens,
+      lastToolOutputNudgeTokens: sessionState.nudges.lastToolOutputNudgeTokens
     },
     stats: sessionState.stats,
     lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
@@ -3355,14 +3417,15 @@ async function loadAllSessionStats(logger) {
     sessionCount: 0
   };
   try {
-    if (!existsSync2(STORAGE_DIR)) {
+    const storageDir = getStorageDir();
+    if (!existsSync2(storageDir)) {
       return result;
     }
-    const files = await fs.readdir(STORAGE_DIR);
+    const files = await fs.readdir(storageDir);
     const jsonFiles = files.filter((f) => f.endsWith(".json"));
     for (const file of jsonFiles) {
       try {
-        const filePath = join2(STORAGE_DIR, file);
+        const filePath = join2(storageDir, file);
         const content = await fs.readFile(filePath, "utf-8");
         const state = JSON.parse(content);
         if (state?.stats?.totalPruneTokens && state?.prune) {
@@ -3473,6 +3536,7 @@ function createSessionState() {
       iterationNudgeAnchors: /* @__PURE__ */ new Set(),
       lastPerMessageNudgeTurn: 0,
       lastPerMessageNudgeTokens: void 0,
+      lastToolOutputNudgeTokens: void 0,
       shouldInjectThisTurn: void 0
     },
     stats: {
@@ -3513,6 +3577,7 @@ function resetSessionState(state) {
     iterationNudgeAnchors: /* @__PURE__ */ new Set(),
     lastPerMessageNudgeTurn: 0,
     lastPerMessageNudgeTokens: void 0,
+    lastToolOutputNudgeTokens: void 0,
     shouldInjectThisTurn: void 0
   };
   state.stats = {
@@ -3560,6 +3625,7 @@ async function ensureSessionInitialized(client, state, sessionId, logger, messag
   );
   state.nudges.lastPerMessageNudgeTurn = persisted.nudges.lastPerMessageNudgeTurn ?? 0;
   state.nudges.lastPerMessageNudgeTokens = persisted.nudges.lastPerMessageNudgeTokens;
+  state.nudges.lastToolOutputNudgeTokens = persisted.nudges.lastToolOutputNudgeTokens;
   state.stats = {
     pruneTokenCounter: persisted.stats?.pruneTokenCounter || 0,
     totalPruneTokens: persisted.stats?.totalPruneTokens || 0
@@ -4589,7 +4655,7 @@ ${output}`);
 }
 
 // lib/compress/message.ts
-function buildSchema() {
+function buildSchema(maxSummaryLengthHard) {
   return {
     topic: tool2.schema.string().describe(
       "Short label (3-5 words) for the overall batch - e.g., 'Closed Research Notes'"
@@ -4603,7 +4669,7 @@ function buildSchema() {
         )
       })
     ).describe("Batch of individual message summaries to create in one tool call"),
-    summaryMaxChars: tool2.schema.number().optional().describe("Override max summary length (default max: 4000 chars). Use when content is important and needs more detail \u2014 don't lose critical info just to fit the limit.")
+    summaryMaxChars: tool2.schema.number().optional().describe(`Override max summary length (default max: ${maxSummaryLengthHard} chars). Use when content is important and needs more detail \u2014 don't lose critical info just to fit the limit.`)
   };
 }
 function createCompressMessageTool(ctx) {
@@ -4611,7 +4677,7 @@ function createCompressMessageTool(ctx) {
   const runtimePrompts = ctx.prompts.getRuntimePrompts();
   return tool2({
     description: runtimePrompts.compressMessage + MESSAGE_FORMAT_EXTENSION,
-    args: buildSchema(),
+    args: buildSchema(ctx.config.compress.maxSummaryLengthHard),
     async execute(args, toolCtx) {
       const input = args;
       validateArgs(input);
@@ -4867,7 +4933,7 @@ function appendMissingBlockSummaries(summary, _missingBlockIds, _summaryByBlockI
 }
 
 // lib/compress/range.ts
-function buildSchema2() {
+function buildSchema2(maxSummaryLengthHard) {
   return {
     topic: tool3.schema.string().describe("Short label (3-5 words) for display - e.g., 'Auth System Exploration'"),
     content: tool3.schema.array(
@@ -4883,7 +4949,7 @@ function buildSchema2() {
     ).describe(
       "One or more ranges to compress, each with start/end boundaries and a summary"
     ),
-    summaryMaxChars: tool3.schema.number().optional().describe("Override max summary length (default max: 4000 chars). Use when content is important and needs more detail \u2014 don't lose critical info just to fit the limit.")
+    summaryMaxChars: tool3.schema.number().optional().describe(`Override max summary length (default max: ${maxSummaryLengthHard} chars). Use when content is important and needs more detail \u2014 don't lose critical info just to fit the limit.`)
   };
 }
 function createCompressRangeTool(ctx) {
@@ -4891,7 +4957,7 @@ function createCompressRangeTool(ctx) {
   const runtimePrompts = ctx.prompts.getRuntimePrompts();
   return tool3({
     description: runtimePrompts.compressRange + RANGE_FORMAT_EXTENSION,
-    args: buildSchema2(),
+    args: buildSchema2(ctx.config.compress.maxSummaryLengthHard),
     async execute(args, toolCtx) {
       const input = args;
       validateArgs2(input);
@@ -5062,10 +5128,11 @@ import { tool as tool4 } from "@opencode-ai/plugin";
 // lib/messages/utils.ts
 import { createHash } from "crypto";
 var SUMMARY_ID_HASH_LENGTH = 16;
-var MERGED_SUMMARY_HEADER = (blockId) => `[ACP compressed context summary (block ${blockId}) \u2014 prior conversation recap]
+var MERGED_SUMMARY_HEADER = (blockId) => `<acp-compression-summary>
+[ACP model-generated recap (block ${blockId}) \u2014 NOT a user message]
 `;
 var MERGED_SUMMARY_FOOTER = `
-[End ACP compressed context summary]
+</acp-compression-summary>
 
 `;
 var DCP_BLOCK_ID_TAG_REGEX = /(<dcp-message-id(?=[\s>])[^>]*>)b\d+(<\/(?:dcp|acp)-message-id>)/g;
@@ -5076,33 +5143,54 @@ var generateStableId = (prefix, seed) => {
   const hash = createHash("sha256").update(seed).digest("hex").slice(0, SUMMARY_ID_HASH_LENGTH);
   return `${prefix}_${hash}`;
 };
-var createSyntheticUserMessage = (baseMessage, content, stableSeed) => {
-  const userInfo = baseMessage.info;
+var createSyntheticMessage = (baseMessage, content, stableSeed, role = "user") => {
+  const baseInfo = baseMessage.info;
   const now = Date.now();
-  const deterministicSeed = stableSeed?.trim() || userInfo.id;
+  const deterministicSeed = stableSeed?.trim() || baseInfo.id;
   const messageId = generateStableId("msg_dcp_summary", deterministicSeed);
   const partId = generateStableId("prt_dcp_summary", deterministicSeed);
-  return {
-    info: {
+  const parts = [
+    {
+      id: partId,
+      sessionID: baseInfo.sessionID,
+      messageID: messageId,
+      type: "text",
+      text: content,
+      synthetic: true
+    }
+  ];
+  if (role === "assistant") {
+    const isAssistant = baseInfo.role === "assistant";
+    const assistantBase = isAssistant ? baseInfo : void 0;
+    const userModel = !isAssistant ? baseInfo.model : void 0;
+    const info2 = {
       id: messageId,
-      sessionID: userInfo.sessionID,
-      role: "user",
-      agent: userInfo.agent,
-      model: userInfo.model,
-      time: { created: now }
-    },
-    parts: [
-      {
-        id: partId,
-        sessionID: userInfo.sessionID,
-        messageID: messageId,
-        type: "text",
-        text: content,
-        synthetic: true
-      }
-    ]
+      sessionID: baseInfo.sessionID,
+      role: "assistant",
+      time: { created: now },
+      parentID: assistantBase?.parentID ?? "",
+      modelID: assistantBase?.modelID ?? userModel?.modelID ?? "",
+      providerID: assistantBase?.providerID ?? userModel?.providerID ?? "",
+      mode: assistantBase?.mode ?? "code",
+      agent: baseInfo.agent ?? "code",
+      path: assistantBase?.path ?? { cwd: "", root: "" },
+      cost: 0,
+      tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } }
+    };
+    return { info: info2, parts };
+  }
+  const userInfo = baseInfo;
+  const info = {
+    id: messageId,
+    sessionID: userInfo.sessionID,
+    role: "user",
+    agent: userInfo.agent,
+    model: userInfo.model,
+    time: { created: now }
   };
+  return { info, parts };
 };
+var createSyntheticUserMessage = (baseMessage, content, stableSeed) => createSyntheticMessage(baseMessage, content, stableSeed, "user");
 var prependCompressionSummary = (message, summary, blockId) => {
   const parts = Array.isArray(message.parts) ? message.parts : [];
   const header = MERGED_SUMMARY_HEADER(blockId);
@@ -5241,6 +5329,11 @@ var stripHallucinations = (messages) => {
 };
 
 // lib/messages/prune.ts
+var STANDALONE_SUMMARY_HEADER = (blockId) => `<acp-compression-summary>
+[ACP model-generated recap (block ${blockId}) \u2014 NOT a user message]
+`;
+var STANDALONE_SUMMARY_FOOTER = `
+</acp-compression-summary>`;
 var prune = (state, logger, config, messages) => {
   filterCompressedRanges(state, logger, config, messages);
   stripStepMarkers(messages);
@@ -5303,41 +5396,18 @@ var filterCompressedRanges = (state, logger, config, messages) => {
             summaryLength: summaryContent.length
           });
         } else {
-          const userMessage = getLastUserMessage(messages, i);
+          const taggedContent = STANDALONE_SUMMARY_HEADER(summary.blockId) + summaryContent + STANDALONE_SUMMARY_FOOTER;
           const summarySeed = `${summary.blockId}:${summary.anchorMessageId}`;
-          if (userMessage) {
-            result.push(
-              createSyntheticUserMessage(userMessage, summaryContent, summarySeed)
-            );
-            logger.info("Injected compress summary", {
-              anchorMessageId: msgId,
-              summaryLength: summaryContent.length
-            });
-          } else {
-            const anchorInfo = msg.info;
-            const fallbackBase = {
-              info: {
-                id: anchorInfo.id || msgId,
-                sessionID: anchorInfo.sessionID || "",
-                role: "user",
-                agent: anchorInfo.agent || "code",
-                model: anchorInfo.model || {
-                  providerID: "",
-                  modelID: "",
-                  variant: void 0
-                },
-                time: { created: anchorInfo.time?.created || Date.now() }
-              },
-              parts: []
-            };
-            result.push(
-              createSyntheticUserMessage(fallbackBase, summaryContent, summarySeed)
-            );
-            logger.info("Injected compress summary (fallback, no preceding user message)", {
-              anchorMessageId: msgId,
-              summaryLength: summaryContent.length
-            });
-          }
+          const userMessage = getLastUserMessage(messages, i);
+          const baseForSummary = userMessage ?? msg;
+          result.push(
+            createSyntheticMessage(baseForSummary, taggedContent, summarySeed, "assistant")
+          );
+          logger.info("Injected compress summary as assistant role", {
+            anchorMessageId: msgId,
+            summaryLength: taggedContent.length,
+            hadUserBase: userMessage !== null
+          });
         }
       }
     }
@@ -5797,12 +5867,15 @@ function isContextOverLimits(config, state, providerId, modelId, messages) {
   };
 }
 function computeShouldNudge(params) {
-  const { currentTokens, modelContextLimit, overMinLimit, overMaxLimit } = params;
-  const contextPct = modelContextLimit && currentTokens ? currentTokens / modelContextLimit * 100 : 0;
-  const lastNudgeTokens = params.lastNudgeTokens;
-  const growthSinceLastNudge = (currentTokens ?? 0) - (lastNudgeTokens ?? 0);
-  const frequencyTriggered = lastNudgeTokens === void 0 || growthSinceLastNudge >= params.nudgeGrowthTokens || overMaxLimit;
-  const shouldNudge = contextPct >= params.minNudgeContextPercent && frequencyTriggered;
+  const { currentTokens, overMinLimit, overMaxLimit } = params;
+  if (currentTokens === void 0) {
+    return { shouldNudge: false, tipsVariant: null };
+  }
+  if (params.lastNudgeTokens === void 0) {
+    return { shouldNudge: false, tipsVariant: null };
+  }
+  const growthSinceLastNudge = currentTokens - params.lastNudgeTokens;
+  const shouldNudge = growthSinceLastNudge >= params.nudgeGrowthTokens || overMaxLimit;
   if (!shouldNudge) {
     return { shouldNudge: false, tipsVariant: null };
   }
@@ -5932,7 +6005,7 @@ function buildContextUsageGuidance(config, currentTokens, modelContextLimit) {
   return `
 
 Context: ${formatK(currentTokens)} tokens.
-All compression serves the primary task, but be frugal. Context capacity is precious \u2014 compress waste promptly. Save context by compressing consumed outputs, not by avoiding tools. Compress by need, not by percentage.`;
+All compression serves the primary task, but be frugal. Context capacity is precious. Save context by compressing consumed outputs, not by avoiding tools. Compress by need, not by percentage.`;
 }
 function applyAnchoredNudges(state, config, messages, prompts, compressionPriorities, currentTokens, modelContextLimit, suffixMessage) {
   const turnNudgeAnchors = collectTurnNudgeAnchors2(state, config, messages);
@@ -6014,6 +6087,85 @@ function applyAnchoredNudges(state, config, messages, prompts, compressionPriori
     ""
   );
 }
+function estimateCodeTokens(text) {
+  let codeChars = 0;
+  let inCode = false;
+  for (const line of text.split("\n")) {
+    if (line.trim().startsWith("```")) {
+      inCode = !inCode;
+      codeChars += line.length + 1;
+      continue;
+    }
+    if (inCode) codeChars += line.length + 1;
+  }
+  return Math.round(codeChars / 4);
+}
+function estimateContextComposition(messages, state) {
+  let toolTokens = 0;
+  let codeTokens = 0;
+  let summaryTokens = 0;
+  let messageTokens = 0;
+  const perMessage = [];
+  const perTool = [];
+  const perCode = [];
+  const perText = [];
+  for (const msg of messages) {
+    const text = (msg.parts || []).filter((p) => p.type === "text").map((p) => p.text || "").join("");
+    const msgId = msg.info?.id || "";
+    const isSummary = msgId.startsWith("msg_dcp_summary") || text.includes("[Compressed conversation section]");
+    let msgTotal = 0;
+    let msgTool = 0;
+    let msgCode = 0;
+    let msgText = 0;
+    for (const part of msg.parts || []) {
+      if (part.type === "text" && typeof part.text === "string") {
+        const partText = part.text;
+        const tokens = Math.round(partText.length / 4);
+        msgTotal += tokens;
+        if (isSummary) {
+          summaryTokens += tokens;
+        } else {
+          messageTokens += tokens;
+          msgText += tokens;
+          const cTokens = estimateCodeTokens(partText);
+          if (cTokens > 0) {
+            codeTokens += cTokens;
+            msgCode += cTokens;
+          }
+        }
+      } else if (part.type !== "text" && part.type !== "reasoning") {
+        const raw = JSON.stringify(part);
+        const tokens = Math.round(raw.length / 4);
+        msgTotal += tokens;
+        toolTokens += tokens;
+        msgTool += tokens;
+      }
+    }
+    if (!isSummary) {
+      const ref = state?.messageIds?.byRawId?.get(msgId) || "?";
+      if (msgTotal > 500) perMessage.push({ ref, tokens: msgTotal });
+      if (msgTool > 500) perTool.push({ ref, tokens: msgTool });
+      if (msgCode > 300) perCode.push({ ref, tokens: msgCode });
+      if (msgText > 500 && msgCode === 0) perText.push({ ref, tokens: msgText });
+    }
+  }
+  perMessage.sort((a, b) => b.tokens - a.tokens);
+  perTool.sort((a, b) => b.tokens - a.tokens);
+  perCode.sort((a, b) => b.tokens - a.tokens);
+  perText.sort((a, b) => b.tokens - a.tokens);
+  return {
+    toolTokens,
+    codeTokens,
+    summaryTokens,
+    messageTokens,
+    textTokens: Math.max(0, messageTokens - codeTokens),
+    total: toolTokens + summaryTokens + messageTokens,
+    largestRanges: perMessage.slice(0, 10),
+    largestToolRanges: perTool.slice(0, 5),
+    largestCodeRanges: perCode.slice(0, 5),
+    largestMessageRanges: perText.slice(0, 5)
+  };
+}
 
 // lib/messages/inject/inject.ts
 var ACP_SUFFIX_SEED = "acp-dynamic-guidance";
@@ -6046,7 +6198,8 @@ var injectCompressNudges = (state, config, logger, messages, prompts, compressio
     state.nudges.turnNudgeAnchors.clear();
     state.nudges.iterationNudgeAnchors.clear();
     state.nudges.lastPerMessageNudgeTokens = currentTokens;
-    void saveSessionState(state, logger);
+    saveSessionState(state, logger).catch(() => {
+    });
     return;
   }
   let anchorsChanged = false;
@@ -6109,6 +6262,10 @@ var injectCompressNudges = (state, config, logger, messages, prompts, compressio
   }
   const suffixMessage = createSuffixMessage(messages);
   applyAnchoredNudges(state, config, messages, prompts, compressionPriorities, currentTokens, modelContextLimit, suffixMessage);
+  const nudgeGrowthTokens = config.compress?.nudgeGrowthTokens ?? resolveAdaptiveNudgeGrowth(modelContextLimit);
+  if (currentTokens !== void 0 && state.nudges.lastPerMessageNudgeTokens !== void 0 && currentTokens < state.nudges.lastPerMessageNudgeTokens - nudgeGrowthTokens) {
+    state.nudges.lastPerMessageNudgeTokens = currentTokens;
+  }
   const decision = computeShouldNudge({
     currentTokens,
     modelContextLimit,
@@ -6116,18 +6273,65 @@ var injectCompressNudges = (state, config, logger, messages, prompts, compressio
     overMaxLimit,
     lastNudgeTokens: state.nudges.lastPerMessageNudgeTokens,
     minNudgeContextPercent: config.compress?.minNudgeContextPercent ?? 15,
-    nudgeGrowthTokens: config.compress?.nudgeGrowthTokens ?? resolveAdaptiveNudgeGrowth(modelContextLimit)
+    nudgeGrowthTokens
   });
   state.nudges.shouldInjectThisTurn = decision.shouldNudge;
+  if (state.nudges.lastPerMessageNudgeTokens === void 0 && currentTokens !== void 0) {
+    state.nudges.lastPerMessageNudgeTokens = currentTokens;
+  }
+  const composition = estimateContextComposition(messages, state);
+  const toolOutputThreshold = config.compress?.toolOutputNudgeThreshold ?? 5e3;
+  let toolOutputReminder = null;
+  if (composition.toolTokens > 0) {
+    if (state.nudges.lastToolOutputNudgeTokens === void 0) {
+      state.nudges.lastToolOutputNudgeTokens = composition.toolTokens;
+    } else {
+      const toolGrowth = composition.toolTokens - state.nudges.lastToolOutputNudgeTokens;
+      if (toolGrowth >= toolOutputThreshold) {
+        const fmt = (n) => n >= 1e3 ? `${(n / 1e3).toFixed(1)}K` : String(n);
+        const topRanges = composition.largestRanges.slice(0, 5).map((r) => `${r.ref} (${fmt(r.tokens)})`).join(", ");
+        toolOutputReminder = `
+
+\u26A0\uFE0F ${fmt(toolGrowth)} new tool outputs accumulated (${fmt(composition.toolTokens)} total). Largest: ${topRanges}. Use compress tool to compress these ranges now.`;
+        state.nudges.lastToolOutputNudgeTokens = composition.toolTokens;
+        anchorsChanged = true;
+      }
+    }
+  }
   let tipsText = null;
   if (decision.shouldNudge) {
     injectContextUsage(suffixMessage, config, currentTokens, modelContextLimit);
+    if (suffixMessage && composition.total > 0) {
+      const fmt = (n) => n >= 1e3 ? `${(n / 1e3).toFixed(1)}K` : String(n);
+      const pct = (n) => Math.round(n / composition.total * 100);
+      const growth = currentTokens !== void 0 && state.nudges.lastPerMessageNudgeTokens !== void 0 ? currentTokens - state.nudges.lastPerMessageNudgeTokens : 0;
+      const growthStr = growth > 0 ? ` (+${fmt(growth)} since last nudge)` : "";
+      const plainTextTokens = composition.textTokens;
+      let breakdown = `
+Breakdown: ${fmt(composition.toolTokens)} tool (${pct(composition.toolTokens)}%) | ${fmt(composition.summaryTokens)} summaries (${pct(composition.summaryTokens)}%) | ${fmt(composition.codeTokens)} code (${pct(composition.codeTokens)}%) | ${fmt(plainTextTokens)} text (${pct(plainTextTokens)}%)${growthStr}`;
+      const topBlocks = Array.from(state.prune.messages.blocksById.values()).filter((b) => b.active).sort((a, b) => b.compressedTokens - a.compressedTokens).slice(0, 3);
+      if (topBlocks.length > 0) {
+        breakdown += `
+Top blocks: ${topBlocks.map((b) => `b${b.blockId} ${fmt(b.compressedTokens)}\u2192${fmt(b.summaryTokens)}`).join(", ")}`;
+      }
+      breakdown += `
+\u{1F4A1} Compress incrementally \u2014 compress the largest consumed ranges first.`;
+      if (composition.largestToolRanges.length > 0) {
+        breakdown += `
+Largest tool outputs: ${composition.largestToolRanges.map((r) => `${r.ref} (${fmt(r.tokens)})`).join(", ")}`;
+      }
+      if (composition.largestCodeRanges.length > 0) {
+        breakdown += `
+Largest code messages: ${composition.largestCodeRanges.map((r) => `${r.ref} (${fmt(r.tokens)})`).join(", ")}`;
+      }
+      if (composition.largestMessageRanges.length > 0) {
+        breakdown += `
+Largest text messages: ${composition.largestMessageRanges.map((r) => `${r.ref} (${fmt(r.tokens)})`).join(", ")}`;
+      }
+      appendToLastTextPart(suffixMessage, breakdown);
+    }
     if (decision.tipsVariant === "maxLimit") {
       tipsText = '\n\n\u26A0\uFE0F Context limit reached \u2014 compress now. Prioritize consumed tool outputs.\n\n{ "topic": "...", "content": [{ "startId": "<ID>", "endId": "<ID>", "summary": "..." }] }\n\nOnly use IDs from visible messages above. Compress older work first.';
-    } else if (decision.tipsVariant === "minLimit") {
-      tipsText = "\n\n\u26A0\uFE0F Context is growing \u2014 consider compressing older work. Tools: compress, decompress, search_context.";
-    } else {
-      tipsText = "\n\n\u{1F4A1} Tools: compress, decompress, search_context.";
     }
     state.nudges.lastPerMessageNudgeTokens = currentTokens;
     state.nudges.lastPerMessageNudgeTurn = state.currentTurn ?? 0;
@@ -6150,11 +6354,30 @@ var injectCompressNudges = (state, config, logger, messages, prompts, compressio
     }
     injectVisibleIdRange(state, messages, suffixMessage);
   }
+  if (toolOutputReminder && suffixMessage) {
+    if (!decision.shouldNudge) {
+      injectContextUsage(suffixMessage, config, currentTokens, modelContextLimit);
+      if (composition.total > 0) {
+        const fmt2 = (n) => n >= 1e3 ? `${(n / 1e3).toFixed(1)}K` : String(n);
+        const pct2 = (n) => Math.round(n / composition.total * 100);
+        const topBlocks = Array.from(state.prune.messages.blocksById.values()).filter((b) => b.active).sort((a, b) => b.compressedTokens - a.compressedTokens).slice(0, 3);
+        let mini = `
+Breakdown: ${fmt2(composition.toolTokens)} tool outputs (${pct2(composition.toolTokens)}%) | ${fmt2(composition.summaryTokens)} summaries (${pct2(composition.summaryTokens)}%) | ${fmt2(composition.messageTokens)} messages (${pct2(composition.messageTokens)}%)`;
+        if (topBlocks.length > 0) {
+          mini += `
+Top blocks: ${topBlocks.map((b) => `b${b.blockId} ${fmt2(b.compressedTokens)}\u2192${fmt2(b.summaryTokens)}`).join(", ")}`;
+        }
+        appendToLastTextPart(suffixMessage, mini);
+      }
+    }
+    appendToLastTextPart(suffixMessage, toolOutputReminder);
+  }
   if (suffixMessage) {
     appendToLastTextPart(suffixMessage, "\n");
   }
   if (anchorsChanged) {
-    void saveSessionState(state, logger);
+    saveSessionState(state, logger).catch(() => {
+    });
   }
 };
 function injectContextUsage(target, config, currentTokens, modelContextLimit) {
@@ -6728,45 +6951,107 @@ ${content}`;
 
 // lib/compress/status.ts
 import { tool as tool5 } from "@opencode-ai/plugin";
-var ACP_STATUS_TOOL_DESCRIPTION = `Show detailed status of all active compressed context blocks. Returns a table of block IDs, summary sizes, ages, and topics \u2014 use this to decide which blocks to decompress or search. No arguments needed.
+var ACP_STATUS_TOOL_DESCRIPTION = `Show detailed status of all active compressed context blocks. Returns block IDs, sizes, ages, topics, and the message-ID ranges each block consumed \u2014 use this to see what has been compressed away and to choose safe compress boundaries.
 
 Use this tool when:
-- You need to know what content has been compressed away
+- You are unsure which mNNNNN refs are still compressible
+- Before choosing compress boundaries, if any prior compressions exist
 - You want to see block sizes before deciding to decompress
-- You need a quick overview of context compression state`;
+- A compress call failed with "not available" (the ID was likely consumed)
+
+Args:
+- mode: "summary" (default) \u2014 one line per block with size/range/topic. "detailed" \u2014 adds age, generation, effective message count, consumed block lineage.
+- sort: "recent" (default) | "size" (largest compressed first) | "age" (oldest surviving first, nearing GC).
+- limit: max blocks to show (default 30).`;
 function formatTokens(n) {
+  if (!Number.isFinite(n) || n <= 0) return "0";
   return n >= 1e3 ? `${(n / 1e3).toFixed(1)}K` : String(n);
 }
+function formatSizePair(compressed, summary) {
+  return `${formatTokens(compressed)}\u2192${formatTokens(summary)}`;
+}
+function formatIdRange(block) {
+  const start = (block.startId || "").trim();
+  const end = (block.endId || "").trim();
+  if (!start || !end) return "\u2014";
+  if (start === end) return start;
+  return `${start}\u2013${end}`;
+}
+function sortBlocks(blocks, sort) {
+  const copy = [...blocks];
+  if (sort === "size") {
+    copy.sort((a, b) => (b.compressedTokens || 0) - (a.compressedTokens || 0));
+  } else if (sort === "age") {
+    copy.sort((a, b) => (b.survivedCount || 0) - (a.survivedCount || 0));
+  } else {
+    copy.sort((a, b) => b.createdAt - a.createdAt);
+  }
+  return copy;
+}
+function renderSummaryRow(block, idWidth) {
+  const idStr = `b${block.blockId}`.padEnd(idWidth + 1);
+  const sizeStr = formatSizePair(block.compressedTokens, block.summaryTokens).padStart(13);
+  const ageStr = formatAge(block.createdAt).padStart(10);
+  const rangeStr = formatIdRange(block).padStart(19);
+  const topic = block.topic || "(no topic)";
+  return `  ${idStr} ${sizeStr}  ${ageStr}  ${rangeStr}   "${topic}"`;
+}
+function renderDetailedRow(block, idWidth) {
+  const idStr = `b${block.blockId}`.padEnd(idWidth + 1);
+  const sizeStr = formatSizePair(block.compressedTokens, block.summaryTokens).padStart(13);
+  const ageStr = formatAge(block.createdAt).padStart(10);
+  const rangeStr = formatIdRange(block).padStart(19);
+  const survived = block.survivedCount ?? 0;
+  const gen = block.generation ?? "young";
+  const effCount = block.effectiveMessageIds?.length ?? 0;
+  const consumedLineage = block.consumedBlockIds && block.consumedBlockIds.length > 0 ? ` nested=[${block.consumedBlockIds.map((n) => `b${n}`).join(",")}]` : "";
+  const topic = block.topic || "(no topic)";
+  return `  ${idStr} ${sizeStr}  ${ageStr}  ${rangeStr}  age=${survived} ${gen} eff=${effCount}${consumedLineage}  "${topic}"`;
+}
 function createAcpStatusTool(ctx) {
   ctx.prompts.reload();
   return tool5({
     description: ACP_STATUS_TOOL_DESCRIPTION,
-    args: {},
-    async execute() {
+    args: {
+      mode: tool5.schema.string().optional().describe('Output detail level: "summary" (default) or "detailed"'),
+      sort: tool5.schema.string().optional().describe('Sort order: "recent" (default), "size", or "age"'),
+      limit: tool5.schema.number().optional().describe("Maximum blocks to show (default 30)")
+    },
+    async execute(args) {
+      const mode = args.mode === "detailed" ? "detailed" : "summary";
+      const sort = args.sort === "size" || args.sort === "age" ? args.sort : "recent";
+      const limit = Number.isFinite(args.limit) && args.limit > 0 ? Math.min(args.limit, 200) : 30;
       const messages = ctx.state.prune.messages;
       const activeIds = Array.from(messages.activeBlockIds).sort((a, b) => a - b);
       if (activeIds.length === 0) {
         return "No compressed blocks. Context is fully visible.";
       }
-      const blocks = activeIds.map((id) => messages.blocksById.get(id)).filter((b) => b !== void 0 && b.active);
-      const totalSummary = blocks.reduce((sum, b) => sum + b.summaryTokens, 0);
-      const totalCompressed = blocks.reduce((sum, b) => sum + b.compressedTokens, 0);
+      const allBlocks = activeIds.map((id) => messages.blocksById.get(id)).filter((b) => b !== void 0 && b.active);
+      if (allBlocks.length === 0) {
+        return "No compressed blocks. Context is fully visible.";
+      }
+      const totalSummary = allBlocks.reduce((s, b) => s + (b.summaryTokens || 0), 0);
+      const totalCompressed = allBlocks.reduce((s, b) => s + (b.compressedTokens || 0), 0);
+      const sorted = sortBlocks(allBlocks, sort);
+      const shown = sorted.slice(0, limit);
+      const truncated = sorted.length - shown.length;
+      const idWidth = Math.max(...shown.map((b) => String(b.blockId).length));
       const lines = [
-        `ACP Status \u2014 ${blocks.length} active compressed block${blocks.length === 1 ? "" : "s"} (${formatTokens(totalSummary)} summary tokens, ${formatTokens(totalCompressed)} original content compressed)`,
+        `ACP Status \u2014 ${allBlocks.length} active compressed block${allBlocks.length === 1 ? "" : "s"} (${formatTokens(totalSummary)} summary, ${formatTokens(totalCompressed)} original compressed)`,
         ""
       ];
-      const idWidth = String(Math.max(...blocks.map((b) => b.blockId))).length;
-      for (const b of blocks) {
-        const idStr = `b${b.blockId}`.padEnd(idWidth + 1);
-        const tokStr = `${formatTokens(b.summaryTokens)}t`.padStart(7);
-        const ageStr = formatAge(b.createdAt).padStart(10);
-        const topic = b.topic || "(no topic)";
-        lines.push(`  ${idStr} ${tokStr}  ${ageStr}   "${topic}"`);
+      for (const b of shown) {
+        lines.push(
+          mode === "detailed" ? renderDetailedRow(b, idWidth) : renderSummaryRow(b, idWidth)
+        );
+      }
+      if (truncated > 0) {
+        lines.push("");
+        lines.push(`${shown.length} of ${sorted.length} blocks shown (${truncated} hidden). Raise limit or change sort to see more.`);
       }
       lines.push("");
-      lines.push(
-        "Use decompress to restore a block's full content, or search_context to search within compressed blocks."
-      );
+      const sortHint = sort === "recent" ? 'sorted by recent. Use acp_status({sort:"size"}) for largest, {sort:"age"} for near-GC.' : `sorted by ${sort}.`;
+      lines.push(`${sortHint} Use decompress to restore a block's full content, or search_context to search within compressed blocks.`);
       return lines.join("\n");
     }
   });
@@ -6978,23 +7263,76 @@ import { homedir as homedir4 } from "os";
 // lib/prompts/system.ts
 var SYSTEM = `
 
-You operate in a context-constrained environment. 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.
+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.
+
+ACP TAGS
 
-The tools you have for context management are \`compress\`, \`decompress\`, and \`search_context\`. \`compress\` replaces older conversation content with technical summaries you produce. \`decompress\` restores previously compressed content when you need exact details. \`search_context\` searches compressed block summaries (and visible messages) to locate relevant content before you decompress.
+\`<acp-context>\` tags wrap ACP (Agent Context Pruning) system metadata \u2014 context management information injected each turn. This is system data, not user input. You may also see \`<dcp-message-id>\` and \`<dcp-system-reminder>\` tags \u2014 these are equivalent (DCP was the previous name for ACP). Treat them as boundary metadata only, not as tool-result content.
 
-\`<acp-context>\` tags wrap ACP (Agent Context Pruning) system metadata \u2014 context management information injected each turn. This is system data, not user input. You may also see \`<dcp-message-id>\` and \`<dcp-system-reminder>\` tags \u2014 these are equivalent (DCP was the previous name for ACP).
+TOOLS
+
+You have four 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). Example: \`compress({ topic: "API exploration", content: [{ startId: "m00150", endId: "m00220", summary: "..." }] })\`.
+- \`decompress\` \u2014 Restore a previously compressed block's full original content, optionally to a file for large blocks. Use when a summary lacks the exact detail you need. Example: \`decompress({ blockId: "b5" })\` or \`decompress({ blockId: "b5", toFile: "path" })\`.
+- \`search_context\` \u2014 Search compressed block summaries (and optionally visible messages) by keyword. Use BEFORE decompressing to find the right block. Example: \`search_context({ query: "auth token refresh" })\`.
+- \`acp_status\` \u2014 List all active compressed blocks with their sizes, ages, and the message ranges they consumed. Use when you are unsure which IDs are still compressible, or before choosing compress boundaries. Example: \`acp_status({ mode: "summary", sort: "recent" })\`.
 
 COMPRESSION PHILOSOPHY
 
-All compression serves the primary task, but be frugal. Two failure modes to avoid:
+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. Compress selectively to keep context lean. But never compress content you're actively using for an ongoing task. Use \`search_context\` to find compressed content when needed, and \`decompress\` to restore details.
+Balance is key. The single test for whether to compress is: "Is this content still needed by the current task step?" If yes, keep it. If no, it is a candidate. When uncertain, lean toward keeping content.
 
 BE FRUGAL
 
-Be frugal with context \u2014 compress obvious waste promptly. Examples include verbose command output (build/test logs, git diff/status, npm install), sub-agent results once consumed, experiment/training logs (keep final metrics only), duplicate file reads, and failed explorations. Any content that is finished serving the task and would not be needed in upcoming turns should be compressed \u2014 not just these examples.
+Be frugal with context. Compress obvious waste proactively when you encounter it \u2014 verbose outputs you have already used, duplicate reads, abandoned explorations. Do not wait until context is critically full before compressing; that harms retrieval quality and risks overflow. When compressing, cover the largest range you can in a single call \u2014 aim for 20+ messages. Compressing 3-5 messages at a time creates many small summaries that collectively waste more tokens than they save. But never let the urge to compress distract from the actual task.
+
+WHEN TO COMPRESS
+
+- A sub-agent or delegated task has returned a large result that you have already extracted the key facts from.
+- Verbose command output (build/test logs, \`git diff\`, \`npm install\`, directory listings) where you have already used the information you need.
+- Exploration that led nowhere \u2014 compress the dead-ends but preserve the lessons learned: what was tried, what failed, and why.
+- Repeated reads of the same file or repeated status checks once the decision is recorded.
+- Resolved discussion threads where a decision has been captured in the summary or in code \u2014 compress the back-and-forth but preserve the decision rationale if it will be referenced later.
+- Intermediate steps of a completed multi-step task, once the final result is recorded.
+- When a task phase ends \u2014 such as finishing a bug hunt, locating a root cause, wrapping up a codebase exploration, or completing a research sprint \u2014 proactively compress the phase's redundant churn (exploratory reads, failed attempts, verbose outputs) while preserving what endures: key findings, relevant code and file paths, decision rationale, and lessons learned (what worked, what didn't, what's worth remembering next time).
+- Any other content where compression serves the primary task \u2014 be frugal.
+
+WHEN NOT TO COMPRESS
+
+- Content the current task step is actively reading or reasoning about.
+- Important user messages \u2014 preserve their exact intent, constraints, and acceptance criteria verbatim, not just the most recent one.
+- Outputs from protected tools (e.g. \`task\`, \`skill\`, \`todowrite\`, \`write\`, \`edit\`) \u2014 these are appended to summaries automatically, not compressed away.
+
+PERIODIC CONTEXT STATUS
+
+Periodically, as context grows, the system appends a short status line in a synthetic suffix message. It looks like:
+
+[ACP] Context: 47.3K tokens. Visible: m00001\u2013m00929, m00944\u2013m00950 (810 msgs). 3 active blocks. \`acp_status\` for details.
+
+This line is INFORMATION, not an instruction. Seeing it does not mean you should compress. Compress only when one of the WHEN TO COMPRESS conditions actually holds. Between these lines, context is not under additional pressure \u2014 you do not need to seek things to compress.
+
+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 block IDs, their sizes, and the message-ID ranges each covers.
+
+CONTEXT BREAKDOWN
+
+When context usage passes a threshold, the system appends a breakdown showing where your context tokens are spent:
+
+Breakdown: 12.3K tool (40%) | 3.1K summaries (10%) | 8.5K code (28%) | 6.5K text (22%)
+
+- "tool" = tool call outputs (largest category \u2014 compress first when consumed)
+- "summaries" = existing compression block summaries (already compressed; do not re-compress standalone)
+- "code" = messages containing code blocks
+- "text" = plain text messages
+
+Below the breakdown, the system lists the largest ranges in each category (e.g. \`Largest tool outputs: m00175 (20.7K), m00200 (8.1K)\`). These are high-value compression candidates \u2014 compress those whose content you have already consumed (extracted the facts you need). Keep any you still need to reference.
+
+Compress incrementally: target one large consumed range per compress call (e.g. m00150\u2192m00200), not the entire context at once. Each compression creates a reusable summary block you can decompress later if needed.
+
+<acp-compression-summary>\`<acp-compression-summary>\` tags wrap ACP model-generated recaps of previously compressed conversation ranges. These are system-generated metadata, not user messages. Treat them as reference material for the compressed history.
 `;
 
 // lib/prompts/compress-range.ts
@@ -7049,7 +7387,7 @@ When multiple independent ranges are ready and their boundaries do not overlap,
 var COMPRESS_MESSAGE = `Collapse selected individual messages in the conversation into detailed summaries.
 
 THE SUMMARY
-Your summary must be EXHAUSTIVE. Capture file paths, function signatures, decisions made, constraints discovered, key findings, tool outcomes, and user intent details that matter... EVERYTHING that preserves the value of the selected message after the raw message is removed.
+Your summary must be EXHAUSTIVE. Capture file paths, function signatures, decisions made, constraints discovered, key findings, tool outcomes, and user intent details that matter... EVERYTHING that preserves the value of the selected message after it is summarized. The original content can be restored via decompress if needed later.
 
 USER INTENT FIDELITY
 When a selected message contains user intent, preserve that intent with extra care. Do not change scope, constraints, priorities, acceptance criteria, or requested outcomes.
@@ -8751,7 +9089,8 @@ function runMajorGC(state, config, logger, messages) {
       agedOutTokens,
       maxBlockAge
     });
-    void saveSessionState(state, logger);
+    saveSessionState(state, logger).catch(() => {
+    });
   }
   if (!state.modelContextLimit) return;
   const currentTokens = getCurrentTokenUsage(state, messages);
@@ -8781,7 +9120,8 @@ function runMajorGC(state, config, logger, messages) {
       currentTokens,
       threshold: config.gc.majorGcThresholdPercent
     });
-    void saveSessionState(state, logger);
+    saveSessionState(state, logger).catch(() => {
+    });
   }
 }
 function createChatMessageTransformHandler(client, state, logger, config, prompts, hostPermissions) {
@@ -8809,14 +9149,16 @@ function createChatMessageTransformHandler(client, state, logger, config, prompt
     const activeBlockCountBefore = state.prune.messages.activeBlockIds.size;
     syncCompressionBlocks(state, logger, output.messages);
     if (state.prune.messages.activeBlockIds.size !== activeBlockCountBefore) {
-      void saveSessionState(state, logger);
+      saveSessionState(state, logger).catch(() => {
+      });
     }
     syncToolCache(state, config, logger, output.messages);
     buildToolIdList(state, output.messages);
     runMajorGC(state, config, logger, output.messages);
     const batchResult = runBatchCleanup(state, config, logger, output.messages);
     if (batchResult.mergedCount > 0) {
-      void saveSessionState(state, logger);
+      saveSessionState(state, logger).catch(() => {
+      });
     }
     prune(state, logger, config, output.messages);
     assignMessageRefs(state, output.messages);