opencode-acp 1.16.0 → 1.17.0-pr.383.130

package/dist/index.js

@@ -890,6 +890,7 @@ var VALID_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "compress.modelMaxLimits",
   "compress.modelMinLimits",
   "compress.providers",
+  "compress.contextLimitFallback",
   "compress.nudgeFrequency",
   "compress.minNudgeContextPercent",
   "compress.nudgeGrowthTokens",
@@ -913,6 +914,7 @@ var VALID_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "compress.reasoning",
   "compress.reasoning.drop",
   "compress.reasoning.threshold",
+  "compress.completionReserveTokens",
   "gc",
   "gc.algorithm",
   "gc.promotionThreshold",
@@ -964,7 +966,11 @@ function validateConfigTypes(config) {
     errors.push({ key: "storagePath", expected: "string", actual: typeof config.storagePath });
   }
   if (config.allowSubAgents !== void 0 && typeof config.allowSubAgents !== "boolean") {
-    errors.push({ key: "allowSubAgents", expected: "boolean", actual: typeof config.allowSubAgents });
+    errors.push({
+      key: "allowSubAgents",
+      expected: "boolean",
+      actual: typeof config.allowSubAgents
+    });
   }
   if (config.pruneNotification !== void 0) {
     const validValues = ["off", "minimal", "detailed"];
@@ -1293,6 +1299,20 @@ function validateConfigTypes(config) {
           }
         }
       }
+      if (compress.completionReserveTokens !== void 0 && typeof compress.completionReserveTokens !== "number") {
+        errors.push({
+          key: "compress.completionReserveTokens",
+          expected: "number",
+          actual: typeof compress.completionReserveTokens
+        });
+      }
+      if (typeof compress.completionReserveTokens === "number" && compress.completionReserveTokens < 0) {
+        errors.push({
+          key: "compress.completionReserveTokens",
+          expected: "non-negative number (>= 0)",
+          actual: `${compress.completionReserveTokens}`
+        });
+      }
       if (typeof compress.iterationNudgeThreshold === "number" && compress.iterationNudgeThreshold < 1) {
         errors.push({
           key: "compress.iterationNudgeThreshold",
@@ -1411,12 +1431,20 @@ function validateConfigTypes(config) {
             break;
           case "nudgeForce":
             if (value !== "strong" && value !== "soft") {
-              errors.push({ key, expected: "'strong' | 'soft'", actual: JSON.stringify(value) });
+              errors.push({
+                key,
+                expected: "'strong' | 'soft'",
+                actual: JSON.stringify(value)
+              });
             }
             break;
           case "stringArray":
             if (!Array.isArray(value) || !value.every((entry) => typeof entry === "string")) {
-              errors.push({ key, expected: "string[]", actual: JSON.stringify(value) });
+              errors.push({
+                key,
+                expected: "string[]",
+                actual: JSON.stringify(value)
+              });
             }
             break;
           case "reasoningConfig":
@@ -1451,7 +1479,11 @@ function validateConfigTypes(config) {
           return;
         }
         if (typeof overrides !== "object" || overrides === null || Array.isArray(overrides)) {
-          errors.push({ key: prefix, expected: "CompressModelOverrides", actual: typeof overrides });
+          errors.push({
+            key: prefix,
+            expected: "CompressModelOverrides",
+            actual: typeof overrides
+          });
           return;
         }
         const model = overrides;
@@ -1484,7 +1516,11 @@ function validateConfigTypes(config) {
         for (const [providerId, providerValue] of Object.entries(providers)) {
           const prefix = `compress.providers.${providerId}`;
           if (typeof providerValue !== "object" || providerValue === null || Array.isArray(providerValue)) {
-            errors.push({ key: prefix, expected: "ProviderOverrides", actual: typeof providerValue });
+            errors.push({
+              key: prefix,
+              expected: "ProviderOverrides",
+              actual: typeof providerValue
+            });
             continue;
           }
           const provider = providerValue;
@@ -1521,6 +1557,20 @@ function validateConfigTypes(config) {
         }
       };
       validateProviderOverrides(compress.providers);
+      if (compress.contextLimitFallback !== void 0 && typeof compress.contextLimitFallback !== "number") {
+        errors.push({
+          key: "compress.contextLimitFallback",
+          expected: "number",
+          actual: typeof compress.contextLimitFallback
+        });
+      }
+      if (typeof compress.contextLimitFallback === "number" && compress.contextLimitFallback < 0) {
+        errors.push({
+          key: "compress.contextLimitFallback",
+          expected: "non-negative number (0 disables the fallback)",
+          actual: `${compress.contextLimitFallback}`
+        });
+      }
       const validValues = ["ask", "allow", "deny"];
       if (compress.permission !== void 0 && !validValues.includes(compress.permission)) {
         errors.push({
@@ -1606,13 +1656,22 @@ function validateConfigTypes(config) {
           });
         } else {
           if (gc.batchCleanup.lowThreshold !== void 0) {
-            validateBatchThreshold("gc.batchCleanup.lowThreshold", gc.batchCleanup.lowThreshold);
+            validateBatchThreshold(
+              "gc.batchCleanup.lowThreshold",
+              gc.batchCleanup.lowThreshold
+            );
           }
           if (gc.batchCleanup.highThreshold !== void 0) {
-            validateBatchThreshold("gc.batchCleanup.highThreshold", gc.batchCleanup.highThreshold);
+            validateBatchThreshold(
+              "gc.batchCleanup.highThreshold",
+              gc.batchCleanup.highThreshold
+            );
           }
           if (gc.batchCleanup.forceThreshold !== void 0) {
-            validateBatchThreshold("gc.batchCleanup.forceThreshold", gc.batchCleanup.forceThreshold);
+            validateBatchThreshold(
+              "gc.batchCleanup.forceThreshold",
+              gc.batchCleanup.forceThreshold
+            );
           }
         }
       }
@@ -1702,6 +1761,7 @@ var defaultConfig = {
     summaryBuffer: true,
     maxContextLimit: "80%",
     minContextLimit: "80%",
+    contextLimitFallback: 128e3,
     nudgeFrequency: 5,
     minNudgeContextPercent: 5,
     iterationNudgeThreshold: 15,
@@ -1872,6 +1932,7 @@ function mergeCompress(base, override) {
     modelMaxLimits: override.modelMaxLimits ?? base.modelMaxLimits,
     modelMinLimits: override.modelMinLimits ?? base.modelMinLimits,
     providers: mergeProviderOverrides(base.providers, override.providers),
+    contextLimitFallback: override.contextLimitFallback ?? base.contextLimitFallback,
     nudgeFrequency: override.nudgeFrequency ?? base.nudgeFrequency,
     minNudgeContextPercent: override.minNudgeContextPercent ?? base.minNudgeContextPercent,
     nudgeGrowthTokens: override.nudgeGrowthTokens,
@@ -1895,7 +1956,8 @@ function mergeCompress(base, override) {
     reasoning: {
       drop: override.reasoning?.drop ?? base.reasoning?.drop ?? DEFAULT_COMPRESS_REASONING.drop,
       threshold: override.reasoning?.threshold ?? base.reasoning?.threshold ?? DEFAULT_COMPRESS_REASONING.threshold
-    }
+    },
+    completionReserveTokens: override.completionReserveTokens ?? base.completionReserveTokens
   };
 }
 function mergeCommands(base, override) {
@@ -1933,10 +1995,9 @@ function deepCloneConfig(config) {
             ...provider,
             ...provider.models ? {
               models: Object.fromEntries(
-                Object.entries(provider.models).map(([modelId, model]) => [
-                  modelId,
-                  { ...model }
-                ])
+                Object.entries(provider.models).map(
+                  ([modelId, model]) => [modelId, { ...model }]
+                )
               )
             } : {}
           }
@@ -2010,8 +2071,14 @@ function mergeLayer(config, data) {
     ],
     compress: mergeCompress(config.compress, data.compress),
     gc: mergeGC(config.gc, data.gc),
-    qualityGate: mergeQualityGate(config.qualityGate, data.qualityGate),
-    messageFilters: mergeMessageFilters(config.messageFilters, data.messageFilters)
+    qualityGate: mergeQualityGate(
+      config.qualityGate,
+      data.qualityGate
+    ),
+    messageFilters: mergeMessageFilters(
+      config.messageFilters,
+      data.messageFilters
+    )
   };
 }
 function scheduleParseWarning(ctx, title, message) {
@@ -2159,6 +2226,56 @@ 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;
@@ -2635,6 +2752,16 @@ function resetOnCompaction(state) {
     nextRef: 1
   };
 }
+function resolveEffectiveContextLimit(state, config) {
+  if (typeof state.modelContextLimit === "number" && state.modelContextLimit > 0) {
+    return { limit: state.modelContextLimit, source: "model" };
+  }
+  const fallback = config.compress.contextLimitFallback;
+  if (typeof fallback === "number" && fallback > 0) {
+    return { limit: fallback, source: "fallback" };
+  }
+  return void 0;
+}
 
 // lib/state/persistence.ts
 function getDefaultStorageDir() {
@@ -4506,6 +4633,24 @@ var SessionStateRegistry = class {
   hydrateModelLimitsFromClient(client) {
     return this.catalog.hydrateFromClient(client);
   }
+  // [FIX #346] The init-time seed (above) is fire-and-forget and races
+  // server readiness: in headless spawn+resume mode the provider-config
+  // call can fail before the server is up, leaving the catalog empty for
+  // the process's lifetime. During a request the server is guaranteed up
+  // (we are inside its pipeline), so on a catalog miss we retry hydration
+  // once per process before giving up (the fallback limit then applies).
+  // The in-flight promise (not a boolean) lets concurrent callers await the
+  // same hydration instead of skipping it.
+  lazyHydration;
+  async hydrateAndResolve(client, providerId, modelId) {
+    const existing = this.catalog.resolve(providerId, modelId);
+    if (existing !== void 0) {
+      return existing;
+    }
+    this.lazyHydration ??= this.catalog.hydrateFromClient(client);
+    await this.lazyHydration;
+    return this.catalog.resolve(providerId, modelId);
+  }
   get(sessionId) {
     return this.states.get(sessionId);
   }
@@ -4599,7 +4744,8 @@ function createSessionState() {
     modelID: void 0,
     systemPromptTokens: void 0,
     storageDir: void 0,
-    qualityGateRetryPending: false
+    qualityGateRetryPending: false,
+    noContextLimitWarned: false
   };
 }
 function resetSessionState(state) {
@@ -4642,6 +4788,7 @@ function resetSessionState(state) {
   state.systemPromptTokens = void 0;
   state.storageDir = void 0;
   state.qualityGateRetryPending = false;
+  state.noContextLimitWarned = false;
 }
 async function ensureSessionInitialized(client, state, sessionId, logger, messages, config, projectDir) {
   if (state.sessionId === sessionId) {
@@ -6657,6 +6804,7 @@ function getModelInfo(messages) {
   };
 }
 function resolveContextTokenLimit(config, state, providerId, modelId, threshold) {
+  const effectiveLimit = resolveEffectiveContextLimit(state, config);
   const parseLimitValue = (limit) => {
     if (limit === void 0) {
       return void 0;
@@ -6664,7 +6812,7 @@ function resolveContextTokenLimit(config, state, providerId, modelId, threshold)
     if (typeof limit === "number") {
       return limit;
     }
-    if (!limit.endsWith("%") || state.modelContextLimit === void 0) {
+    if (!limit.endsWith("%") || effectiveLimit === void 0) {
       return void 0;
     }
     const parsedPercent = parseFloat(limit.slice(0, -1));
@@ -6673,7 +6821,7 @@ function resolveContextTokenLimit(config, state, providerId, modelId, threshold)
     }
     const roundedPercent = Math.round(parsedPercent);
     const clampedPercent = Math.max(0, Math.min(100, roundedPercent));
-    return Math.round(clampedPercent / 100 * state.modelContextLimit);
+    return Math.round(clampedPercent / 100 * effectiveLimit.limit);
   };
   if (threshold === "max") {
     const nestedLimit = resolveCompressOverrides(config, providerId, modelId).maxContextLimit;
@@ -6724,11 +6872,12 @@ function isContextOverLimits(config, state, providerId, modelId, messages) {
       if (!overMaxLimit) break;
     }
   }
+  const effectiveLimit = resolveEffectiveContextLimit(state, config);
   return {
     overMaxLimit,
     overMinLimit,
     currentTokens,
-    modelContextLimit: state.modelContextLimit
+    modelContextLimit: effectiveLimit?.limit
   };
 }
 ensureBuiltinTriggerPolicyRegistered();
@@ -6931,6 +7080,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 = [];
@@ -6984,6 +7134,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) {
@@ -7011,7 +7165,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),
@@ -7034,13 +7189,10 @@ function buildCompressibleRanges(messages, state, protectedTools = [], protected
     if (!ref) continue;
     const rn = parseInt(ref.slice(1), 10);
     if ((protectedTools.length > 0 || protectedFilePatterns.length > 0) && messageContainsProtectedTool(msg, protectedTools, protectedFilePatterns)) {
-      let tokens2 = 0;
+      const tokens2 = Math.round(countMessageCharacters(msg) / 4);
       const tools = /* @__PURE__ */ new Set();
       for (const part of msg.parts || []) {
-        if (part.type === "text" && typeof part.text === "string") {
-          tokens2 += Math.round(part.text.length / 4);
-        } else if (part.type !== "text" && part.type !== "reasoning") {
-          tokens2 += Math.round(JSON.stringify(part).length / 4);
+        if (part.type !== "text" && part.type !== "reasoning") {
           const toolName = part?.tool;
           const callID = part?.callID;
           if (toolName && callID) {
@@ -7061,15 +7213,13 @@ function buildCompressibleRanges(messages, state, protectedTools = [], protected
       protectedMsgInfo.push({ ref, refNum: rn, tokens: tokens2, tools: [...tools] });
       continue;
     }
-    let tokens = 0;
+    const tokens = Math.round(countMessageCharacters(msg) / 4);
     let isTool = false;
     let hasMeaningfulPart = false;
     for (const part of msg.parts || []) {
       if (part.type === "text" && typeof part.text === "string") {
-        tokens += Math.round(part.text.length / 4);
         if (part.text.trim().length > 0) hasMeaningfulPart = true;
       } else if (part.type !== "text" && part.type !== "reasoning") {
-        tokens += Math.round(JSON.stringify(part).length / 4);
         isTool = true;
         hasMeaningfulPart = true;
       }
@@ -7893,8 +8043,11 @@ var injectCompressNudges = (state, config, logger, messages, prompts, compressio
       state.nudges.iterationNudgeAnchors.clear();
       state.nudges.lastNudgeShownTokens = void 0;
       state.nudges.lastToolOutputNudgeTokens = void 0;
-      state.nudges.lastTier2NudgeTokens = currentTokens;
-      state.nudges.lastTier3NudgeTokens = currentTokens;
+      const captureOnly = isCaptureOnlyCompress(lastCompressMsg);
+      if (!captureOnly) {
+        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;
@@ -8206,7 +8359,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 += `
@@ -8807,8 +8960,9 @@ function createDecompressTool(factoryCtx) {
     async execute(args, toolCtx) {
       const ctx = resolveToolContext(factoryCtx, toolCtx.sessionID);
       const { rawMessages } = await prepareDecompressSession(ctx, toolCtx);
-      const contextUsageBefore = ctx.state.modelContextLimit ? Math.round(
-        getCurrentTokenUsage(ctx.state, rawMessages) / ctx.state.modelContextLimit * 100
+      const effectiveLimitBefore = resolveEffectiveContextLimit(ctx.state, ctx.config);
+      const contextUsageBefore = effectiveLimitBefore ? Math.round(
+        getCurrentTokenUsage(ctx.state, rawMessages) / effectiveLimitBefore.limit * 100
       ) : void 0;
       const resolved = resolveTargets(args, ctx.state, rawMessages, ctx.logger);
       if (!resolved.ok) {
@@ -8872,8 +9026,9 @@ function createDecompressTool(factoryCtx) {
         0,
         ctx.state.stats.totalPruneTokens - restoredTokens
       );
-      const contextUsageAfter = ctx.state.modelContextLimit ? Math.round(
-        getCurrentTokenUsage(ctx.state, rawMessages) / ctx.state.modelContextLimit * 100
+      const effectiveLimitAfter = resolveEffectiveContextLimit(ctx.state, ctx.config);
+      const contextUsageAfter = effectiveLimitAfter ? Math.round(
+        getCurrentTokenUsage(ctx.state, rawMessages) / effectiveLimitAfter.limit * 100
       ) : void 0;
       await finalizeDecompressSession(ctx);
       const restoredContentPreview = buildRestoredContentPreview(
@@ -9094,6 +9249,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") {
@@ -9104,10 +9260,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 {
@@ -9129,14 +9287,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) {
@@ -9247,22 +9407,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("");
@@ -9530,7 +9691,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" : "dev";
+var LOG_VERSION = true ? "1.17.0-pr.383.130" : "dev";
 var LEVEL_RANK = {
   debug: 10,
   info: 20,
@@ -9826,13 +9987,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.
 
@@ -10354,6 +10516,8 @@ var MIN_OUTPUT_TOKENS = 1e3;
 var KEEP_PREFIX_CHARS = 2e3;
 var KEEP_SUFFIX_CHARS = 2e3;
 var PROTECT_RECENT_MESSAGES = 3;
+var OUTPUT_RESERVE_TOKENS = 16384;
+var overheadErrorLogged = /* @__PURE__ */ new Set();
 function parseGcThreshold(threshold, modelContextLimit) {
   if (typeof threshold === "number") return threshold;
   const str = threshold ?? "100%";
@@ -10362,10 +10526,26 @@ function parseGcThreshold(threshold, modelContextLimit) {
   return modelContextLimit;
 }
 function truncateLargeToolOutputs(state, config, logger, messages) {
-  if (!state.modelContextLimit) return;
+  const effective = resolveEffectiveContextLimit(state, config);
+  if (!effective) return;
   const currentTokens = getCurrentTokenUsage(state, messages);
   if (currentTokens === 0) return;
-  const threshold = parseGcThreshold(config.gc?.majorGcThresholdPercent, state.modelContextLimit);
+  const configuredThreshold = parseGcThreshold(config.gc?.majorGcThresholdPercent, effective.limit);
+  const overhead = (state.systemPromptTokens ?? 0) + OUTPUT_RESERVE_TOKENS;
+  const threshold = Math.min(configuredThreshold, effective.limit - overhead);
+  if (threshold <= 0) {
+    const sessionKey = state.sessionId ?? "unknown";
+    if (!overheadErrorLogged.has(sessionKey)) {
+      overheadErrorLogged.add(sessionKey);
+      logger.error("ACP: model context window too small to fit overhead", {
+        session: state.sessionId,
+        limit: effective.limit,
+        contextLimitSource: effective.source,
+        overhead
+      });
+    }
+    return;
+  }
   if (currentTokens < threshold) return;
   const protectedIndex = messages.length - PROTECT_RECENT_MESSAGES;
   const candidates = [];
@@ -10410,9 +10590,158 @@ function truncateLargeToolOutputs(state, config, logger, messages) {
       truncatedCount,
       estimatedSavedTokens: Math.round(savedTokens),
       currentTokens,
-      threshold
+      threshold,
+      contextLimit: effective.limit,
+      contextLimitSource: effective.source
+    });
+  }
+}
+
+// lib/messages/enforce-budget.ts
+var DEFAULT_COMPLETION_RESERVE_TOKENS = 32768;
+var TRUNCATION_MARKER2 = "[truncated for context space";
+var KEEP_PREFIX_CHARS2 = 2e3;
+var KEEP_SUFFIX_CHARS2 = 2e3;
+var PROTECT_RECENT_MESSAGES2 = 3;
+var MIN_CLEAR_TOKENS = 200;
+function resolveContextWindow(state) {
+  if (typeof state.modelContextLimit === "number" && state.modelContextLimit > 0) {
+    return state.modelContextLimit;
+  }
+  return void 0;
+}
+function estimateWireTokens(state, messages) {
+  const base = getCurrentTokenUsage(state, messages);
+  if (base > 0) {
+    let baseAssistant = -1;
+    for (let i = messages.length - 1; i >= 0; i--) {
+      if (messages[i].info.role !== "assistant") continue;
+      const tokens = messages[i].info.tokens;
+      if ((tokens?.input || 0) <= 0 && (tokens?.output || 0) <= 0) continue;
+      baseAssistant = i;
+      break;
+    }
+    if (baseAssistant >= 0) {
+      let additions = 0;
+      for (let i = baseAssistant + 1; i < messages.length; i++) {
+        additions += countAllMessageTokens(messages[i]);
+      }
+      return base + additions;
+    }
+  }
+  let total = 0;
+  for (const m of messages) total += countAllMessageTokens(m);
+  return total + (state.systemPromptTokens ?? 0);
+}
+function enforceContextBudget(state, config, logger, messages) {
+  const window = resolveContextWindow(state);
+  if (window === void 0) return void 0;
+  const configuredReserve = config.compress?.completionReserveTokens;
+  const reserve = typeof configuredReserve === "number" && Number.isFinite(configuredReserve) && configuredReserve >= 0 ? configuredReserve : DEFAULT_COMPLETION_RESERVE_TOKENS;
+  const budget = window - reserve;
+  if (budget <= 0) return void 0;
+  const estimatedTokens = estimateWireTokens(state, messages);
+  if (estimatedTokens <= budget) {
+    return {
+      applied: false,
+      window,
+      reserve,
+      budget,
+      estimatedTokens,
+      finalEstimate: estimatedTokens,
+      truncatedCount: 0,
+      clearedCount: 0
+    };
+  }
+  const protectedIndex = messages.length - PROTECT_RECENT_MESSAGES2;
+  const protectedTools = new Set(config.compress?.protectedTools ?? []);
+  const candidates = [];
+  for (let mi = 0; mi < protectedIndex; mi++) {
+    if (mi === 0 && messages[mi].info.role === "user") continue;
+    const msg = messages[mi];
+    const parts = Array.isArray(msg.parts) ? msg.parts : [];
+    for (const part of parts) {
+      if (part?.type !== "tool") continue;
+      if (part.state?.status !== "completed") continue;
+      if (part.tool === "compress") continue;
+      if (protectedTools.has(part.tool)) continue;
+      const content = extractCompletedToolOutput(part);
+      if (content === void 0) continue;
+      if (content === COMPACTED_TOOL_OUTPUT_PLACEHOLDER) continue;
+      const tokens = countTokens2(content);
+      if (tokens <= 0) continue;
+      candidates.push({ part, content, tokens, index: mi });
+    }
+  }
+  let saved = 0;
+  let truncatedCount = 0;
+  let clearedCount = 0;
+  const truncatable = candidates.filter(
+    (c) => !c.content.includes(TRUNCATION_MARKER2) && c.content.length > KEEP_PREFIX_CHARS2 + KEEP_SUFFIX_CHARS2
+  ).sort((a, b) => b.tokens - a.tokens);
+  for (const c of truncatable) {
+    if (estimatedTokens - saved <= budget) break;
+    const prefix = c.content.slice(0, KEEP_PREFIX_CHARS2);
+    const suffix = c.content.slice(-KEEP_SUFFIX_CHARS2);
+    const truncated = prefix + `
+
+...${TRUNCATION_MARKER2} \u2014 original ~${c.tokens} tokens]...
+
+` + suffix;
+    if (truncated.length >= c.content.length) continue;
+    c.part.state.output = truncated;
+    saved += c.tokens - countTokens2(truncated);
+    truncatedCount++;
+  }
+  if (estimatedTokens - saved > budget) {
+    const clearable = candidates.filter((c) => {
+      const out = extractCompletedToolOutput(c.part);
+      return out !== void 0 && out !== COMPACTED_TOOL_OUTPUT_PLACEHOLDER && countTokens2(out) > MIN_CLEAR_TOKENS;
+    }).sort((a, b) => a.index - b.index);
+    for (const c of clearable) {
+      if (estimatedTokens - saved <= budget) break;
+      const current = extractCompletedToolOutput(c.part);
+      if (current === void 0 || current === COMPACTED_TOOL_OUTPUT_PLACEHOLDER) continue;
+      c.part.state.output = COMPACTED_TOOL_OUTPUT_PLACEHOLDER;
+      saved += countTokens2(current) - countTokens2(COMPACTED_TOOL_OUTPUT_PLACEHOLDER);
+      clearedCount++;
+    }
+  }
+  const finalEstimate = Math.max(0, estimatedTokens - saved);
+  if (truncatedCount > 0 || clearedCount > 0) {
+    logger.warn("Context budget guard: pruned tool outputs to fit the request", {
+      session: state.sessionId,
+      estimatedTokens: Math.round(estimatedTokens),
+      budget,
+      window,
+      reserve,
+      truncatedCount,
+      clearedCount,
+      estimatedSavedTokens: Math.round(saved),
+      finalEstimate: Math.round(finalEstimate)
     });
   }
+  if (finalEstimate > budget) {
+    logger.warn(
+      "Context budget guard: still over budget after pruning all compressible tool outputs; the request may be rejected by the model",
+      {
+        session: state.sessionId,
+        finalEstimate: Math.round(finalEstimate),
+        budget,
+        window
+      }
+    );
+  }
+  return {
+    applied: truncatedCount > 0 || clearedCount > 0,
+    window,
+    reserve,
+    budget,
+    estimatedTokens,
+    finalEstimate,
+    truncatedCount,
+    clearedCount
+  };
 }
 
 // lib/commands/context.ts
@@ -11371,11 +11700,12 @@ function runBatchCleanup(state, config, logger, messages) {
     mergedCount: 0,
     savedTokens: 0
   };
-  if (!state.modelContextLimit || state.modelContextLimit <= 0) {
+  const effective = resolveEffectiveContextLimit(state, config);
+  if (!effective) {
     return noop;
   }
   const currentTokens = getCurrentTokenUsage(state, messages);
-  if (currentTokens < state.modelContextLimit) {
+  if (currentTokens < effective.limit) {
     return noop;
   }
   const maxMergedLength = config.gc.maxOldGenSummaryLength;
@@ -11392,7 +11722,8 @@ function runBatchCleanup(state, config, logger, messages) {
     mergedCount: result.mergedCount,
     savedTokens: result.savedTokens,
     currentTokens,
-    contextLimit: state.modelContextLimit
+    contextLimit: effective.limit,
+    contextLimitSource: effective.source
   });
   return {
     tier: 3,
@@ -11426,11 +11757,6 @@ function createSystemPromptHandler(registry4, logger, config, prompts) {
       input.model?.limit?.context
     );
     const state = input.sessionID ? registry4.get(input.sessionID) : void 0;
-    if (state && input.model?.limit?.context) {
-      state.modelContextLimit = input.model.limit.context;
-      state.modelProviderID = input.model?.providerID;
-      state.modelID = input.model?.id;
-    }
     if (!state || state.isSubAgent && !config.allowSubAgents) {
       return;
     }
@@ -11439,6 +11765,23 @@ function createSystemPromptHandler(registry4, logger, config, prompts) {
       logger.info("Skipping DCP system prompt injection for internal agent");
       return;
     }
+    if (input.model?.limit?.context) {
+      const limit = input.model.limit.context;
+      const providerID = input.model?.providerID;
+      const modelID = input.model?.id;
+      const changed = state.modelContextLimit !== limit || providerID !== void 0 && state.modelProviderID !== providerID || modelID !== void 0 && state.modelID !== modelID;
+      state.modelContextLimit = limit;
+      if (providerID !== void 0) {
+        state.modelProviderID = providerID;
+      }
+      if (modelID !== void 0) {
+        state.modelID = modelID;
+      }
+      if (changed) {
+        saveSessionState(state, logger).catch(() => {
+        });
+      }
+    }
     const effectivePermission = compressPermission(state, config);
     if (effectivePermission === "deny") {
       return;
@@ -11483,10 +11826,17 @@ function createChatMessageTransformHandler(client, registry4, logger, config, pr
         config
       );
       const requestModel = lastUserMessage.info.model;
-      const requestModelLimit = registry4.resolveModelLimit(
+      let requestModelLimit = registry4.resolveModelLimit(
         requestModel?.providerID,
         requestModel?.modelID
       );
+      if (requestModelLimit === void 0 && requestModel?.providerID && requestModel?.modelID) {
+        requestModelLimit = await registry4.hydrateAndResolve(
+          client,
+          requestModel.providerID,
+          requestModel.modelID
+        );
+      }
       const prevModelID = state.modelID;
       if (requestModelLimit !== void 0) {
         state.modelContextLimit = requestModelLimit;
@@ -11516,6 +11866,16 @@ function createChatMessageTransformHandler(client, registry4, logger, config, pr
         });
       }
       await updatePerTurnState(state, logger, messages);
+      if (state.modelContextLimit === void 0 && !state.noContextLimitWarned && requestModel?.providerID && requestModel?.modelID && registry4.resolveModelLimit(requestModel.providerID, requestModel.modelID) === void 0) {
+        state.noContextLimitWarned = true;
+        logger.warn(
+          'Model reports no context window and the catalog has no entry for it; all percentage thresholds (min/max/emergency, GC) and the context-budget guard are disabled. Set the model limit in opencode.json (e.g. "limit": {"context": 262144, "output": 16384}) to enable them (also fixes the 32000 max_tokens fallback); an absolute compress.maxContextLimit in acp.jsonc only enables proactive nudges, not the guard.',
+          {
+            session: state.sessionId,
+            model: `${requestModel.providerID}/${requestModel.modelID}`
+          }
+        );
+      }
     }
     syncCompressPermissionState(state, config, hostPermissions, output.messages);
     if (state.isSubAgent && !config.allowSubAgents) {
@@ -11541,10 +11901,11 @@ function createChatMessageTransformHandler(client, registry4, logger, config, pr
       }
     }
     ensureBuiltinFiltersRegistered();
+    const effectiveLimit = resolveEffectiveContextLimit(state, config);
     applyMessageFilters(output.messages, config.messageFilters, logger, {
       sessionId: state.sessionId ?? "",
       isSubAgent: state.isSubAgent,
-      modelContextLimit: state.modelContextLimit
+      modelContextLimit: effectiveLimit?.limit
     });
     cacheSystemPromptTokens(state, output.messages);
     assignMessageRefs(state, output.messages);
@@ -11564,6 +11925,7 @@ function createChatMessageTransformHandler(client, registry4, logger, config, pr
     const prePruneTokens = getCurrentTokenUsage(state, output.messages);
     prune(state, logger, config, output.messages);
     truncateLargeToolOutputs(state, config, logger, output.messages);
+    enforceContextBudget(state, config, logger, output.messages);
     hideConsumedCompressCalls(state, output.messages);
     assignMessageRefs(state, output.messages);
     const compressionPriorities = buildPriorityMap(config, state, output.messages);
@@ -11595,14 +11957,31 @@ ${text}`);
     stripStaleMetadata(output.messages);
     dropEmptyMessages(output.messages);
     const postTokens = getCurrentTokenUsage(state, output.messages);
+    if (postTokens !== void 0 && effectiveLimit) {
+      const budget = effectiveLimit.limit - (state.systemPromptTokens ?? 0) - OUTPUT_RESERVE_TOKENS;
+      if (postTokens > budget) {
+        logger.error(
+          "ACP hard guard: context exceeds model budget after in-flight reduction",
+          {
+            session: state.sessionId,
+            postTokens,
+            budget,
+            contextLimit: effectiveLimit.limit,
+            contextLimitSource: effectiveLimit.source,
+            hint: "request will likely be rejected; run /compact or start a new session"
+          }
+        );
+      }
+    }
     logger.info("Chat transform complete", {
       session: state.sessionId,
       model: state.modelID,
       messages: output.messages.length,
       prePruneTokens,
       postTokens,
-      contextLimit: state.modelContextLimit,
-      usagePct: postTokens !== void 0 && state.modelContextLimit ? `${(postTokens / state.modelContextLimit * 100).toFixed(1)}%` : void 0,
+      contextLimit: effectiveLimit?.limit,
+      contextLimitSource: effectiveLimit?.source,
+      usagePct: postTokens !== void 0 && effectiveLimit ? `${(postTokens / effectiveLimit.limit * 100).toFixed(1)}%` : void 0,
       nudged: state.nudges.shouldInjectThisTurn
     });
     if (state.sessionId) {
@@ -11634,12 +12013,7 @@ function createCommandExecuteHandler(client, registry4, logger, config, workingD
         path: { id: input.sessionID }
       });
       const messages = filterMessages(messagesResponse.data || messagesResponse);
-      const state = await registry4.getOrCreate(
-        client,
-        input.sessionID,
-        messages,
-        config
-      );
+      const state = await registry4.getOrCreate(client, input.sessionID, messages, config);
       syncCompressPermissionState(state, config, hostPermissions, messages);
       const commandCtx = {
         client,
@@ -11653,7 +12027,7 @@ function createCommandExecuteHandler(client, registry4, logger, config, workingD
       const sub = input.arguments?.trim().toLowerCase();
       if (sub === "stats" || sub === "status" || sub === "") {
         await handleStatsCommand(commandCtx);
-        throw new Error("__DCP_CONTEXT_HANDLED__");
+        return;
       }
       if (sub === "export" || sub.startsWith("export ")) {
         const exportArgs = input.arguments?.trim().slice("export".length).trim() || "";
@@ -11661,17 +12035,10 @@ function createCommandExecuteHandler(client, registry4, logger, config, workingD
         throw new Error("__DCP_CONTEXT_HANDLED__");
       }
       if (sub === "help") {
-        await sendIgnoredMessage(
-          client,
-          input.sessionID,
-          buildHelpText(),
-          {},
-          logger
-        );
+        await sendIgnoredMessage(client, input.sessionID, buildHelpText(), {}, logger);
         throw new Error("__DCP_CONTEXT_HANDLED__");
       }
       await handleContextCommand(commandCtx);
-      throw new Error("__DCP_CONTEXT_HANDLED__");
     }
   };
 }
@@ -11742,9 +12109,7 @@ function createEventHandler(registry4, logger) {
       return;
     }
     if (typeof part.callID === "string" && typeof part.messageID === "string") {
-      timing.startsByCallId.delete(
-        buildCompressionTimingKey(part.messageID, part.callID)
-      );
+      timing.startsByCallId.delete(buildCompressionTimingKey(part.messageID, part.callID));
     }
   };
 }
@@ -12021,7 +12386,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" : "dev",
+    version: true ? "1.17.0-pr.383.130" : "dev",
     workspace: ctx.directory,
     logLevel: logger.level,
     debug: config.debug,