billion-context 0.1.39 → 0.1.40

package/dist/index.js

@@ -43595,9 +43595,11 @@ function prune(messages, state, options = {}) {
   const indexById = /* @__PURE__ */ new Map();
   messages.forEach((message, index) => indexById.set(message.id, index));
   const anchors = inject ? collectSummaryAnchors(state, indexById) : [];
-  return stripOrphanedToolResults(
-    stripOrphanedToolCalls(
-      rebuildMessages(messages, covered, firstUserIndex, anchors)
+  return stripOrphanedReasoning(
+    stripOrphanedToolResults(
+      stripOrphanedToolCalls(
+        rebuildMessages(messages, covered, firstUserIndex, anchors)
+      )
     )
   );
 }
@@ -43674,6 +43676,24 @@ function stripOrphanedToolCalls(messages) {
     (m2) => m2.contentType !== "tool-call" || !m2.toolCallId || m2.toolName === "compress" || knownResultIds.has(m2.toolCallId)
   );
 }
+function stripOrphanedReasoning(messages) {
+  const drop = /* @__PURE__ */ new Set();
+  for (let i = 0; i < messages.length; i++) {
+    if (drop.has(i)) continue;
+    if (messages[i].contentType !== "reasoning") continue;
+    let j2 = i;
+    while (j2 + 1 < messages.length && messages[j2 + 1].contentType === "reasoning") {
+      j2++;
+    }
+    const companion = messages[j2 + 1];
+    const hasCompanion = companion !== void 0 && companion.role === "assistant" && (companion.contentType === "text" || companion.contentType === "tool-call");
+    if (!hasCompanion) {
+      for (let k2 = i; k2 <= j2; k2++) drop.add(k2);
+    }
+  }
+  if (drop.size === 0) return messages;
+  return messages.filter((_2, i) => !drop.has(i));
+}
 function syncBlocks(messages, state) {
   const presentIds = new Set(messages.map((message) => message.id));
   const deactivated = [];
@@ -43730,7 +43750,7 @@ function defaultConfig(modelContextLimit, overrides = {}) {
   const base = {
     tiers: { enabled: true, tier2Trigger: 5, tier3Trigger: 10 },
     nudge: {
-      maxContextLimitPct: 0.55,
+      maxContextLimitPct: 0.75,
       minContextLimitPct: 0.45,
       frequency: 5,
       iterationThreshold: 15,
@@ -43740,10 +43760,10 @@ function defaultConfig(modelContextLimit, overrides = {}) {
       growthCap: 5e4,
       minGrowthFloor: 2e4,
       minGrowthRatio: 0.45,
-      emergencyThresholdPct: 0.8
+      emergencyThresholdPct: 0.95
     },
     promotionThreshold: 5,
-    truncate: { threshold: 1 },
+    truncate: { threshold: 0.95 },
     compress: {
       minCompressRange: 5e3,
       maxSummaryLength: 2e4,
@@ -43773,6 +43793,11 @@ function validateConfig(config) {
       "nudge.minContextLimitPct must not exceed nudge.maxContextLimitPct"
     );
   }
+  if (config.nudge.maxContextLimitPct > config.nudge.emergencyThresholdPct) {
+    errors.push(
+      "nudge.maxContextLimitPct must not exceed nudge.emergencyThresholdPct"
+    );
+  }
   if (config.promotionThreshold < 1) {
     errors.push("promotionThreshold must be >= 1");
   }
@@ -43805,6 +43830,18 @@ function parseBoundary(ref) {
   }
   return null;
 }
+var BoundaryNotFoundError = class extends Error {
+  code = "BOUNDARY_NOT_FOUND";
+  kind;
+  endpoint;
+  constructor(kind, endpoint, message) {
+    super(message);
+    this.name = "BoundaryNotFoundError";
+    this.code = "BOUNDARY_NOT_FOUND";
+    this.kind = kind;
+    this.endpoint = endpoint;
+  }
+};
 function resolveBoundaries(input) {
   const start = parseBoundary(input.startRef);
   const end = parseBoundary(input.endRef);
@@ -43817,13 +43854,8 @@ function resolveBoundaries(input) {
   input.messages.forEach(
     (message, index) => indexByRawId.set(message.id, index)
   );
-  let startIndex = resolveAnchorIndex(start, input.state, indexByRawId);
-  let endIndex = resolveAnchorIndex(end, input.state, indexByRawId);
-  if (startIndex === null || endIndex === null) {
-    throw new Error(
-      `Boundary not found in visible context (likely consumed by an existing block). startId="${input.startRef}", endId="${input.endRef}".`
-    );
-  }
+  let startIndex = resolveAnchorIndex(start, input.state, indexByRawId, "start");
+  let endIndex = resolveAnchorIndex(end, input.state, indexByRawId, "end");
   if (startIndex > endIndex) {
     [startIndex, endIndex] = [endIndex, startIndex];
   }
@@ -43854,16 +43886,51 @@ function resolveBoundaries(input) {
     protectedGaps
   };
 }
-function resolveAnchorIndex(boundary, state, indexByRawId) {
+function resolveAnchorIndex(boundary, state, indexByRawId, endpoint) {
+  const label = endpoint === "start" ? "startId" : "endId";
   if (boundary.kind === "message") {
     const rawId = state.messageRefs.byRef[boundary.raw] ?? state.messageRefs.byRef[formatPaddedRef(boundary.numericId)];
-    if (!rawId) return null;
+    if (!rawId) {
+      throw new BoundaryNotFoundError(
+        "unknown",
+        endpoint,
+        `${label}="${boundary.raw}" does not exist in this session (typo or wrong session) \u2014 run acp_status for current refs.`
+      );
+    }
     const index = indexByRawId.get(rawId);
-    return index === void 0 ? null : index;
+    if (index === void 0) {
+      throw new BoundaryNotFoundError(
+        "consumed",
+        endpoint,
+        `${label}="${boundary.raw}" not found in visible context (likely consumed by an existing block).`
+      );
+    }
+    return index;
   }
   const block = blockById(state, `b${boundary.numericId}`);
-  if (!block || !block.active) return null;
-  return earliestIndexOfIds(block.effectiveMessageIds, indexByRawId);
+  if (!block) {
+    throw new BoundaryNotFoundError(
+      "unknown",
+      endpoint,
+      `${label}="b${boundary.numericId}" does not exist in this session (typo or wrong session) \u2014 run acp_status for current refs.`
+    );
+  }
+  if (!block.active) {
+    throw new BoundaryNotFoundError(
+      "consumed",
+      endpoint,
+      `${label}="b${boundary.numericId}" not found in visible context (block distilled/consumed by a higher-tier block).`
+    );
+  }
+  const anchor = earliestIndexOfIds(block.effectiveMessageIds, indexByRawId);
+  if (anchor === null) {
+    throw new BoundaryNotFoundError(
+      "consumed",
+      endpoint,
+      `${label}="b${boundary.numericId}" not found in visible context (block messages consumed by a higher-tier block).`
+    );
+  }
+  return anchor;
 }
 function formatPaddedRef(index) {
   return `m${String(index).padStart(5, "0")}`;
@@ -44240,6 +44307,38 @@ function adjustBoundariesForToolPairs(startIndex, endIndex, messages, maxScan =
   }
   return { startIndex: newStartIndex, endIndex: newEndIndex };
 }
+function adjustBoundariesForReasoningPairs(startIndex, endIndex, messages) {
+  if (startIndex > endIndex) {
+    return { startIndex, endIndex };
+  }
+  let newStartIndex = startIndex;
+  let newEndIndex = endIndex;
+  for (let i = startIndex; i <= endIndex && i < messages.length; i++) {
+    const msg2 = messages[i];
+    if (!msg2) continue;
+    if (msg2.contentType === "reasoning") {
+      let j2 = i;
+      while (j2 + 1 < messages.length && messages[j2 + 1].contentType === "reasoning") {
+        j2++;
+      }
+      const companion = messages[j2 + 1];
+      if (companion !== void 0 && companion.role === "assistant" && (companion.contentType === "text" || companion.contentType === "tool-call") && j2 + 1 > newEndIndex) {
+        newEndIndex = j2 + 1;
+      }
+    }
+    if (msg2.role === "assistant" && (msg2.contentType === "text" || msg2.contentType === "tool-call")) {
+      let k2 = i - 1;
+      while (k2 >= 0 && messages[k2].contentType === "reasoning") {
+        k2--;
+      }
+      const runStart = k2 + 1;
+      if (runStart < i && runStart >= 0 && messages[runStart].contentType === "reasoning" && runStart < newStartIndex) {
+        newStartIndex = runStart;
+      }
+    }
+  }
+  return { startIndex: newStartIndex, endIndex: newEndIndex };
+}
 function refNum(ref) {
   const n = parseInt(ref.slice(1), 10);
   return Number.isNaN(n) ? -1 : n;
@@ -44394,6 +44493,9 @@ function runPipeline(nodes, initial, ctx) {
   }
   return io2;
 }
+function rangeError(spec, message) {
+  return `range ${spec.startRef}..${spec.endRef}: ${message}`;
+}
 function createCore(ports = {}) {
   const countTokens = ports.countTokens ?? defaultCountTokens;
   function applyCompression(input) {
@@ -44405,20 +44507,44 @@ function createCore(ports = {}) {
     const warnings = [];
     const protectedMessageIds = input.protectedMessageIds ?? computeProtectedRefs(input.messages, input.state, input.config, countTokens);
     const preExistingCoverage = collectCoverage(state);
-    const rangeIndexSets = [];
+    const classifications = /* @__PURE__ */ new Map();
+    const classificationErrors = [];
+    const consumedRanges = [];
     for (const spec of input.ranges) {
-      let resolved;
       try {
-        resolved = resolveBoundaries({
+        const resolved = resolveBoundaries({
           startRef: spec.startRef,
           endRef: spec.endRef,
           messages: input.messages,
           state
         });
-      } catch {
-        continue;
+        classifications.set(spec, { status: "ok", resolved });
+      } catch (error) {
+        if (error instanceof BoundaryNotFoundError) {
+          classifications.set(
+            spec,
+            error.kind === "unknown" ? { status: "unknown", error } : { status: "consumed", error }
+          );
+          if (error.kind === "consumed") {
+            consumedRanges.push(spec);
+          } else {
+            classificationErrors.push(rangeError(spec, error.message));
+          }
+        } else {
+          classifications.set(spec, {
+            status: "invalid",
+            error: error instanceof Error ? error : new Error(String(error))
+          });
+          classificationErrors.push(
+            rangeError(spec, error instanceof Error ? error.message : String(error))
+          );
+        }
       }
-      const indices = resolved.messageIds.map(
+    }
+    const rangeIndexSets = [];
+    for (const [spec, resolution] of classifications) {
+      if (resolution.status !== "ok") continue;
+      const indices = resolution.resolved.messageIds.map(
         (id) => input.messages.findIndex((m2) => m2.id === id)
       ).filter((i) => i >= 0);
       rangeIndexSets.push({ spec, indices });
@@ -44445,37 +44571,27 @@ function createCore(ports = {}) {
     if (input.config.compress.minCompressRange > 0 && input.ranges.length > 0) {
       let totalRangeChars = 0;
       let hasBlockBoundaryRange = false;
-      for (const spec of input.ranges) {
-        if (skipSpecs.has(spec)) continue;
-        let resolved;
-        try {
-          resolved = resolveBoundaries({
-            startRef: spec.startRef,
-            endRef: spec.endRef,
-            messages: input.messages,
-            state
-          });
-        } catch {
-          continue;
-        }
-        if (resolved.boundaryKind === "block") {
+      let countedRanges = 0;
+      for (const [spec, resolution] of classifications) {
+        if (resolution.status !== "ok" || skipSpecs.has(spec)) continue;
+        if (resolution.resolved.boundaryKind === "block") {
           hasBlockBoundaryRange = true;
           continue;
         }
-        for (const id of resolved.messageIds) {
+        countedRanges++;
+        for (const id of resolution.resolved.messageIds) {
           const msg2 = input.messages.find((m2) => m2.id === id);
           totalRangeChars += msg2?.text?.length ?? 0;
         }
       }
       if (!hasBlockBoundaryRange && totalRangeChars < input.config.compress.minCompressRange) {
+        const gateMessage = consumedRanges.length > 0 ? `Requested range(s) already compressed (e.g. ${consumedRanges[0].startRef}..${consumedRanges[0].endRef}); remaining compressible content ${totalRangeChars} chars < min ${input.config.compress.minCompressRange}. Nothing to do \u2014 run acp_status to see current compressible ranges.` : `Total compressible content too small (${totalRangeChars} chars across ${countedRanges} range(s), min ${input.config.compress.minCompressRange}). Combine more messages into your range(s) to meet the threshold.`;
         return {
           state: input.state,
           result: {
             blocksCreated: 0,
             tokensCompressed: 0,
-            errors: [
-              `Total compressible content too small (${totalRangeChars} chars across ${input.ranges.length} range(s), min ${input.config.compress.minCompressRange}). Combine more messages into your range(s) to meet the threshold.`
-            ],
+            errors: [gateMessage, ...classificationErrors],
             warnings: []
           }
         };
@@ -44483,6 +44599,18 @@ function createCore(ports = {}) {
     }
     for (const spec of input.ranges) {
       if (skipSpecs.has(spec)) continue;
+      const resolution = classifications.get(spec);
+      if (resolution === void 0) continue;
+      if (resolution.status === "consumed") {
+        warnings.push(
+          `Skipped range (${spec.startRef}..${spec.endRef}) \u2014 already compressed (messages consumed by existing block(s)); nothing to compress.`
+        );
+        continue;
+      }
+      if (resolution.status === "unknown" || resolution.status === "invalid") {
+        errors.push(rangeError(spec, resolution.error.message));
+        continue;
+      }
       try {
         const outcome = applySingleRange({
           spec,
@@ -44498,7 +44626,7 @@ function createCore(ports = {}) {
         tokensCompressed += outcome.tokens;
         warnings.push(...outcome.warnings);
       } catch (error) {
-        errors.push(error instanceof Error ? error.message : String(error));
+        errors.push(rangeError(spec, error instanceof Error ? error.message : String(error)));
       }
     }
     state.stats.compressionCount += blocksCreated;
@@ -44706,7 +44834,7 @@ function applySingleRange(input) {
     messages: input.messages,
     state: input.state
   });
-  const rangeMessageIds = applyToolPairAdjustment(
+  const rangeMessageIds = applyPairBoundaryAdjustments(
     resolved,
     input.messages
   );
@@ -44820,20 +44948,33 @@ function applySingleRange(input) {
   }
   return { tokens: compressedTokens, warnings };
 }
-function applyToolPairAdjustment(resolved, messages) {
+function applyPairBoundaryAdjustments(resolved, messages) {
   if (resolved.boundaryKind === "block") {
     return resolved.messageIds;
   }
-  const adjusted = adjustBoundariesForToolPairs(
-    resolved.startIndex,
-    resolved.endIndex,
-    messages
-  );
-  if (adjusted.startIndex === resolved.startIndex && adjusted.endIndex === resolved.endIndex) {
+  let startIndex = resolved.startIndex;
+  let endIndex = resolved.endIndex;
+  for (let pass = 0; pass < 2; pass++) {
+    const reasoningAdjusted = adjustBoundariesForReasoningPairs(
+      startIndex,
+      endIndex,
+      messages
+    );
+    const toolAdjusted = adjustBoundariesForToolPairs(
+      reasoningAdjusted.startIndex,
+      reasoningAdjusted.endIndex,
+      messages
+    );
+    const changed = toolAdjusted.startIndex !== startIndex || toolAdjusted.endIndex !== endIndex;
+    startIndex = toolAdjusted.startIndex;
+    endIndex = toolAdjusted.endIndex;
+    if (!changed) break;
+  }
+  if (startIndex === resolved.startIndex && endIndex === resolved.endIndex) {
     return resolved.messageIds;
   }
   const ids = [];
-  for (let i = adjusted.startIndex; i <= adjusted.endIndex; i++) {
+  for (let i = startIndex; i <= endIndex; i++) {
     const msg2 = messages[i];
     if (msg2) ids.push(msg2.id);
   }
@@ -44933,6 +45074,7 @@ function decideNudge(input) {
   const limit = config.modelContextLimit;
   const usage = limit > 0 ? tokenCount / limit : 0;
   const nudgeGrowthTokens = resolveAdaptiveGrowth(limit, config.nudge);
+  const overLimit = usage >= config.nudge.maxContextLimitPct;
   const emergencyOverride = usage >= config.nudge.emergencyThresholdPct;
   const baseline = state.nudge.lastPerMessageNudgeTokens;
   const hadPendingNudge = state.nudge.lastNudgeShownTokens > 0;
@@ -44949,7 +45091,7 @@ function decideNudge(input) {
   let injectedTier = null;
   let injectedReason = "";
   const growthReady = growthSinceReference >= growthFloor;
-  if (!emergencyOverride && growthReady) {
+  if (!overLimit && growthReady) {
     for (const tier of [1, 2, 3]) {
       if (!config.tiers.enabled && tier > 1) break;
       const info = tiers[tier];
@@ -44961,11 +45103,26 @@ function decideNudge(input) {
       injectedReason = tier === 1 ? `T1 compressible ${info.pending} >= ${nudgeGrowthTokens}, growth ${growthSinceReference}, usage ${Math.round(usage * 100)}%` : `T${tier} distill ready: ${info.targetBlocks.length} tier-${tier - 1} blocks (${info.pending} tokens) >= ${nudgeGrowthTokens}, usage ${Math.round(usage * 100)}%`;
       break;
     }
+  } else if (overLimit) {
+    for (const tier of [1, 2, 3]) {
+      if (!config.tiers.enabled && tier > 1) break;
+      const info = tiers[tier];
+      if (!info || info.pending < config.compress.minCompressRange) continue;
+      injectedTier = tier;
+      injectedReason = emergencyOverride ? `EMERGENCY: usage ${Math.round(usage * 100)}% >= ${Math.round(config.nudge.emergencyThresholdPct * 100)}%, T${tier} pending ${info.pending}` : `OVER-LIMIT: usage ${Math.round(usage * 100)}% >= ${Math.round(config.nudge.maxContextLimitPct * 100)}%, T${tier} pending ${info.pending}`;
+      break;
+    }
   }
-  const shouldInject = emergencyOverride || injectedTier !== null;
+  const shouldInject = injectedTier !== null || overLimit && (rec?.recommendedRanges?.length ?? 0) > 0;
   let reason;
-  if (emergencyOverride) {
-    reason = `EMERGENCY: usage ${Math.round(usage * 100)}% >= ${Math.round(config.nudge.emergencyThresholdPct * 100)}%`;
+  if (emergencyOverride && injectedTier !== null) {
+    reason = injectedReason;
+  } else if (emergencyOverride) {
+    reason = `EMERGENCY: usage ${Math.round(usage * 100)}% >= ${Math.round(config.nudge.emergencyThresholdPct * 100)}% (no compressible content)`;
+  } else if (overLimit && injectedTier !== null) {
+    reason = injectedReason;
+  } else if (overLimit) {
+    reason = `OVER-LIMIT: usage ${Math.round(usage * 100)}% >= ${Math.round(config.nudge.maxContextLimitPct * 100)}% (no compressible content)`;
   } else if (injectedTier !== null) {
     reason = injectedReason;
   } else {
@@ -45001,6 +45158,7 @@ function decideNudge(input) {
       nudgeGrowthTokens,
       growthFloor,
       hasPendingNudge: hasPendingNudge ? 1 : 0,
+      overLimit: overLimit ? 1 : 0,
       emergencyOverride: emergencyOverride ? 1 : 0,
       pendingT1: tiers[1].pending,
       pendingT2: tiers[2].pending,
@@ -45172,12 +45330,22 @@ DROP:
 - Anything marked [OBSOLETE] or [SUPERSEDED] \u2014 drop entirely, note "[N blocks obsolete]" in the summary.
 
 SIZE TARGET: 30-60 tokens per source block (including header). For a batch of N source blocks, total output \u2248 N \xD7 40 tokens. If a source block has only one trivial fact, output just the header + one line.`;
-var EFFICIENCY_NOTE = `This is an efficiency nudge to compress early and keep context lean \u2014 not an overflow warning. A separate, stronger alert will appear if the context is actually full.
+var defaultPrompts = Object.freeze({
+  compressPhilosophy: COMPRESS_PHILOSOPHY,
+  howToCompressRules: HOW_TO_COMPRESS_RULES,
+  tier2DistillRules: TIER2_DISTILL_RULES,
+  tier3CondenseRules: TIER3_CONDENSE_RULES
+});
+function efficiencyNote(prompts) {
+  return `This is an efficiency nudge to compress early and keep context lean \u2014 not an overflow warning. A separate, stronger alert will appear if the context is actually full.
 
-${COMPRESS_PHILOSOPHY}`;
-var EMERGENCY_HEADER = `\u26A0\uFE0F Context limit reached \u2014 compress now. Prioritize consumed tool outputs.
+${prompts.compressPhilosophy}`;
+}
+function emergencyHeader(prompts) {
+  return `\u26A0\uFE0F Context limit reached \u2014 compress now. Prioritize consumed tool outputs.
 
-${COMPRESS_PHILOSOPHY}`;
+${prompts.compressPhilosophy}`;
+}
 function formatK(n) {
   if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
   return `${n}`;
@@ -45285,7 +45453,7 @@ function formatRanges(compressible, protectedRanges) {
   return `Compressible ranges (${merged.length}, oldest first):
 ${lines.join("\n")}`;
 }
-function renderNudgeText(decision) {
+function renderNudgeText(decision, prompts = defaultPrompts) {
   const breakdownStr = formatBreakdown(decision.contextBreakdown);
   const rangesStr = formatRanges(decision.compressibleRanges, decision.protectedRanges ?? []);
   if (decision.tier !== null && decision.tier >= 2) {
@@ -45297,7 +45465,7 @@ function renderNudgeText(decision) {
     return {
       voice: "gentle",
       text: [
-        EFFICIENCY_NOTE,
+        efficiencyNote(prompts),
         "",
         breakdownStr,
         "",
@@ -45306,22 +45474,22 @@ function renderNudgeText(decision) {
         blockList,
         `Example: compress({ content: [{ startId: "${startId}", endId: "${endId}", summary: "..." }] })`,
         "",
-        HOW_TO_COMPRESS_RULES,
+        prompts.howToCompressRules,
         "",
-        isT2 ? TIER2_DISTILL_RULES : TIER3_CONDENSE_RULES
+        isT2 ? prompts.tier2DistillRules : prompts.tier3CondenseRules
       ].join("\n")
     };
   }
-  const isEmergency = !!decision.breakdown?.emergencyOverride;
+  const isEmergency = !!decision.breakdown?.emergencyOverride || !!decision.breakdown?.overLimit;
   if (isEmergency) {
     return {
       voice: "emergency",
       text: [
-        EMERGENCY_HEADER,
+        emergencyHeader(prompts),
         "",
         breakdownStr,
         "",
-        HOW_TO_COMPRESS_RULES,
+        prompts.howToCompressRules,
         "",
         `{ "topic": "...", "content": [{ "startId": "<ID>", "endId": "<ID>", "summary": "..." }] }`,
         "Only use IDs from visible messages above. Compress older work first.",
@@ -45333,11 +45501,11 @@ function renderNudgeText(decision) {
   return {
     voice: "gentle",
     text: [
-      EFFICIENCY_NOTE,
+      efficiencyNote(prompts),
       "",
       breakdownStr,
       "",
-      HOW_TO_COMPRESS_RULES,
+      prompts.howToCompressRules,
       "",
       rangesStr,
       "",
@@ -46290,29 +46458,24 @@ function lookupContextLimit(model) {
 function resolveContextLimit(routes, upstreamUrl, model) {
   return resolveConfiguredContextLimit(routes, upstreamUrl, model) ?? lookupContextLimit(model);
 }
-function resolveConfiguredContextLimit(routes, upstreamUrl, model) {
-  if (!model || !upstreamUrl) return void 0;
+function findRoute(routes, upstreamUrl) {
+  if (!upstreamUrl) return void 0;
   let bestKey = "";
   for (const key of Object.keys(routes)) {
     if (upstreamUrl === key || upstreamUrl.startsWith(key + "/")) {
       if (key.length > bestKey.length) bestKey = key;
     }
   }
-  if (bestKey) {
-    const m2 = routes[bestKey].models?.[model];
-    if (m2?.context && m2.context > 0) return m2.context;
-  }
+  return bestKey ? routes[bestKey] : void 0;
+}
+function resolveConfiguredContextLimit(routes, upstreamUrl, model) {
+  if (!model || !upstreamUrl) return void 0;
+  const m2 = findRoute(routes, upstreamUrl)?.models?.[model];
+  if (m2?.context && m2.context > 0) return m2.context;
   return void 0;
 }
 function resolveCompressProtocol(routes, upstreamUrl) {
-  if (!upstreamUrl) return void 0;
-  let bestKey = "";
-  for (const key of Object.keys(routes)) {
-    if (upstreamUrl === key || upstreamUrl.startsWith(key + "/")) {
-      if (key.length > bestKey.length) bestKey = key;
-    }
-  }
-  return bestKey ? routes[bestKey].compressProtocol : void 0;
+  return findRoute(routes, upstreamUrl)?.compressProtocol;
 }
 function loadRoutes(env = process.env) {
   const fileConfig = loadConfigFile();
@@ -46388,6 +46551,7 @@ function loadOptions(env = process.env) {
     modelContextLimit,
     kernelConfig: defaultConfig(modelContextLimit),
     compress: {
+      ...fileConfig.compress ?? {},
       injectTool: (env.ACP_COMPRESS_TOOL ?? (fileConfig.compress?.injectTool === false ? "0" : "1")) !== "0",
       injectNudge: (env.ACP_COMPRESS_NUDGE ?? (fileConfig.compress?.injectNudge === false ? "0" : "1")) !== "0"
     },
@@ -46461,6 +46625,7 @@ function parseRouteEntry(v2) {
     const route = { models: obj.models };
     if (typeof obj.proxy === "string") route.proxy = obj.proxy;
     if (obj.compressProtocol === "marker" || obj.compressProtocol === "tools") route.compressProtocol = obj.compressProtocol;
+    if (obj.compress) route.compress = obj.compress;
     return route;
   }
   if (v2 === null) return {};
@@ -46483,6 +46648,73 @@ function rejectLegacyRoute(key, value) {
 import http from "http";
 import fs5 from "fs";
 
+// src/compress-settings.ts
+function resolveContextLimitValue(raw, nativeLimit) {
+  if (typeof raw === "number" && Number.isFinite(raw) && raw > 0) return Math.max(1, Math.floor(raw));
+  if (typeof raw === "string") {
+    const pct2 = /^(\d+(?:\.\d+)?)\s*%$/.exec(raw.trim());
+    if (pct2) return Math.max(1, Math.floor(nativeLimit * Number(pct2[1]) / 100));
+    const n = Number(raw);
+    if (Number.isFinite(n) && n > 0) return Math.floor(n);
+  }
+  return Math.max(1, Math.floor(nativeLimit));
+}
+function mergeCompress(global2, provider, model) {
+  const pick2 = (k2) => model?.[k2] ?? provider?.[k2] ?? global2?.[k2];
+  return {
+    modelContextLimit: pick2("modelContextLimit"),
+    maxContextLimit: pick2("maxContextLimit"),
+    emergencyThresholdPercent: pick2("emergencyThresholdPercent"),
+    nudgeGrowthTokens: pick2("nudgeGrowthTokens"),
+    preserveRecentMessages: pick2("preserveRecentMessages"),
+    preserveRecentTokens: pick2("preserveRecentTokens"),
+    minCompressRange: pick2("minCompressRange"),
+    tiers: pick2("tiers")
+  };
+}
+function resolveCompress(routes, upstreamUrl, model, global2) {
+  const route = findRoute(routes, upstreamUrl);
+  return mergeCompress(global2, route?.compress, model ? route?.models?.[model]?.compress : void 0);
+}
+function hasCompressSettings(s3) {
+  return Object.values(s3).some((v2) => v2 !== void 0);
+}
+function applyCompressSettings(base, limit, s3) {
+  const nudge = { ...base.nudge };
+  const truncate = { ...base.truncate };
+  if (s3.maxContextLimit !== void 0) nudge.maxContextLimitPct = parsePercent(s3.maxContextLimit);
+  if (s3.emergencyThresholdPercent !== void 0) {
+    const pct2 = parsePercent(s3.emergencyThresholdPercent);
+    nudge.emergencyThresholdPct = pct2;
+    truncate.threshold = pct2;
+  }
+  if (s3.nudgeGrowthTokens !== void 0 && s3.nudgeGrowthTokens > 0) {
+    nudge.growthFloor = s3.nudgeGrowthTokens;
+    nudge.growthCap = s3.nudgeGrowthTokens;
+  }
+  const tiers = { ...base.tiers };
+  if (s3.tiers !== void 0) tiers.enabled = s3.tiers;
+  return {
+    ...base,
+    modelContextLimit: limit,
+    nudge,
+    truncate,
+    tiers,
+    preserveRecentMessages: s3.preserveRecentMessages ?? base.preserveRecentMessages,
+    preserveRecentTokens: s3.preserveRecentTokens ?? base.preserveRecentTokens,
+    compress: {
+      ...base.compress,
+      minCompressRange: s3.minCompressRange ?? base.compress.minCompressRange
+    }
+  };
+}
+function parsePercent(v2) {
+  if (typeof v2 === "number") return v2;
+  const s3 = v2.trim();
+  if (s3.endsWith("%")) return Number(s3.slice(0, -1)) / 100;
+  return Number(s3);
+}
+
 // src/registry.ts
 import { readFile, writeFile, mkdir } from "fs/promises";
 import { existsSync as existsSync2, statSync as statSync2 } from "fs";
@@ -48978,7 +49210,7 @@ function createResponsesAdapter(textProtocol, projection) {
             });
           } else if (item?.type === "custom_tool_call") {
             yield { kind: "meta", chunk: rawBuf, firstRoundOnly: false };
-          } else if (!suppressTextLifecycle) {
+          } else if (item?.type !== "message" || !suppressTextLifecycle) {
             yield { kind: "meta", chunk: rawBuf, firstRoundOnly: true };
           }
         } else if (type === "response.content_part.added" || type === "response.content_part.done" || type === "response.output_text.done") {
@@ -49017,7 +49249,7 @@ function createResponsesAdapter(textProtocol, projection) {
             }
           } else if (item?.type === "custom_tool_call") {
             yield { kind: "meta", chunk: rawBuf, firstRoundOnly: false };
-          } else if (!suppressTextLifecycle) {
+          } else if (item?.type !== "message" || !suppressTextLifecycle) {
             yield { kind: "meta", chunk: rawBuf, firstRoundOnly: true };
           }
         } else if (type === "response.completed") {
@@ -51415,8 +51647,9 @@ ${bodyBuffer.toString("utf8")}`);
     const model = parsed.model;
     if (model) {
       const embeddedUrl = route?.rewrittenUrl;
-      let limit = resolveContextLimit(opts.routes, embeddedUrl, model);
-      if (!limit && embeddedUrl) {
+      const compress = resolveCompress(opts.routes, embeddedUrl, model, opts.compress);
+      let native = resolveContextLimit(opts.routes, embeddedUrl, model);
+      if (!native && embeddedUrl) {
         const host = (() => {
           try {
             return new URL(embeddedUrl).host;
@@ -51424,10 +51657,12 @@ ${bodyBuffer.toString("utf8")}`);
             return void 0;
           }
         })();
-        limit = await contextFromRegistry(model, host);
+        native = await contextFromRegistry(model, host);
       }
-      if (limit && limit !== config.modelContextLimit) {
-        reqConfig = { ...config, modelContextLimit: limit };
+      const limit = resolveContextLimitValue(compress.modelContextLimit, native ?? config.modelContextLimit);
+      const tuned = hasCompressSettings(compress);
+      if (tuned || limit !== config.modelContextLimit) {
+        reqConfig = applyCompressSettings(config, limit, compress);
       }
     }
   }
@@ -51523,7 +51758,7 @@ function prepareAnthropic(parsed, req, opts, core, config, log2, session) {
     if (opts.compress.injectTool) {
       toolsOut = injectTool(parsed.tools);
     }
-    if (turn.nudge?.shouldInject) {
+    if (opts.compress.injectNudge && turn.nudge?.shouldInject) {
       try {
         const rendered = renderNudgeText(turn.nudge);
         if (rendered.text) {
@@ -51575,7 +51810,7 @@ function prepareOpenai(parsed, req, opts, core, config, log2, session) {
     if (shouldInject) {
       toolsOut = injectOpenaiTool(parsed.tools);
     }
-    if (turn.nudge?.shouldInject && shouldInject) {
+    if (opts.compress.injectNudge && turn.nudge?.shouldInject && shouldInject) {
       try {
         const rendered = renderNudgeText(turn.nudge);
         if (rendered.text) {
@@ -51642,7 +51877,7 @@ function prepareResponses(parsed, req, opts, core, config, log2, session, identi
     } else if (projection.systemParts.length > 0) {
       rebuiltInput = injectResponsesDeveloperMessage(rebuiltInput, projection.systemParts.join("\n\n---\n\n"));
     }
-    if (turn.nudge?.shouldInject && shouldInject) {
+    if (opts.compress.injectNudge && turn.nudge?.shouldInject && shouldInject) {
       try {
         const rendered = renderNudgeText(turn.nudge);
         if (rendered.text) {
@@ -55725,7 +55960,7 @@ function stopProxy(handle2) {
 function runClient(cmd, args, env, deps) {
   const spawnImpl = deps?.spawnImpl ?? spawn;
   return new Promise((resolve, reject) => {
-    const child = spawnImpl(cmd, args, { stdio: "inherit", env });
+    const child = spawnImpl(cmd, args, { stdio: "inherit", env, shell: process.platform === "win32" });
     child.on?.("error", (...rest) => reject(rest[0]));
     child.on?.("exit", (...rest) => {
       const code = rest[0];
@@ -55734,31 +55969,36 @@ function runClient(cmd, args, env, deps) {
     });
   });
 }
-function isOnPath(name, env) {
+var PATH_EXTS = process.platform === "win32" ? [".cmd", ".bat", ".exe", ""] : [""];
+function resolveOnPath(name, env) {
   const p2 = env.PATH;
-  if (!p2) return false;
-  return p2.split(":").some((dir) => {
-    if (!dir) return false;
-    try {
-      const f2 = path9.join(dir, name);
-      return fs7.existsSync(f2) && fs7.statSync(f2).isFile();
-    } catch {
-      return false;
+  if (!p2) return void 0;
+  for (const dir of p2.split(path9.delimiter)) {
+    if (!dir) continue;
+    for (const ext of PATH_EXTS) {
+      const f2 = path9.join(dir, name + ext);
+      try {
+        if (fs7.existsSync(f2) && fs7.statSync(f2).isFile()) return f2;
+      } catch {
+      }
     }
-  });
+  }
+  return void 0;
 }
 function resolveClientCommand(client, env) {
   if (client === "pi") {
     const piBin = env.PI_BIN?.trim();
     if (piBin) return { command: piBin, prefixArgs: [] };
-    if (isOnPath("pi", env)) return { command: "pi", prefixArgs: [] };
+    const piResolved = resolveOnPath("pi", env);
+    if (piResolved) return { command: piResolved, prefixArgs: [] };
     const cli = path9.join(
       os4.homedir(),
       ".pi/agent/npm/node_modules/@earendil-works/pi-coding-agent/dist/cli.js"
     );
     return { command: process.execPath, prefixArgs: [cli] };
   }
-  return { command: client, prefixArgs: [] };
+  const resolved = resolveOnPath(client, env);
+  return { command: resolved ?? client, prefixArgs: [] };
 }
 function parsePort(raw) {
   const port = raw && raw.trim() ? parseInt(raw, 10) : LAUNCHER_DEFAULT_PORT;