opencode-acp 1.16.0-pr.365.125 → 1.16.0-pr.374.126

package/dist/index.js

@@ -2159,56 +2159,6 @@ var messageHasCompressAttempt = (message) => {
   const parts = Array.isArray(message.parts) ? message.parts : [];
   return parts.some((part) => part.type === "tool" && part.tool === "compress");
 };
-var isCaptureOnlyCompress = (message) => {
-  if (!isMessageWithInfo(message)) {
-    return false;
-  }
-  if (message.info.role !== "assistant") {
-    return false;
-  }
-  const parts = Array.isArray(message.parts) ? message.parts : [];
-  let sawBoundary = false;
-  for (const part of parts) {
-    if (!(part.type === "tool" && part.tool === "compress")) {
-      continue;
-    }
-    for (const startId of extractCompressBoundaryIds(part.state?.input)) {
-      sawBoundary = true;
-      if (/^b\d+$/i.test(startId)) {
-        return false;
-      }
-    }
-  }
-  return sawBoundary;
-};
-function extractCompressBoundaryIds(rawInput) {
-  let content = [];
-  if (typeof rawInput === "string") {
-    try {
-      const parsed = JSON.parse(rawInput);
-      const c = parsed?.content;
-      content = Array.isArray(c) ? c : [];
-    } catch {
-      return [];
-    }
-  } else if (rawInput && typeof rawInput === "object") {
-    const c = rawInput.content;
-    content = Array.isArray(c) ? c : [];
-  }
-  const ids = [];
-  for (const entry of content) {
-    if (!entry || typeof entry !== "object") {
-      continue;
-    }
-    const { startId, endId } = entry;
-    for (const sid of [startId, endId]) {
-      if (typeof sid === "string" && sid.trim() !== "") {
-        ids.push(sid.trim());
-      }
-    }
-  }
-  return ids;
-}
 var isIgnoredUserMessage = (message) => {
   if (!isMessageWithInfo(message)) {
     return false;
@@ -6981,6 +6931,7 @@ function estimateContextComposition(messages, state, protectedTools = [], protec
   let summaryTokens = 0;
   let messageTokens = 0;
   let protectedTokens = 0;
+  let reasoningTokens = 0;
   const perMessage = [];
   const perTool = [];
   const perCode = [];
@@ -7034,6 +6985,10 @@ function estimateContextComposition(messages, state, protectedTools = [], protec
         summaryTokens += summaryPartTokens;
         toolTypeMap.set(toolName, (toolTypeMap.get(toolName) || 0) + toolPartTokens);
         if (!msgToolName) msgToolName = toolName;
+      } else if (part.type === "reasoning" && typeof part.text === "string") {
+        const tokens = Math.round(part.text.length / 4);
+        msgTotal += tokens;
+        reasoningTokens += tokens;
       }
     }
     if (isProtected && !isSummary) {
@@ -7061,7 +7016,8 @@ function estimateContextComposition(messages, state, protectedTools = [], protec
     textTokens: Math.max(0, messageTokens - codeTokens),
     systemTokens,
     protectedTokens,
-    total: systemTokens + toolTokens + summaryTokens + messageTokens,
+    reasoningTokens,
+    total: systemTokens + toolTokens + summaryTokens + messageTokens + reasoningTokens,
     largestRanges: perMessage.slice(0, 15),
     largestToolRanges: perTool.slice(0, 15),
     largestCodeRanges: perCode.slice(0, 5),
@@ -7943,11 +7899,8 @@ var injectCompressNudges = (state, config, logger, messages, prompts, compressio
       state.nudges.iterationNudgeAnchors.clear();
       state.nudges.lastNudgeShownTokens = void 0;
       state.nudges.lastToolOutputNudgeTokens = void 0;
-      const captureOnly = isCaptureOnlyCompress(lastCompressMsg);
-      if (!captureOnly) {
-        state.nudges.lastTier2NudgeTokens = currentTokens;
-        state.nudges.lastTier3NudgeTokens = currentTokens;
-      }
+      state.nudges.lastTier2NudgeTokens = currentTokens;
+      state.nudges.lastTier3NudgeTokens = currentTokens;
       const currentTurnHasSuccessfulCompress = messages.slice(currentTurnStart).some((m) => m.info.role === "assistant" && messageHasCompress(m));
       if (currentTurnHasSuccessfulCompress && wasNudgeTriggered && !state.nudges.compressBaselineSet) {
         const baseline = state.nudges.lastPerMessageNudgeTokens;
@@ -8259,7 +8212,7 @@ This is an efficiency nudge to compress early and keep context lean \u2014 not a
 ${COMPRESS_PHILOSOPHY}` : "";
       const sysPart = composition.systemTokens > 0 ? `${fmt(composition.systemTokens)} system (${pct2(composition.systemTokens)}%) | ` : "";
       let breakdown = `${efficiencyNote}
-Breakdown: ${sysPart}${fmt(composition.toolTokens)} tool (${pct2(composition.toolTokens)}%) | ${fmt(composition.summaryTokens)} summaries (${pct2(composition.summaryTokens)}%) | ${fmt(composition.codeTokens)} code (${pct2(composition.codeTokens)}%) | ${fmt(plainTextTokens)} text (${pct2(plainTextTokens)}%)${growthStr}`;
+Breakdown: ${sysPart}${fmt(composition.toolTokens)} tool (${pct2(composition.toolTokens)}%) | ${fmt(composition.summaryTokens)} summaries (${pct2(composition.summaryTokens)}%) | ${fmt(composition.codeTokens)} code (${pct2(composition.codeTokens)}%) | ${fmt(plainTextTokens)} text (${pct2(plainTextTokens)}%) | ${fmt(composition.reasoningTokens)} reasoning (${pct2(composition.reasoningTokens)}%)${growthStr}`;
       const compressibleTokens = composition.total - composition.systemTokens - composition.protectedTokens - composition.summaryTokens;
       if (composition.protectedTokens > 0) {
         breakdown += `
@@ -9147,6 +9100,7 @@ function collectVisibleMessages(rawMessages, ctx) {
     const ref = byRawId.get(msgId);
     if (!ref) return;
     let tokens = 0;
+    let reasoning = 0;
     let toolName = "";
     for (const part of msg.parts || []) {
       if (part.type === "text" && typeof part.text === "string") {
@@ -9157,10 +9111,12 @@ function collectVisibleMessages(rawMessages, ctx) {
         if (!toolName) {
           toolName = part?.tool || "unknown";
         }
+      } else if (part.type === "reasoning" && typeof part.text === "string") {
+        reasoning += Math.round(part.text.length / 4);
       }
     }
-    if (tokens > 0) {
-      result.push({ ref, tokens, tool: toolName || "text", index: idx });
+    if (tokens > 0 || reasoning > 0) {
+      result.push({ ref, tokens, tool: toolName || "text", index: idx, reasoning });
     }
   });
   return {
@@ -9182,14 +9138,16 @@ function renderOverview(visibleMessages, summaryTokens, systemTokens, blocks, fe
   } else {
     const totalTool = visibleMessages.filter((m) => m.tool !== "text" && m.tool !== "step-finish").reduce((s, m) => s + m.tokens, 0);
     const totalText = visibleMessages.filter((m) => m.tool === "text").reduce((s, m) => s + m.tokens, 0);
-    const total = systemTokens + totalTool + totalText + summaryTokens;
+    const totalReasoning = visibleMessages.reduce((s, m) => s + m.reasoning, 0);
+    const total = systemTokens + totalTool + totalText + summaryTokens + totalReasoning;
     const sysPct = pct(systemTokens, total);
     const toolPct = pct(totalTool, total);
     const textPct = pct(totalText, total);
     const summaryPct = pct(summaryTokens, total);
+    const reasoningPct = pct(totalReasoning, total);
     lines.push("CONTEXT BREAKDOWN");
     lines.push(
-      `  ${formatTokens(systemTokens)} system (${sysPct}%) | ${formatTokens(totalTool)} tool (${toolPct}%) | ${formatTokens(totalText)} text (${textPct}%) | ${formatTokens(summaryTokens)} summaries (${summaryPct}%)`
+      `  ${formatTokens(systemTokens)} system (${sysPct}%) | ${formatTokens(totalTool)} tool (${toolPct}%) | ${formatTokens(totalText)} text (${textPct}%) | ${formatTokens(summaryTokens)} summaries (${summaryPct}%) | ${formatTokens(totalReasoning)} reasoning (${reasoningPct}%)`
     );
     const topTypes = Array.from(toolTypeMap.entries()).map(([tool6, tokens]) => ({ tool: tool6, tokens })).sort((a, b) => b.tokens - a.tokens).slice(0, 3);
     if (topTypes.length > 0) {
@@ -9300,22 +9258,23 @@ function renderUncompressedDrilldown(visibleMessages, toolFilter, sort, limit) {
   if (toolFilter) {
     filtered = filtered.filter((m) => m.tool === toolFilter);
   }
+  const sizeOf = (m) => m.tokens + m.reasoning;
   if (sort === "time") {
     filtered.sort((a, b) => a.index - b.index);
   } else if (sort === "tool") {
-    filtered.sort((a, b) => a.tool.localeCompare(b.tool) || b.tokens - a.tokens);
+    filtered.sort((a, b) => a.tool.localeCompare(b.tool) || sizeOf(b) - sizeOf(a));
   } else {
-    filtered.sort((a, b) => b.tokens - a.tokens);
+    filtered.sort((a, b) => sizeOf(b) - sizeOf(a));
   }
-  const totalTokens = filtered.reduce((s, m) => s + m.tokens, 0);
-  const allTokens = visibleMessages.reduce((s, m) => s + m.tokens, 0);
+  const totalTokens = filtered.reduce((s, m) => s + sizeOf(m), 0);
+  const allTokens = visibleMessages.reduce((s, m) => s + sizeOf(m), 0);
   const header = toolFilter ? `UNCOMPRESSED \u2014 ${toolFilter}: ${formatTokens(totalTokens)} | ${filtered.length} msgs | ${pct(totalTokens, allTokens)}% of visible` : `UNCOMPRESSED \u2014 ${formatTokens(totalTokens)} | ${filtered.length} msgs`;
   lines.push(header);
   lines.push(`Sorted by ${sort}`);
   lines.push("");
   const shown = filtered.slice(0, limit);
   for (const m of shown) {
-    lines.push(`  ${m.ref} (${formatTokens(m.tokens)}) ${m.tool}`);
+    lines.push(`  ${m.ref} (${formatTokens(sizeOf(m))}) ${m.tool}`);
   }
   if (filtered.length > shown.length) {
     lines.push("");
@@ -9583,7 +9542,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.16.0-pr.365.125" : "dev";
+var LOG_VERSION = true ? "1.16.0-pr.374.126" : "dev";
 var LEVEL_RANK = {
   debug: 10,
   info: 20,
@@ -9879,13 +9838,14 @@ CONTEXT BREAKDOWN
 
 When context usage passes a threshold, the system appends a breakdown showing where your context tokens are spent:
 
-Breakdown: 5.2K system (21%) | 12.3K tool (40%) | 3.1K summaries (10%) | 8.5K code (28%) | 6.5K text (22%)
+Breakdown: 4.2K system (21%) | 8.0K tool (40%) | 2.0K summaries (10%) | 2.6K code (13%) | 2.2K text (11%) | 1.0K reasoning (5%)
 
 - "system" = system prompt tokens (AGENTS.md, tool definitions \u2014 not compressible)
 - "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
+- "reasoning" = model thinking blocks (counted to match real API usage; freed when their message is compressed)
 
 Below the breakdown, the system lists compressible ranges grouped by conversation turn. All listed ranges should be compressed to summary format \u2014 the only exceptions are protected content, content the current step is actively using, or critical content you cannot reconstruct. Compress the largest ranges first when the current step no longer needs them.
 
@@ -12074,7 +12034,7 @@ var server = (async (ctx) => {
   }
   const logger = new Logger(config.debug, config.debug ? "debug" : config.logLevel);
   logger.info("ACP plugin initialized", {
-    version: true ? "1.16.0-pr.365.125" : "dev",
+    version: true ? "1.16.0-pr.374.126" : "dev",
     workspace: ctx.directory,
     logLevel: logger.level,
     debug: config.debug,