nolo-cli 0.211.0 → 0.213.0

package/{chunk-BTYQAODF.js → chunk-7BT37FK3.js}

@@ -1,12 +1,12 @@
+import {
+  ALL_MODELS
+} from "./chunk-T43B7LB2.js";
 import {
   estimateTokenCount
 } from "./chunk-PSCNXBYA.js";
 import {
   MODEL_LOOKUP_MAP
 } from "./chunk-SM3NSZJV.js";
-import {
-  ALL_MODELS
-} from "./chunk-T43B7LB2.js";
 import {
   isPlatformManagedProvider,
   resolvePlatformEffectiveModel
@@ -40,71 +40,6 @@ function sha256Hex(text) {
   return SHA256(text).toString();
 }
 
-// packages/ai/context/retention.ts
-var SAFE_BUFFER_RATIO = 0.95;
-var CACHE_FIRST_RETENTION_STRENGTH = 0.95;
-var clamp = (v, min, max) => Math.min(max, Math.max(min, v));
-var planContextUsage = (params) => {
-  const { contextWindow, summaryTokens, recentLoad } = params;
-  const safeWindowLimit = Math.floor(contextWindow * SAFE_BUFFER_RATIO);
-  const iq = CACHE_FIRST_RETENTION_STRENGTH;
-  const isLargeWindow = contextWindow >= 512e3;
-  const isSmallWindow = contextWindow <= 64e3;
-  let baseHistoryRatio;
-  if (isLargeWindow) {
-    baseHistoryRatio = 0.8 + 0.2 * iq;
-  } else if (isSmallWindow) {
-    baseHistoryRatio = 0.35 + 0.3 * iq;
-  } else {
-    baseHistoryRatio = 0.55 + 0.3 * iq;
-  }
-  let historyRatio = baseHistoryRatio;
-  switch (recentLoad) {
-    case "light": {
-      const maxRatio = isLargeWindow ? 1 : isSmallWindow ? 0.75 : 0.85;
-      historyRatio = clamp(historyRatio * 1.05, 0.3, maxRatio);
-      break;
-    }
-    case "heavy": {
-      const maxRatio = isLargeWindow ? 0.98 : isSmallWindow ? 0.7 : 0.8;
-      const multiplier = isLargeWindow ? 0.98 : isSmallWindow ? 0.9 : 0.9;
-      historyRatio = clamp(historyRatio * multiplier, 0.3, maxRatio);
-      break;
-    }
-    case "medium":
-    default: {
-      const maxRatio = isLargeWindow ? 1 : isSmallWindow ? 0.75 : 0.85;
-      historyRatio = clamp(historyRatio, 0.3, maxRatio);
-      break;
-    }
-  }
-  const historyBudget = Math.max(
-    0,
-    Math.floor(safeWindowLimit * historyRatio)
-  );
-  const minRawRatio = isSmallWindow ? 0.5 : isLargeWindow ? 0.2 : 0.3;
-  const rawMessageBudget = Math.max(
-    Math.floor(historyBudget * minRawRatio),
-    historyBudget - summaryTokens,
-    0
-  );
-  let minTailTokens;
-  if (recentLoad === "light") {
-    minTailTokens = Math.min(
-      Math.floor(safeWindowLimit * 0.3),
-      8e3
-    );
-  } else if (recentLoad === "heavy") {
-    minTailTokens = Math.max(
-      Math.floor(safeWindowLimit * 0.25),
-      16e3
-    );
-  } else {
-    minTailTokens = Math.floor(safeWindowLimit * 0.2);
-  }
-  return { historyBudget, rawMessageBudget, minTailTokens };
-};
-
 // packages/ai/context/toolOutputCap.ts
 var TOOL_OUTPUT_CAP_WINDOW_RATIO = 0.12;
 var TOOL_OUTPUT_CAP_MIN_TOKENS = 4e3;
@@ -114,8 +49,8 @@ var COMPRESSION_TRIGGER_RATIO_MIN = 0.5;
 var ROUND_OVERHEAD_WINDOW_RATIO = 0.08;
 var ROUND_OVERHEAD_MIN_TOKENS = 4e3;
 var ROUND_OVERHEAD_MAX_TOKENS = 24e3;
-var clamp2 = (v, min, max) => Math.min(max, Math.max(min, v));
-var capToolOutputTokens = (contextWindow) => clamp2(
+var clamp = (v, min, max) => Math.min(max, Math.max(min, v));
+var capToolOutputTokens = (contextWindow) => clamp(
   Math.floor(contextWindow * TOOL_OUTPUT_CAP_WINDOW_RATIO),
   TOOL_OUTPUT_CAP_MIN_TOKENS,
   TOOL_OUTPUT_CAP_MAX_TOKENS
@@ -124,12 +59,12 @@ var resolveCompressionTriggerRatio = (contextWindow) => {
   if (typeof contextWindow !== "number" || !Number.isFinite(contextWindow) || contextWindow <= 0) {
     return COMPRESSION_TRIGGER_RATIO_MAX;
   }
-  const headroom = capToolOutputTokens(contextWindow) + clamp2(
+  const headroom = capToolOutputTokens(contextWindow) + clamp(
     Math.floor(contextWindow * ROUND_OVERHEAD_WINDOW_RATIO),
     ROUND_OVERHEAD_MIN_TOKENS,
     ROUND_OVERHEAD_MAX_TOKENS
   );
-  return clamp2(
+  return clamp(
     1 - headroom / contextWindow,
     COMPRESSION_TRIGGER_RATIO_MIN,
     COMPRESSION_TRIGGER_RATIO_MAX
@@ -182,24 +117,6 @@ var getMessageTokenCount = (msg) => {
   return tokens;
 };
 var hasOpenEndedToolCall = (msg) => !!msg && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0;
-var classifyConversationLoad = (msgs) => {
-  const N = 20;
-  if (!Array.isArray(msgs) || msgs.length === 0) return "light";
-  const tail = msgs.slice(-N);
-  const tokenSamples = tail.map(getMessageTokenCount);
-  if (tokenSamples.length === 0) return "light";
-  const sum = tokenSamples.reduce((acc, v) => acc + v, 0);
-  const avg = sum / tokenSamples.length;
-  const sorted = [...tokenSamples].sort((a, b) => a - b);
-  const p95 = sorted[Math.floor((sorted.length - 1) * 0.95)];
-  if (p95 < 200 && avg < 120) {
-    return "light";
-  }
-  if (p95 > 2e3 || avg > 1200) {
-    return "heavy";
-  }
-  return "medium";
-};
 var normalizeContextUsageRatio = (value) => {
   if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
   const ratio = value > 1 ? value / 100 : value;
@@ -224,21 +141,18 @@ function findPendingMessages(allMsgs, summarizedBeforeId) {
 }
 function shouldTriggerCompaction(args) {
   const {
-    pendingMsgCount,
     totalUsed,
     historyBudget,
     triggerRatio,
     force,
     reason,
-    realContextUsagePercent,
-    coldResume,
-    lastMsg
+    realContextUsagePercent
   } = args;
   const usageRatio = normalizeContextUsageRatio(realContextUsagePercent);
   const triggeredByRealUsage = usageRatio !== void 0 && usageRatio >= triggerRatio;
   const triggeredByEstimate = usageRatio === void 0 && totalUsed >= historyBudget;
-  const shouldRunActiveSummary = force && reason === "manual" && (pendingMsgCount < MIN_TRIGGER_PENDING_COUNT || !hasOpenEndedToolCall(lastMsg));
-  const triggeredByColdResume = coldResume === true && pendingMsgCount >= MIN_TRIGGER_PENDING_COUNT;
+  const shouldRunActiveSummary = force && reason === "manual";
+  const triggeredByColdResume = false;
   return {
     trigger: triggeredByRealUsage || triggeredByEstimate || shouldRunActiveSummary || triggeredByColdResume,
     triggeredByRealUsage,
@@ -246,11 +160,7 @@ function shouldTriggerCompaction(args) {
     triggeredByColdResume
   };
 }
-function calculateCompressCount(pendingMsgs, rawMessageBudget, opts) {
-  const { keepTailCount, totalUsed, historyBudget } = opts;
-  if (keepTailCount && totalUsed < historyBudget) {
-    return Math.max(0, pendingMsgs.length - ACTIVE_SUMMARY_TAIL_KEEP_COUNT);
-  }
+function calculateCompressCount(pendingMsgs, rawMessageBudget) {
   let tokensToKeep = 0;
   let keepCount = 0;
   for (let i = pendingMsgs.length - 1; i >= 0; i--) {
@@ -286,19 +196,20 @@ function resolveEffectiveCompactionBudgets(args) {
     maxRetainedRatio
   };
 }
-function guardToolChainBoundary(pendingMsgs, compressCount) {
-  let count = compressCount;
-  while (count < pendingMsgs.length && pendingMsgs[count].role === "tool") {
-    count++;
-  }
-  while (count > 0 && hasOpenEndedToolCall(pendingMsgs[count - 1])) {
-    if (count < pendingMsgs.length && pendingMsgs[count].role === "tool") {
-      count++;
-    } else {
-      count--;
-      break;
+function guardToolChainBoundary(pendingMsgs, compressCount, preserveByProjection) {
+  let safeLimit = Math.max(0, pendingMsgs.length - 1);
+  if (!preserveByProjection) {
+    for (let i = pendingMsgs.length - 1; i >= 0; i--) {
+      if (pendingMsgs[i].role === "user") {
+        safeLimit = i;
+        break;
+      }
     }
   }
+  let count = Math.min(compressCount, safeLimit);
+  while (count > 0 && (pendingMsgs[count]?.role === "tool" || hasOpenEndedToolCall(pendingMsgs[count - 1]))) {
+    count--;
+  }
   return count;
 }
 function planCompression(input) {
@@ -310,7 +221,7 @@ function planCompression(input) {
     force = false,
     reason,
     realContextUsagePercent,
-    coldResume
+    preserveLatestUserByProjection = false
   } = input;
   const { pendingMsgs, startIndex } = findPendingMessages(allMsgs, summarizedBeforeId);
   if (pendingMsgs.length === 0) {
@@ -329,30 +240,31 @@ function planCompression(input) {
   }
   const summaryTokens = estimateTokenCount(summary || "");
   const pendingTokens = pendingMsgs.reduce((sum, msg) => sum + getMessageTokenCount(msg), 0);
-  const totalUsed = summaryTokens + pendingTokens;
-  const adjustedSummaryTokens = Math.max(summaryTokens, 1e3);
-  const recentLoad = classifyConversationLoad(pendingMsgs);
-  const { historyBudget, rawMessageBudget } = planContextUsage({
-    contextWindow,
-    summaryTokens: adjustedSummaryTokens,
-    recentLoad
-  });
+  let coveredUserTokens = 0;
+  if (preserveLatestUserByProjection && summary && startIndex > 0) {
+    for (let i = startIndex - 1; i >= 0; i--) {
+      if (allMsgs[i].role === "user") {
+        coveredUserTokens = getMessageTokenCount(allMsgs[i]);
+        break;
+      }
+    }
+  }
+  const totalUsed = summaryTokens + coveredUserTokens + pendingTokens;
   const triggerRatio = resolveCompressionTriggerRatio(contextWindow);
+  const historyBudget = Math.floor(contextWindow * triggerRatio);
+  const rawMessageBudget = Math.max(0, historyBudget - summaryTokens);
   const {
     trigger,
     triggeredByRealUsage,
     shouldRunActiveSummary,
     triggeredByColdResume
   } = shouldTriggerCompaction({
-    pendingMsgCount: pendingMsgs.length,
     totalUsed,
     historyBudget,
     triggerRatio,
     force,
     reason,
-    realContextUsagePercent,
-    coldResume,
-    lastMsg: pendingMsgs[pendingMsgs.length - 1]
+    realContextUsagePercent
   });
   const diagnostics = {
     pendingMsgCount: pendingMsgs.length,
@@ -371,44 +283,41 @@ function planCompression(input) {
       emptyReason: "not-triggered"
     });
   }
-  const { effectiveHistoryBudget, effectiveRawMessageBudget } = resolveEffectiveCompactionBudgets({
+  const { effectiveRawMessageBudget } = resolveEffectiveCompactionBudgets({
     contextWindow,
     triggerRatio,
     historyBudget,
     rawMessageBudget,
-    summaryTokens
+    summaryTokens: Math.max(summaryTokens, Math.min(1e3, Math.floor(contextWindow * 0.1)))
   });
-  let compressCount = calculateCompressCount(
+  const minimumPrefixTokens = Math.min(1e3, Math.floor(contextWindow * 0.1));
+  const tailBudget = Math.min(effectiveRawMessageBudget, Math.max(0, pendingTokens - minimumPrefixTokens));
+  let compressCount = guardToolChainBoundary(
     pendingMsgs,
-    effectiveRawMessageBudget,
-    {
-      keepTailCount: shouldRunActiveSummary || triggeredByRealUsage || triggeredByColdResume,
-      totalUsed,
-      historyBudget: effectiveHistoryBudget
-    }
+    calculateCompressCount(pendingMsgs, tailBudget),
+    preserveLatestUserByProjection
   );
-  compressCount = guardToolChainBoundary(pendingMsgs, compressCount);
-  const allowSmallPrefix = reason !== "task_completed" && (shouldRunActiveSummary || triggeredByRealUsage || diagnostics.triggeredByEstimate);
-  if (allowSmallPrefix && (compressCount < MIN_COMPRESS_COUNT || pendingMsgs.length < MIN_TRIGGER_PENDING_COUNT)) {
-    let safeLimit = pendingMsgs.length - 1;
+  if (preserveLatestUserByProjection) {
+    let latestUser = -1;
     for (let i = pendingMsgs.length - 1; i >= 0; i--) {
       if (pendingMsgs[i].role === "user") {
-        safeLimit = i;
+        latestUser = i;
         break;
       }
     }
-    compressCount = Math.min(compressCount, safeLimit);
-    while (compressCount > 0 && (pendingMsgs[compressCount]?.role === "tool" || hasOpenEndedToolCall(pendingMsgs[compressCount - 1]))) {
-      compressCount--;
-    }
-    if (compressCount === 0) {
-      return emptyPlan(startIndex, {
-        ...diagnostics,
-        compressCount,
-        emptyReason: "no-safe-prefix"
-      });
+    const preservedTokens = latestUser >= 0 && latestUser < compressCount ? getMessageTokenCount(pendingMsgs[latestUser]) : latestUser < 0 ? coveredUserTokens : 0;
+    if (preservedTokens > 0) {
+      compressCount = guardToolChainBoundary(
+        pendingMsgs,
+        calculateCompressCount(pendingMsgs, Math.max(0, tailBudget - preservedTokens)),
+        true
+      );
     }
   }
+  if (compressCount === 0) {
+    return emptyPlan(startIndex, { ...diagnostics, compressCount, emptyReason: "no-safe-prefix" });
+  }
+  const allowSmallPrefix = reason !== "task_completed" && (shouldRunActiveSummary || triggeredByRealUsage || diagnostics.triggeredByEstimate);
   const compressibleTokens = pendingMsgs.slice(0, compressCount).reduce((sum, msg) => sum + getMessageTokenCount(msg), 0);
   if (compressCount < MIN_COMPRESS_COUNT && !(allowSmallPrefix && compressibleTokens >= 1e3)) {
     return emptyPlan(startIndex, {
@@ -516,21 +425,139 @@ function extractFileOperationsFromCalls(calls, resolveCanonicalName) {
   }
   return result;
 }
-function formatFileOperationsFromMessages(msgs, resolveCanonicalName) {
-  const allOps = [];
+function makeBoundedExcerpt(content) {
+  const evidence = selectEvidenceLines(content.split("\n"));
+  return (maxChars) => {
+    if (content.length <= maxChars) return content;
+    const marker = `
+[... ${content.length} chars projected ...]
+`;
+    const available = maxChars - marker.length;
+    if (available < 3) return marker.trim();
+    const evidenceCap = Math.floor(available * 0.2);
+    const selected = [];
+    let evidenceLength = 0;
+    for (const line of evidence) {
+      const cost = line.length + 1;
+      if (evidenceLength + cost > evidenceCap) continue;
+      selected.push(line);
+      evidenceLength += cost;
+    }
+    const remainder = available - evidenceLength;
+    const headLength = Math.ceil(remainder / 2);
+    const tailLength = Math.floor(remainder / 2);
+    return content.slice(0, headLength) + marker + (selected.length ? selected.join("\n") + "\n" : "") + (tailLength ? content.slice(-tailLength) : "");
+  };
+}
+function buildBoundedCompactionRequest(args) {
+  const { msgsToCompress: msgs, previousSummary, contextWindow } = args;
+  if (!Number.isFinite(contextWindow) || contextWindow <= 0) return { status: "blocked", reason: "invalid-window" };
+  if (!msgs.length) return { status: "blocked", reason: "empty-input" };
+  const window = Math.floor(contextWindow);
+  const outputTokenBudget = Math.min(8192, Math.max(1, Math.floor(window / 4)));
+  const cap = Math.min(computeSummaryInputTokenCap(contextWindow), window - outputTokenBudget);
+  const systemTokens = estimateTokenCount(COMPACTION_SUMMARY_SYSTEM_PROMPT);
+  for (let i = 0; i < msgs.length; ) {
+    const msg = msgs[i];
+    if (msg.role === "tool") return { status: "blocked", reason: "no-safe-group" };
+    const calls = msg.role === "assistant" && Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
+    if (!calls.length) {
+      i++;
+      continue;
+    }
+    const ids = calls.map((call) => call.id);
+    const hasIds = ids.every((id) => typeof id === "string" && id.length > 0);
+    if (!hasIds && ids.some((id) => id !== void 0) || hasIds && new Set(ids).size !== ids.length) {
+      return { status: "blocked", reason: "no-safe-group" };
+    }
+    const remaining2 = new Set(ids);
+    let count = 0;
+    i++;
+    while (i < msgs.length && msgs[i].role === "tool") {
+      const id = msgs[i].tool_call_id;
+      if (hasIds ? !id || !remaining2.delete(id) : id !== void 0) {
+        return { status: "blocked", reason: "no-safe-group" };
+      }
+      count++;
+      i++;
+    }
+    if (count !== calls.length || hasIds && remaining2.size) return { status: "blocked", reason: "no-safe-group" };
+  }
+  const canonicalize = args.canonicalizeToolName ?? ((name) => name);
+  const operations = /* @__PURE__ */ new Map();
   for (const msg of msgs) {
     if (!Array.isArray(msg.tool_calls)) continue;
-    allOps.push(
-      ...extractFileOperationsFromCalls(msg.tool_calls, resolveCanonicalName)
-    );
+    for (const op of extractFileOperationsFromCalls(msg.tool_calls, canonicalize)) {
+      operations.set(JSON.stringify([op.type, op.path]), op);
+    }
   }
-  if (allOps.length === 0) return "\u65E0";
-  const typeLabelMap = {
-    read: "\u8BFB\u53D6",
-    write: "\u5199\u5165",
-    edit: "\u7F16\u8F91"
+  const labelsByOperation = { read: "\u8BFB\u53D6", write: "\u5199\u5165", edit: "\u7F16\u8F91" };
+  const fileOpsText = [...operations.values()].map((op) => `- ${labelsByOperation[op.type]}: ${op.path}`).join("\n") || "\u65E0";
+  const note = "\u4EE5\u4E0B\u662F\u6709\u635F\u6295\u5F71\uFF0C\u90E8\u5206\u6D88\u606F\u53EF\u80FD\u88AB\u622A\u53D6\uFF1B\u539F\u6587\u4ECD\u5B58\u5386\u53F2\u3002";
+  const omitted = "[... \u5185\u5BB9\u5DF2\u622A\u53D6 ...]";
+  const contents = msgs.map((msg) => serializeMessageContent(msg.content) || formatMessageContentFallback(msg));
+  const excerpts = contents.map((content, i) => msgs[i].role === "user" ? void 0 : makeBoundedExcerpt(content));
+  const raw = contents.map((content, i) => msgs[i].role === "tool" ? excerpts[i](TOOL_RESULT_TRUNCATE_CHARS) : content);
+  const labels = msgs.map((msg) => `${msg.role} [id=${JSON.stringify(msg.id)}]: `);
+  const projected = msgs.map((msg, i) => msg.role === "user" ? raw[i] : omitted);
+  const makePrompt = () => buildCompactionUserContent({
+    previousSummary,
+    fileOpsText,
+    messagesText: `${note}
+${labels.map((label, i) => label + projected[i]).join("\n")}`
+  });
+  const base = makePrompt();
+  const baseTokens = systemTokens + estimateTokenCount(base);
+  if (baseTokens > cap) return { status: "blocked", reason: "no-budget" };
+  const remaining = cap - baseTokens;
+  const demands = raw.map((text, i) => msgs[i].role === "user" ? 0 : estimateTokenCount(text));
+  const weights = msgs.map((msg) => msg.role === "assistant" ? 2 : 1);
+  let low = 0;
+  let high = remaining + 1;
+  while (low + 1 < high) {
+    const mid = Math.floor((low + high) / 2);
+    const used = demands.reduce((sum, demand, i) => sum + Math.min(demand, mid * weights[i]), 0);
+    if (used <= remaining) low = mid;
+    else high = mid;
+  }
+  let extra = remaining - demands.reduce((sum, demand, i) => sum + Math.min(demand, low * weights[i]), 0);
+  for (let i = 0; i < msgs.length; i++) {
+    if (msgs[i].role === "user") continue;
+    let allowance = Math.min(demands[i], low * weights[i]);
+    const bonus = Math.min(extra, demands[i] - allowance);
+    allowance += bonus;
+    extra -= bonus;
+    if (demands[i] <= allowance) {
+      projected[i] = raw[i];
+      continue;
+    }
+    let lo = 0;
+    let hi = Math.min(contents[i].length, msgs[i].role === "tool" ? TOOL_RESULT_TRUNCATE_CHARS : contents[i].length);
+    let best = omitted;
+    while (lo <= hi) {
+      const mid = Math.floor((lo + hi) / 2);
+      const candidate = excerpts[i](mid);
+      if (estimateTokenCount(candidate) <= allowance) {
+        best = candidate;
+        lo = mid + 1;
+      } else {
+        hi = mid - 1;
+      }
+    }
+    projected[i] = best;
+  }
+  const promptContent = makePrompt();
+  const inputTokens = systemTokens + estimateTokenCount(promptContent);
+  if (inputTokens > cap) return { status: "blocked", reason: "no-budget" };
+  return {
+    status: "ready",
+    promptContent,
+    coveredMessages: msgs.slice(),
+    summarizedBeforeId: msgs[msgs.length - 1].id,
+    inputTokens,
+    outputTokenBudget,
+    partial: false
   };
-  return allOps.map((op) => `- ${typeLabelMap[op.type]}: ${op.path}`).join("\n");
 }
 var TOOL_RESULT_TRUNCATE_CHARS = 4e3;
 var SUMMARY_INPUT_MAX_TOKENS = 3e4;
@@ -538,38 +565,6 @@ function computeSummaryInputTokenCap(contextWindow) {
   const halfWindow = typeof contextWindow === "number" && Number.isFinite(contextWindow) && contextWindow > 0 ? Math.floor(contextWindow * 0.5) : SUMMARY_INPUT_MAX_TOKENS;
   return Math.max(1, Math.min(SUMMARY_INPUT_MAX_TOKENS, halfWindow));
 }
-function capTextToTokenBudget(text, maxTokens) {
-  const marker = `
-
-[... summary input capped to ${maxTokens} tokens ...]`;
-  const markerTokens = estimateTokenCount(marker);
-  const budget = Math.max(0, maxTokens - markerTokens);
-  if (estimateTokenCount(text) <= budget) return text;
-  let lo = 0;
-  let hi = text.length;
-  while (lo < hi) {
-    const mid = lo + hi + 1 >> 1;
-    if (estimateTokenCount(text.slice(0, mid)) <= budget) lo = mid;
-    else hi = mid - 1;
-  }
-  return `${text.slice(0, lo)}${marker}`;
-}
-function capSummaryInputToTokenBudget(items, maxTotalTokens) {
-  if (items.length === 0) return "";
-  const sepTokens = estimateTokenCount("\n");
-  const kept = [];
-  let used = 0;
-  for (let i = items.length - 1; i >= 0; i -= 1) {
-    const t = estimateTokenCount(items[i]);
-    const sep = kept.length > 0 ? sepTokens : 0;
-    if (kept.length > 0 && used + sep + t > maxTotalTokens) break;
-    used += sep + t;
-    kept.push(items[i]);
-  }
-  kept.reverse();
-  const result = kept.join("\n");
-  return estimateTokenCount(result) > maxTotalTokens ? capTextToTokenBudget(result, maxTotalTokens) : result;
-}
 var EVIDENCE_LINE_PATTERNS = [
   // commit sha：必须带 git 语境（commit/sha/HEAD/merge/push 输出 a..b）且含字母+数字
   /\b(?:commit|sha|HEAD|merge|revert|cherry-pick)\b[^\n]{0,24}\b(?=[0-9a-f]*[a-f])(?=[0-9a-f]*\d)[0-9a-f]{7,40}\b/i,
@@ -596,116 +591,6 @@ function isEvidenceLine(line) {
 function selectEvidenceLines(lines) {
   return lines.filter(isEvidenceLine);
 }
-var HEAD_SHARE = 0.4;
-var TAIL_SHARE = 0.4;
-function evidenceTruncateBudget(maxChars) {
-  const markerReserve = 96;
-  const usable = Math.max(0, maxChars - markerReserve);
-  const headCap = Math.floor(usable * HEAD_SHARE);
-  const tailCap = Math.floor(usable * TAIL_SHARE);
-  return {
-    markerReserve,
-    headCap,
-    tailCap,
-    evidenceCap: Math.max(0, usable - headCap - tailCap)
-  };
-}
-function takeHeadLines(lines, cap) {
-  let text = "";
-  let consumed = 0;
-  for (const line of lines) {
-    const candidate = consumed === 0 ? line : `${text}
-${line}`;
-    if (candidate.length > cap) {
-      if (consumed === 0 && cap > 0) {
-        return { text: line.slice(0, cap), consumed: 1 };
-      }
-      break;
-    }
-    text = candidate;
-    consumed += 1;
-  }
-  return { text, consumed };
-}
-function takeTailLines(lines, cap) {
-  if (cap <= 0 || lines.length === 0) return { text: "", consumed: 0 };
-  let text = "";
-  let consumed = 0;
-  for (let i = lines.length - 1; i >= 0; i -= 1) {
-    const candidate = consumed === 0 ? lines[i] : `${lines[i]}
-${text}`;
-    if (candidate.length > cap) {
-      if (consumed === 0) return { text: lines[i].slice(-cap), consumed: 1 };
-      break;
-    }
-    text = candidate;
-    consumed += 1;
-  }
-  return { text, consumed };
-}
-function shrinkToFit(head, evidence, tail, makeMarker, maxChars) {
-  const joinBody = () => head.concat(evidence, tail).join("\n");
-  let marker = makeMarker(joinBody().length);
-  while (joinBody().length + marker.length > maxChars) {
-    if (evidence.length > 0) evidence.pop();
-    else if (tail.length > 0) tail.pop();
-    else if (head.length > 0) head.pop();
-    else break;
-    marker = makeMarker(joinBody().length);
-  }
-  const result = joinBody() + marker;
-  return result.length > maxChars ? result.slice(0, maxChars) : result;
-}
-function truncateContentForSummary(role, content, maxChars = TOOL_RESULT_TRUNCATE_CHARS) {
-  if (role !== "tool" || content.length <= maxChars) return content;
-  const lines = content.split("\n");
-  const budget = evidenceTruncateBudget(maxChars);
-  const head = takeHeadLines(lines, budget.headCap);
-  const tail = takeTailLines(
-    lines.slice(0, lines.length - head.consumed),
-    budget.tailCap
-  );
-  const middle = lines.slice(head.consumed, lines.length - tail.consumed);
-  const evidence = selectEvidenceLines(middle);
-  if (evidence.length === 0) {
-    return `${content.slice(0, maxChars)}
-
-[... ${content.length - maxChars} chars truncated ...]`;
-  }
-  const headLines = head.text ? head.text.split("\n") : [];
-  const tailLines = tail.text ? tail.text.split("\n") : [];
-  const evidenceLines = [];
-  let evidenceUsed = 0;
-  for (const line of evidence) {
-    if (evidenceUsed + line.length > budget.evidenceCap) break;
-    evidenceLines.push(line);
-    evidenceUsed += line.length;
-  }
-  const marker = (bodyChars) => {
-    const note = evidenceLines.length > 0 ? `
-[... \u5DF2\u4FDD\u7559 ${evidenceLines.length} \u6761\u8BC1\u636E\u884C ...]` : "";
-    return `
-
-[... ${content.length - bodyChars} chars truncated ...]${note}`;
-  };
-  return shrinkToFit(headLines, evidenceLines, tailLines, marker, maxChars);
-}
-function formatMessagesForSummaryWithTruncation(msgs, maxToolResultChars = TOOL_RESULT_TRUNCATE_CHARS, maxTotalTokens) {
-  const items = msgs.map((msg) => {
-    const rawContent = serializeMessageContent(msg.content) || "";
-    const truncated = truncateContentForSummary(
-      msg.role,
-      rawContent,
-      maxToolResultChars
-    );
-    const text = truncated || formatMessageContentFallback(msg);
-    return `${msg.role}: ${text}`;
-  });
-  if (typeof maxTotalTokens === "number" && Number.isFinite(maxTotalTokens) && maxTotalTokens > 0) {
-    return capSummaryInputToTokenBudget(items, maxTotalTokens);
-  }
-  return items.join("\n");
-}
 function buildCompactionMetrics(args) {
   const {
     reason,
@@ -892,6 +777,11 @@ function fuzzyContextWindow(normalizedName) {
   }
   return void 0;
 }
+var findCodexOAuthPinnedContextWindow = (modelName, provider) => {
+  if (!modelName) return void 0;
+  if (isPlatformManagedProvider(provider, modelName)) return void 0;
+  return channelPinnedContextWindow(modelName.toLowerCase());
+};
 var findModelContextWindow = (modelName, provider) => {
   if (!modelName) return void 0;
   const onPlatformChannel = isPlatformManagedProvider(provider, modelName);
@@ -954,8 +844,8 @@ var getModelInfo = (modelName) => {
 };
 
 export {
-  planContextUsage,
   DEFAULT_CONTEXT_WINDOW,
+  findCodexOAuthPinnedContextWindow,
   findModelContextWindow,
   getModelContextWindow,
   getModelInfo,
@@ -963,14 +853,12 @@ export {
   serializeMessageContent,
   resolveCompressionTriggerRatio,
   truncateToolOutputForContext,
+  getMessageTokenCount,
+  resolveEffectiveCompactionBudgets,
   planCompression,
   COMPACTION_SUMMARY_SCHEMA_VERSION,
   COMPACTION_SUMMARY_SYSTEM_PROMPT,
-  buildCompactionUserContent,
-  formatFileOperationsFromMessages,
-  TOOL_RESULT_TRUNCATE_CHARS,
-  computeSummaryInputTokenCap,
-  formatMessagesForSummaryWithTruncation,
+  buildBoundedCompactionRequest,
   buildCompactionMetricsFromPlan,
   formatCompactionMetricsLog,
   computeSummarySourceMetadata

package/{chunk-27E2CBBY.js → chunk-7OCO4TDT.js}

@@ -1,7 +1,7 @@
 import {
   generatePkcePair,
   startCallbackServer
-} from "./chunk-SN5XE6GQ.js";
+} from "./chunk-RPQXPZZF.js";
 import {
   toErrorMessage
 } from "./chunk-HNMXYYJR.js";