billion-context-omp 0.1.7 → 0.1.9

package/dist/index.js

@@ -287,7 +287,8 @@ function defaultConfig(modelContextLimit, overrides = {}) {
       growthCap: 5e4,
       minGrowthFloor: 2e4,
       minGrowthRatio: 0.45,
-      emergencyThresholdPct: 0.95
+      emergencyThresholdPct: 0.95,
+      tier2GrowthMultiplier: 1.5
     },
     promotionThreshold: 5,
     truncate: { threshold: 0.95 },
@@ -1012,6 +1013,44 @@ function buildCompressibleRanges(messages, state, config, protectedZoneRefs, cou
     protected: protectedRanges
   };
 }
+function mergeBatch(batch) {
+  const first = batch[0];
+  const last = batch[batch.length - 1];
+  const count = batch.reduce((s, r) => s + r.count, 0);
+  const tokens = batch.reduce((s, r) => s + r.tokens, 0);
+  const toolPct = Math.round(
+    batch.reduce((s, r) => s + r.toolPct * r.count, 0) / count
+  );
+  const merged = {
+    startRef: first.startRef,
+    endRef: last.endRef,
+    count,
+    tokens,
+    toolPct,
+    textPct: 100 - toolPct
+  };
+  if (batch.some((r) => r.dangerous === true)) {
+    merged.dangerous = true;
+  }
+  return merged;
+}
+function mergeRangesToThreshold(ranges, minChars) {
+  if (minChars <= 0 || ranges.length === 0) return ranges;
+  const result = [];
+  let batch = [];
+  for (const r of ranges) {
+    batch.push(r);
+    const batchTokens = batch.reduce((s, x) => s + x.tokens, 0);
+    if (batchTokens * 4 >= minChars) {
+      result.push(mergeBatch(batch));
+      batch = [];
+    }
+  }
+  if (batch.length > 0) {
+    result.push(mergeBatch(batch));
+  }
+  return result;
+}
 function runPipeline(nodes, initial, ctx) {
   let io = initial;
   for (const node of nodes) {
@@ -1291,7 +1330,10 @@ var recommendNode = {
     const nothingToCompress = contextRanges.compressible.length === 0;
     const recommendation = {
       contextRanges,
-      recommendedRanges: contextRanges.compressible,
+      recommendedRanges: mergeRangesToThreshold(
+        contextRanges.compressible,
+        ctx.config.compress.minCompressRange
+      ),
       nothingToCompress
     };
     return { ...io, effects: { ...io.effects, recommendation } };
@@ -1317,6 +1359,7 @@ var nudgeNode = {
     if (baseline > 0 && ctx.tokenCount < baseline - nudgeGrowthTokens) {
       stamped.lastPerMessageNudgeTokens = ctx.tokenCount;
       stamped.lastNudgeShownTokens = 0;
+      stamped.lastShownByTier = {};
     }
     if (stamped.lastPerMessageNudgeTokens === 0) {
       stamped.lastPerMessageNudgeTokens = ctx.tokenCount;
@@ -1585,10 +1628,11 @@ function resolveAdaptiveGrowth(modelContextLimit, nudge) {
     )
   );
 }
-function pendingByTier(state, recommendation, countTokens) {
+function pendingByTier(state, recommendation, countTokens, minCompressRange) {
   const out = {};
-  const compressible = recommendation?.contextRanges.compressible ?? [];
-  out[1] = { pending: compressible.reduce((s, r) => s + r.tokens, 0), targetBlocks: [] };
+  const merged = recommendation?.recommendedRanges ?? [];
+  const effective = minCompressRange > 0 ? merged.filter((r) => r.tokens * 4 >= minCompressRange) : merged;
+  out[1] = { pending: effective.reduce((s, r) => s + r.tokens, 0), targetBlocks: [] };
   const active = activeBlocks(state);
   const t1 = active.filter((b) => b.tier === 1);
   const t2 = active.filter((b) => b.tier === 2);
@@ -1603,6 +1647,7 @@ function decideNudge(input) {
   const nudgeGrowthTokens = resolveAdaptiveGrowth(limit, config.nudge);
   const overLimit = usage >= config.nudge.maxContextLimitPct;
   const emergencyOverride = usage >= config.nudge.emergencyThresholdPct;
+  const pressure = overLimit || emergencyOverride;
   const baseline = state.nudge.lastPerMessageNudgeTokens;
   const hadPendingNudge = state.nudge.lastNudgeShownTokens > 0;
   const hasPendingNudge = hadPendingNudge;
@@ -1614,44 +1659,67 @@ function decideNudge(input) {
   );
   const growthSinceReference = tokenCount - growthReference;
   const rec = recommendation;
-  const tiers = pendingByTier(state, rec, countTokens);
+  const tiers = pendingByTier(
+    state,
+    rec,
+    countTokens,
+    config.compress.minCompressRange
+  );
+  const tier2Threshold = Math.round(
+    nudgeGrowthTokens * (config.nudge.tier2GrowthMultiplier ?? 1.5)
+  );
   let injectedTier = null;
   let injectedReason = "";
   const growthReady = growthSinceReference >= growthFloor;
-  if (!overLimit && growthReady) {
-    for (const tier of [1, 2, 3]) {
-      if (!config.tiers.enabled && tier > 1) break;
-      const info = tiers[tier];
-      if (!info || info.pending < nudgeGrowthTokens) continue;
-      const lastShown = state.nudge.lastShownByTier[tier] ?? 0;
-      const cadenceMet = lastShown === 0 || tokenCount - lastShown >= growthFloor;
-      if (!cadenceMet) continue;
-      injectedTier = tier;
-      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;
+  const t1Eff = tiers[1]?.pending ?? 0;
+  const t2Pen = tiers[2]?.pending ?? 0;
+  const t3Pen = tiers[3]?.pending ?? 0;
+  if (pressure) {
+    const candidates = [1];
+    if (config.tiers.enabled) {
+      candidates.push(2, 3);
+    }
+    let best = null;
+    let bestPending = 0;
+    for (const t of candidates) {
+      const p = tiers[t]?.pending ?? 0;
+      if (p > bestPending) {
+        bestPending = p;
+        best = t;
+      }
     }
-  } 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;
+    if (best !== null && bestPending > 0) {
+      injectedTier = best;
+      const label = emergencyOverride ? "EMERGENCY" : "OVER-LIMIT";
+      injectedReason = best === 1 ? `${label} T1: max effective pending ${bestPending}, usage ${Math.round(usage * 100)}%` : `${label} T${best} distill: max pending ${bestPending} (T1 effective ${t1Eff}, T2 ${t2Pen}, T3 ${t3Pen}), usage ${Math.round(usage * 100)}%`;
+    }
+  } else if (growthReady) {
+    if (t1Eff >= nudgeGrowthTokens) {
+      injectedTier = 1;
+      injectedReason = `T1 effective ${t1Eff} >= ${nudgeGrowthTokens}, growth ${growthSinceReference}, usage ${Math.round(usage * 100)}%`;
+    } else if (config.tiers.enabled && t2Pen >= tier2Threshold && t2Pen > t1Eff) {
+      const lastShown = state.nudge.lastShownByTier[2] ?? 0;
+      const cadenceMet = lastShown === 0 || tokenCount - lastShown >= growthFloor;
+      if (cadenceMet) {
+        injectedTier = 2;
+        injectedReason = `T2 distill ready: ${tiers[2].targetBlocks.length} tier-1 blocks (${t2Pen} tokens) >= ${tier2Threshold} (1.5x) and > T1 effective ${t1Eff}, usage ${Math.round(usage * 100)}%`;
+      }
+    } else if (config.tiers.enabled && t3Pen >= tier2Threshold && t3Pen > t2Pen && t3Pen > t1Eff) {
+      const lastShown = state.nudge.lastShownByTier[3] ?? 0;
+      const cadenceMet = lastShown === 0 || tokenCount - lastShown >= growthFloor;
+      if (cadenceMet) {
+        injectedTier = 3;
+        injectedReason = `T3 condense ready: ${tiers[3].targetBlocks.length} tier-2 blocks (${t3Pen} tokens) >= ${tier2Threshold} (1.5x) and > T2 ${t2Pen} and > T1 effective ${t1Eff}, usage ${Math.round(usage * 100)}%`;
+      }
     }
   }
-  const shouldInject = injectedTier !== null || overLimit && (rec?.recommendedRanges?.length ?? 0) > 0;
+  const shouldInject = injectedTier !== null;
   let reason;
-  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) {
+  if (injectedTier !== null) {
     reason = injectedReason;
+  } else if (pressure) {
+    const label = emergencyOverride ? "EMERGENCY" : "OVER-LIMIT";
+    reason = `${label}: usage ${Math.round(usage * 100)}% but no tier has effective compressible content (T1 effective ${t1Eff}, T2 ${t2Pen}, T3 ${t3Pen}) \u2014 nudge suppressed to avoid offering ranges below minCompressRange`;
   } else {
     const tiersList = [1, 2, 3];
     const eligible = tiersList.filter((t) => config.tiers.enabled || t === 1);
@@ -2000,20 +2068,23 @@ ${lines.join("\n")}`;
 function renderNudgeText(decision, prompts = defaultPrompts) {
   const breakdownStr = formatBreakdown(decision.contextBreakdown);
   const rangesStr = formatRanges(decision.compressibleRanges, decision.protectedRanges ?? []);
+  const isEmergency = !!decision.breakdown?.emergencyOverride || !!decision.breakdown?.overLimit;
   if (decision.tier !== null && decision.tier >= 2) {
     const isT2 = decision.tier === 2;
     const targets = decision.tierTargetBlocks ?? [];
     const blockList = formatTierTargetBlocks(targets);
     const startId = targets[0]?.blockId ?? "b1";
     const endId = targets[targets.length - 1]?.blockId ?? "b5";
+    const voice = isEmergency ? "emergency" : "gentle";
+    const triggerLine = isEmergency ? `[EMERGENCY \u2014 TIER ${decision.tier} ${isT2 ? "DISTILLATION" : "CONDENSATION"}] Context limit reached \u2014 distill NOW into a denser summary to reclaim tokens.` : `[TIER ${decision.tier} ${isT2 ? "DISTILLATION" : "CONDENSATION"} TRIGGER]`;
     return {
-      voice: "gentle",
+      voice,
       text: [
         efficiencyNote(prompts),
         "",
         breakdownStr,
         "",
-        `[TIER ${decision.tier} ${isT2 ? "DISTILLATION" : "CONDENSATION"} TRIGGER]`,
+        triggerLine,
         isT2 ? `Your tier-1 compression summaries have accumulated. Distill them into a single denser tier-2 summary. Use block IDs as boundaries (startId and endId as bN). Any raw (uncompressed) messages sitting between the boundary blocks are absorbed into the tier-2 block as well \u2014 apply HOW TO COMPRESS to those raw messages and the TIER 2 distillation rules to the existing summaries, so the whole span is covered and nothing is lost.` : `Your tier-2 compression summaries have accumulated. Condense them further into a tier-3 ultra-condensed summary. Use block IDs as boundaries (startId and endId as bN). Any raw (uncompressed) messages sitting between the boundary blocks are absorbed into the tier-3 block as well \u2014 apply HOW TO COMPRESS to those raw messages and the TIER 3 condensation rules to the existing summaries, so the whole span is covered and nothing is lost.`,
         blockList,
         `Example: compress({ content: [{ startId: "${startId}", endId: "${endId}", summary: "..." }] })`,
@@ -2024,7 +2095,6 @@ function renderNudgeText(decision, prompts = defaultPrompts) {
       ].join("\n")
     };
   }
-  const isEmergency = !!decision.breakdown?.emergencyOverride || !!decision.breakdown?.overLimit;
   if (isEmergency) {
     return {
       voice: "emergency",
@@ -2388,9 +2458,9 @@ function charBigrams(text) {
   }
   return grams;
 }
-function tfMap(text, stem2) {
+function tfMap(text, stem22) {
   const m = /* @__PURE__ */ new Map();
-  for (const t of tokenize(text, { stem: stem2 })) m.set(t, (m.get(t) ?? 0) + 1);
+  for (const t of tokenize(text, { stem: stem22 })) m.set(t, (m.get(t) ?? 0) + 1);
   return m;
 }
 var bm25Algorithm = {
@@ -2784,6 +2854,13 @@ function compressToolArgs(call) {
 function projectMessage(message, id) {
   const msg = message;
   const role = msg.role;
+  if (role === "compactionSummary" || role === "branchSummary") {
+    const text = (msg.summary ?? "").trim();
+    if (text.length === 0) return [];
+    const label = role === "branchSummary" ? "branch summary" : "compaction summary";
+    return [{ id, role: "user", contentType: "text", text: `${SUMMARY_HEADER} \u2014 omp ${label}
+${text}` }];
+  }
   if (role === "user") {
     return [{ id, role: "user", contentType: "text", text: extractText(msg.content) }];
   }
@@ -3081,8 +3158,13 @@ function rangeFingerprints(ranges, coreMessages, byRef, blocks) {
 }
 
 // src/runtime.ts
-function freshSlot() {
-  return { identities: [], foldedLen: 0, preview: false, state: createInitialState(), coreMessages: [], appliedCallIds: /* @__PURE__ */ new Set() };
+function freshSlot(preserveFrom) {
+  const slot = { identities: [], foldedLen: 0, preview: false, state: createInitialState(), coreMessages: [], appliedCallIds: /* @__PURE__ */ new Set(), rejectStreak: 0 };
+  if (preserveFrom) {
+    slot.state = { ...slot.state, nudge: preserveFrom.state.nudge };
+    slot.rejectStreak = preserveFrom.rejectStreak;
+  }
+  return slot;
 }
 function stateHasCompressCall(state, callId) {
   return state.blocks.some((b) => b.compressCallId === callId);
@@ -3128,7 +3210,7 @@ function createRuntime(adapter) {
     let slot = slotFor(sid);
     if (slot.preview) {
       debug.event("fold-refold", { sid, foldedLen: slot.foldedLen, lcp: 0, streamLen: stream.length, reason: "preview" });
-      slot = freshSlot();
+      slot = freshSlot(slot);
       slots.set(sid, slot);
     }
     const ids = stream.map(messageIdentity);
@@ -3136,7 +3218,7 @@ function createRuntime(adapter) {
     while (lcp < Math.min(ids.length, slot.identities.length) && ids[lcp] === slot.identities[lcp]) lcp++;
     if (lcp < slot.foldedLen) {
       debug.event("fold-refold", { sid, foldedLen: slot.foldedLen, lcp, streamLen: ids.length });
-      slot = freshSlot();
+      slot = freshSlot(slot);
       slots.set(sid, slot);
       lcp = 0;
     }
@@ -3218,6 +3300,11 @@ function createRuntime(adapter) {
     slot.state = state;
     if (toolCallId) slot.appliedCallIds.add(toolCallId);
   }
+  function noteCompressOutcome(ctx, ok) {
+    const slot = slotFor(sidOf(ctx));
+    slot.rejectStreak = ok ? 0 : slot.rejectStreak + 1;
+    return slot.rejectStreak;
+  }
   return {
     core,
     get adapter() {
@@ -3237,6 +3324,7 @@ function createRuntime(adapter) {
     foldStream,
     stateFor,
     commitFoldState,
+    noteCompressOutcome,
     forgetSession,
     primeFold,
     acquireLock
@@ -3310,7 +3398,17 @@ function makeCompressTool(runtime) {
   return {
     name: "compress",
     label: "Compress",
-    description: 'Replace older conversation ranges with detailed summaries you write. Single range: compress({ content: [{ "topic": "Session Opener", "startId": "m00004", "endId": "m00022", "summary": "..." }] }) \u2014 a short topic label is recommended but optional. Batch: one entry per range in content[]. The JSON you write must be strict: escape every double quote inside summaries.',
+    // Stay a top-level tool. Extension tools default to "discoverable", which
+    // omp's tools.xdev mounts behind the xd://compress device — forcing the
+    // model to hand-write JSON-inside-a-JSON-string via the write tool. That
+    // double-escaping layer was the direct cause of issue #21's parse errors
+    // and truncated write calls; top-level structured args eliminate it.
+    // (Found independently in #36, which also surfaced that device-mounted
+    // descriptions are capped at 200 chars — XDEV_EXTERNAL_DESCRIPTION_CAP in
+    // the host — so the escaping guidance in this description never even
+    // reached the model while device-mounted.)
+    loadMode: "essential",
+    description: 'Replace older conversation ranges with detailed summaries you write. Single range: compress({ content: [{ "topic": "Session Opener", "startId": "m00004", "endId": "m00022", "summary": "..." }] }) \u2014 a short topic label is recommended but optional. Batch: one entry per range in content[].',
     parameters: CompressParams,
     async execute(toolCallId, params, _signal, _onUpdate, ctx) {
       let result;
@@ -3357,7 +3455,7 @@ async function handleCompress(args, runtime, ctx, toolCallId) {
     const invalidRanges = rangeSpecs.filter((r) => !r.startRef || !r.endRef || typeof r.startRef !== "string" || typeof r.endRef !== "string");
     if (invalidRanges.length > 0) {
       logError("compress", { sid: ctx.sessionManager.getSessionId(), event: "invalid-ranges", count: invalidRanges.length, ranges: invalidRanges.map((r) => `${r.startRef}..${r.endRef}`) });
-      return `Rejected: ${invalidRanges.length} range(s) have invalid startId or endId (missing or non-string). All ranges must have valid message refs (e.g. "m00005") or block IDs (e.g. "b3"). No changes applied \u2014 run acp_status for current refs.`;
+      return rejectionMessage(ctx, runtime, `Rejected: ${invalidRanges.length} range(s) have invalid startId or endId (missing or non-string). All ranges must have valid message refs (e.g. "m00005") or block IDs (e.g. "b3"). No changes applied \u2014 run acp_status for current refs.`);
     }
     let applied;
     try {
@@ -3369,12 +3467,13 @@ async function handleCompress(args, runtime, ctx, toolCallId) {
       });
     } catch (e) {
       logThrow("compress", e, { sid: ctx.sessionManager.getSessionId(), phase: "applyCompression", ranges: rangeSpecs.length });
-      return `Compression failed: ${e instanceof Error ? e.message : String(e)}. No changes applied \u2014 state is unchanged.`;
+      return rejectionMessage(ctx, runtime, `Compression failed: ${e instanceof Error ? e.message : String(e)}. No changes applied \u2014 state is unchanged.`);
     }
     if (applied.result.errors.length > 0) {
       logError("compress", { sid: ctx.sessionManager.getSessionId(), event: "apply-errors", count: applied.result.errors.length, errors: applied.result.errors.slice(0, 5) });
-      return `Compression rejected: ${applied.result.errors.join("; ")}. No changes applied \u2014 run acp_status to verify current state.`;
+      return rejectionMessage(ctx, runtime, `Compression rejected: ${applied.result.errors.join("; ")}. No changes applied \u2014 run acp_status to verify current state.`);
     }
+    runtime.noteCompressOutcome(ctx, true);
     await runtime.commitFoldState(ctx, applied.state, toolCallId);
     const { blocksCreated, tokensCompressed, warnings } = applied.result;
     const afterTokens = Math.max(0, beforeTokens - tokensCompressed);
@@ -3415,6 +3514,22 @@ async function handleCompress(args, runtime, ctx, toolCallId) {
     releaseLock();
   }
 }
+var LOOP_GUARD_STOP = 3;
+var LOOP_GUARD_SUPPRESS = 4;
+function rejectionMessage(ctx, runtime, base) {
+  const streak = runtime.noteCompressOutcome(ctx, false);
+  if (streak >= LOOP_GUARD_SUPPRESS) {
+    logWarn("compress", { sid: ctx.sessionManager.getSessionId(), event: "loop-guard", streak, mode: "suppressed" });
+    return `Compression rejected (again \u2014 ${streak} consecutive rejections). No changes applied. STOP calling compress; it is not converging. Continue the task. Compress stays available: a fresh attempt works when acp_status shows a range that can meet the minimum size.`;
+  }
+  if (streak >= LOOP_GUARD_STOP) {
+    logWarn("compress", { sid: ctx.sessionManager.getSessionId(), event: "loop-guard", streak, mode: "stop-directive" });
+    return `${base}
+
+STOP: ${streak} compress calls rejected in a row. Do NOT retry the same range. Run acp_status to see what is actually compressible now; if no range can meet the minimum size, nothing is left to compress \u2014 stop and continue the actual task.`;
+  }
+  return base;
+}
 
 // src/decompress-tool.ts
 import { type as type2 } from "@oh-my-pi/omptype";
@@ -3435,6 +3550,9 @@ function makeDecompressTool(runtime) {
   return {
     name: "decompress",
     label: "Decompress",
+    // Top-level (see compress-tool.ts): the xd:// device indirection trades
+    // a few schema tokens per request for a JSON-in-JSON escaping trap.
+    loadMode: "essential",
     description: "Restore a previously compressed block's content, or a single message by its ref. The block/message stays compressed \u2014 context and cache prefix are not disrupted. BLOCK decompress (blockId b5) defaults to writing a file (blocks can be large); use the read tool to access it, or inline:true to return inline. MESSAGE decompress (blockId = a message ref from search_context) returns that ONE message's original text \u2014 defaults to inline since a single message is usually small; oversized messages go to a file. full:true recurses through nested block tiers (block mode only). You can pass a block id (b5) OR a message ref (e.g. m00123) from search_context results.",
     parameters: DecompressParams,
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
@@ -3629,6 +3747,9 @@ function makeSearchTool(runtime) {
   return {
     name: "search_context",
     label: "Search Context",
+    // Top-level (see compress-tool.ts): schema is tiny; the xd://
+    // indirection costs more in call friction than it saves in tokens.
+    loadMode: "essential",
     description: "Search compressed blocks AND historical messages by keyword. Use to cheaply locate detail before decompressing. Returns ranked results with ref, size, preview, and the decompress command to retrieve full content.",
     parameters: SearchParams,
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
@@ -3697,6 +3818,420 @@ function getSystemPromptText(ctx) {
   return normalizeSystemPrompt(result);
 }
 
+// node_modules/billion-context-kit/node_modules/acp-kernel/dist/index.js
+import { createRequire as createRequire2 } from "module";
+var BLOCKED_REF2 = "BLOCKED";
+function refForRaw2(map, rawId) {
+  return map.byRaw[rawId] ?? null;
+}
+var require22 = createRequire2(import.meta.url);
+function defaultCountTokens2(text) {
+  if (!text) return 0;
+  const cjk = text.match(/[\u4e00-\u9fff\u3040-\u30ff\uac00-\ud7af]/g);
+  const cjkCount = cjk?.length ?? 0;
+  return cjkCount + Math.ceil((text.length - cjkCount) / 4);
+}
+function formatTokens4(tokens) {
+  if (tokens < 1e3) return String(tokens);
+  if (tokens < 1e4) return (tokens / 1e3).toFixed(1) + "K";
+  return Math.round(tokens / 1e3) + "K";
+}
+function classifyType2(message) {
+  if (message.contentType === "tool-call" || message.contentType === "tool-result") {
+    return message.toolName || "tool";
+  }
+  return message.contentType;
+}
+function escapeRegex2(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var LT2 = "<";
+var GT2 = ">";
+var TAG_OPEN2 = LT2 + "acp ";
+var TAG_CLOSE2 = LT2 + "/acp" + GT2;
+function acpTag2(ref, tokens, type5) {
+  return TAG_OPEN2 + 'tokens="' + formatTokens4(tokens) + '" type="' + type5 + '"' + GT2 + ref + TAG_CLOSE2;
+}
+function renderMessage2(message, map, countTokens, strategy) {
+  const ref = refForRaw2(map, message.id);
+  if (!ref || ref === BLOCKED_REF2) return message;
+  if (strategy === "none") return message;
+  if (strategy === "text-only" && message.contentType !== "text") {
+    return message;
+  }
+  const ownTagRe = new RegExp(
+    "^" + escapeRegex2(TAG_OPEN2) + "[^>]*" + GT2 + escapeRegex2(ref) + escapeRegex2(TAG_CLOSE2) + "\\n?"
+  );
+  const cleanText = (message.text || "").replace(ownTagRe, "");
+  const tokens = countTokens(cleanText);
+  const type5 = classifyType2(message);
+  const prefix = acpTag2(ref, tokens, type5) + "\n";
+  if (!cleanText) return { ...message, text: prefix };
+  return { ...message, text: prefix + cleanText };
+}
+function renderVisibleRefs2(messages, state, countTokens = (text) => Math.ceil(text.length / 4), strategy = "all") {
+  const map = state.messageRefs;
+  return messages.map(
+    (message) => renderMessage2(message, map, countTokens, strategy)
+  );
+}
+function createRenderRefsNode2(strategy) {
+  return {
+    name: "render-refs",
+    run(io, ctx) {
+      return {
+        ...io,
+        messages: renderVisibleRefs2(io.messages, io.state, ctx.countTokens, strategy)
+      };
+    }
+  };
+}
+var renderRefsNode2 = createRenderRefsNode2("all");
+var COMPRESS_PHILOSOPHY2 = `Compression Philosophy:
+- All compression serves the primary task, but be frugal.
+- Context capacity is precious. Save context by compressing consumed outputs, not by avoiding tools.
+- Compress by need, not by percentage.
+- Work from summaries, not raw tool outputs. All listed ranges (user prompts, tool outputs, code, logs, exploration, intermediate steps) 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.`;
+var HOW_TO_COMPRESS_RULES2 = `HOW TO COMPRESS
+
+When you call \`compress\`, the summary you write becomes the only record of the replaced conversation. Make it self-contained and complete: every user request, experiment purpose, and work task in the range must be accurately captured. A later reader (or you, after decompressing) should be able to continue the task WITHOUT needing the original.
+
+KEEP VERBATIM \u2014 never paraphrase or abbreviate these:
+- Full file paths with line numbers, directory prefix on every mention (\`lib/hooks.ts:347\`, \`src/index.ts:12-18\`, \`gatenet_v3/model.py:45\`). Never abbreviate to a bare filename (\`hooks.ts\`, \`model.py\`) \u2014 they are ambiguous and cannot be grepped or decompressed-to later.
+- Function, class, and type signatures (exact names, params, return types) AND critical code lines that encode logic \u2014 the line that IS the finding, not just the function name (e.g. \`kv_keys += define_gate * a_key[i](emb)\` is more useful than "see model_kvnet.py").
+- Error messages and stack traces (exact text \u2014 you need the literal string to grep for it later).
+- Key details from reports and analyses \u2014 not just the conclusion. Keep the comparison numbers and the mechanism, not "X is worse" alone (write "1.76\xD7 PPL gap because KV store is static", not "KVNet underperforms").
+- Decisions and their rationale ("chose X over Y because Z" \u2014 the "because" is load-bearing; without it the decision looks arbitrary).
+- Constraints discovered ("must support Node 22", "no new dependencies", "AGENTS.md forbids \`as any\`").
+- Exact values: versions, config keys, thresholds, magic numbers.
+- User intent \u2014 quote short user messages verbatim. When the message is too long to quote, preserve intent with extra care: do not change scope, constraints, priorities, acceptance criteria, or requested outcomes. Mark them clearly as past quotes (e.g., "User said: ..."), not as current directives. Losing these changes the task itself.
+- The user's overall goal and any changes to it \u2014 the big-picture objective plus how it evolved during the compressed range. Each summary must reflect the goal as it stood at the end of the range, including pivots (e.g., "initially: fix bug X \u2192 pivoted to: refactor module Y after discovering root cause"). Losing the goal or its evolution makes all subsequent work appear unmotivated.
+- Purpose behind each significant action \u2014 preserve not just what was done but why: the hypothesis behind each experiment, the question behind each exploration, the task goal behind each work action. Without purpose, the summary reads as disconnected technical steps with no through-line.
+- Open questions and unresolved TODOs \u2014 losing these changes what work appears to remain.
+- Message refs of key anchors (\`m00420\`, \`m00510\u2013m00520\`) \u2014 they let you or a later reader jump back via decompress to the exact original.
+
+DROP \u2014 extract the signal, discard the vessel:
+- Verbose logs (build/test/\`npm\` output) once you have captured the error line or the result.
+- Duplicate file reads once the needed content is recorded.
+- Consumed exploration \u2014 search hits, agent return values, successful tool outputs \u2014 once you have extracted the facts you need (same rule as dead-ends, but nothing went wrong; the content is simply spent).
+- Dead-end exploration \u2014 but PRESERVE the lesson in one line: "tried X, failed because Y".
+- Back-and-forth discussion and self-corrections once the final position is captured (keep the outcome, drop the journey to it).
+- Repeated status checks (\`git status\`, \`ls\`) once state is known.
+
+For each significant item you DROP (scripts, reports, large analyses, long tool outputs), add a one-line CONTENT description of what it covers \u2014 not where it lives. Bad: "probe script at /path/probe_kvnet.py". Good: "probe_kvnet.py: tests n-gram baseline, generation quality, long-range dependency, position sensitivity, op pipeline, QUERY attention." This lets a later decompress target the right block by relevance, not by guessing locations.
+
+PRIORITY \u2014 when the summary must be compact, preserve in this order:
+1. User's overall goal, goal evolution, intent, and hard constraints (losing these changes the task).
+2. Decisions and rationale.
+3. Exact technical artifacts: paths, signatures, errors, values.
+4. Conclusions and key findings.
+5. Lessons learned: what failed and why.
+
+Write dense, scannable bullets \u2014 not narrative prose. If the range spans distinct concerns (request \u2192 findings \u2192 decision), group bullets under short thematic headers so a reader can scan to the part they need. Every line must earn its place. Do not mimic the style of existing summaries in context; follow these rules.`;
+var TIER2_DISTILL_RULES2 = `TIER 2 COMPRESSION \u2014 DISTILLATION
+
+You are compressing historical summaries (not raw conversation). These summaries have already captured the details. Your job is to DISTILL them: extract only what matters for future work, discard the process.
+
+KEEP \u2014 these are the only things that survive distillation:
+- Decisions and their rationale ("chose X over Y because Z" \u2014 the "because" is load-bearing).
+- Final outcomes: version numbers shipped, PR numbers merged/closed, bugs fixed or deferred.
+- Key lessons: what failed and why ("tried X, failed because Y"). These prevent repeating mistakes.
+- Critical constraints discovered ("must support Node 22", "AGENTS.md forbids as any").
+- Design decisions with architectural impact ("chose compress-as-anchor over synthetic messages because prefix cache").
+- Whether content is OBSOLETE or SUPERSEDED \u2014 mark with one line: "[SUPERSEDED by PR #NNN]" or "[OBSOLETE: deleted in vX.Y.Z]". Do NOT keep the obsolete content's details \u2014 just the marker and reason.
+- Function/class/type names and module paths that are the SUBJECT of the work \u2014 e.g., "fixed filterCompressedRanges in prune.ts", "added SessionStateRegistry in state.ts". Not exact line numbers or full signatures \u2014 just enough to LOCATE the code without searching.
+- Exploration findings: if a block was exploratory with no decision, keep the CONCLUSION in one line ("explored X, not viable because Y"). Do not keep the exploration process.
+
+DROP \u2014 these were useful during the work but are no longer needed:
+- Exact line numbers, diffs, verbose function signatures, full code listings.
+- Build/deploy process details, test execution steps.
+- Review process details (who reviewed, what rounds, test counts).
+- Verbose logs, command output, intermediate debugging steps.
+
+FORMAT:
+- Start each distilled block with a source header line:
+  \`Source: bN+bM+... (XK\u2192YK tok, Zx). [original topic]\`
+  Example: \`Source: b5+b7 (56K+44K\u2192268 tok, 375x). [Tool-result recap + publish]\`
+- 3-5 bullet points per source block, each a self-contained fact.
+- Dense, scannable \u2014 no narrative prose.
+- Start with the outcome, not the process: "v1.13.0 shipped (7 PRs bundled)" not "implemented 7 PRs then reviewed then merged".
+- Cross-block synthesis: if multiple source blocks cover the same topic (same PR, same feature, same bug), MERGE them into a single group of bullets. Do not repeat the same fact from different blocks \u2014 keep it once under the most relevant source header.
+
+SIZE TARGET: 50-150 tokens per source block (excluding the header). If you can't fit it in 150 tokens, you're keeping too much process. If a block has nothing worth keeping (pure noise), output just the header followed by "[no actionable content]."`;
+var TIER3_CONDENSE_RULES2 = `TIER 3 COMPRESSION \u2014 ULTRA-CONDENSATION
+
+You are compressing distilled summaries (Tier 2) into ultra-condensed facts (Tier 3). The distilled summaries already contain only decisions and outcomes. Your job is to reduce them to bare factual references.
+
+PRIORITY \u2014 when a source block has more facts than the size target allows, keep in this order:
+1. Shipped outcomes (versions released, PRs merged) \u2014 these are permanent record.
+2. Open work (PRs/issues still pending) \u2014 these may need follow-up.
+3. Key decisions with architectural impact ("chose X over Y because Z").
+4. Critical constraints ("must support Node 22").
+Drop everything else. Tier 3 is a lookup index, not a knowledge base.
+
+FORMAT:
+- Start with a source header line:
+  \`Source: bN+bM+... (XK\u2192YK tok, Zx). [original topic]\`
+- Output 1-3 facts per source block. Each fact is a single line: subject + outcome.
+- No explanations, no rationale, no process \u2014 just the fact.
+- Format: "[PR/Issue/Version] \u2014 [outcome in \u22648 words]"
+- Merge related facts from different source blocks if they concern the same topic.
+
+EXAMPLES:
+- "v1.13.0 shipped \u2014 quality gate + GC fix (7 PRs)"
+- "PR #196 merged \u2014 preserve-first-user (supersedes #169)"
+- "Bug 1214 fixed \u2014 compress consumed all user messages"
+- "Chose compress-as-anchor \u2014 prefix cache benefit over synthetic injection"
+- "Constraint: AGENTS.md forbids as any \u2014 never suppress types"
+
+DROP:
+- Multi-sentence context. If a fact needs >1 sentence, it's too detailed for Tier 3.
+- Lessons learned ("tried X, failed because Y") \u2014 drop UNLESS the failure is likely to recur and the block is <30 days old.
+- Design rationale details \u2014 keep the decision, drop the "because" unless it's a critical constraint.
+- 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 defaultPrompts2 = Object.freeze({
+  compressPhilosophy: COMPRESS_PHILOSOPHY2,
+  howToCompressRules: HOW_TO_COMPRESS_RULES2,
+  tier2DistillRules: TIER2_DISTILL_RULES2,
+  tier3CondenseRules: TIER3_CONDENSE_RULES2
+});
+function formatK2(n) {
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+  return `${n}`;
+}
+function formatRanges2(compressible, protectedRanges) {
+  if (compressible.length === 0 && protectedRanges.length === 0) {
+    return "[No specific ranges detected \u2014 compress any consumed content.]";
+  }
+  const refNum2 = (ref) => {
+    const m = ref.match(/\d+/);
+    return m ? parseInt(m[0], 10) : 0;
+  };
+  const entries = [];
+  for (const r of compressible) {
+    entries.push({
+      startRef: r.startRef,
+      endRef: r.endRef,
+      startNum: refNum2(r.startRef),
+      endNum: refNum2(r.endRef),
+      count: r.count,
+      tokens: r.tokens,
+      toolPct: r.toolPct,
+      textPct: r.textPct,
+      compressibleTokens: r.tokens,
+      compressibleCount: r.count,
+      protectedTokens: 0,
+      protectedCount: 0,
+      protectedTools: [],
+      dangerous: r.dangerous ?? false
+    });
+  }
+  for (const r of protectedRanges) {
+    entries.push({
+      startRef: r.startRef,
+      endRef: r.endRef,
+      startNum: refNum2(r.startRef),
+      endNum: refNum2(r.endRef),
+      count: r.count,
+      tokens: r.tokens,
+      toolPct: 0,
+      textPct: 0,
+      compressibleTokens: 0,
+      compressibleCount: 0,
+      protectedTokens: r.tokens,
+      protectedCount: r.count,
+      protectedTools: [...r.tools],
+      dangerous: false
+    });
+  }
+  entries.sort((a, b) => a.startNum - b.startNum);
+  const merged = [];
+  for (const e of entries) {
+    const last = merged[merged.length - 1];
+    if (last && e.startNum <= last.endNum + 1) {
+      last.endRef = e.endRef;
+      last.endNum = Math.max(last.endNum, e.endNum);
+      last.count += e.count;
+      last.tokens += e.tokens;
+      last.compressibleTokens += e.compressibleTokens;
+      last.compressibleCount += e.compressibleCount;
+      last.protectedTokens += e.protectedTokens;
+      last.protectedCount += e.protectedCount;
+      if (e.dangerous) last.dangerous = true;
+      for (const t of e.protectedTools) {
+        if (!last.protectedTools.includes(t)) last.protectedTools.push(t);
+      }
+    } else {
+      merged.push({ ...e });
+    }
+  }
+  const lines = merged.map((e) => {
+    const suffix = e.dangerous && e.compressibleTokens > 0 ? "  \u26A0\uFE0F NOT recommended unless you are certain." : "";
+    if (e.protectedTokens > 0 && e.compressibleTokens === 0) {
+      return `  ${e.startRef}\u2013${e.endRef}  ${e.count} msgs  ${formatK2(e.tokens)} [PROTECTED: ${e.protectedTools.join(", ")} \u2014 not compressible]${suffix}`;
+    }
+    if (e.protectedTokens > 0 && e.compressibleTokens > 0) {
+      return `  ${e.startRef}\u2013${e.endRef}  ${e.count} msgs  ${formatK2(e.tokens)} [${formatK2(e.compressibleTokens)} compressible | ${formatK2(e.protectedTokens)} protected: ${e.protectedTools.join(", ")}]${suffix}`;
+    }
+    return `  ${e.startRef}\u2013${e.endRef}  ${e.count} msgs  ${formatK2(e.tokens)} [tool ${e.toolPct}% | text ${e.textPct}%]${suffix}`;
+  });
+  return `Compressible ranges (${merged.length}, oldest first):
+${lines.join("\n")}`;
+}
+var substringAlgorithm2 = {
+  name: "substring",
+  description: "Exact substring counting (original baseline). Predictable, no normalization.",
+  score(docs, query) {
+    const terms = query.toLowerCase().trim().split(/\s+/).filter((t) => t.length > 0);
+    if (terms.length === 0) return docs.map((d) => ({ ref: d.ref, score: 0 }));
+    return docs.map((d) => {
+      const haystack = d.text.toLowerCase();
+      let score = 0;
+      for (const term of terms) score += countOccurrences22(haystack, term);
+      return { ref: d.ref, score };
+    });
+  }
+};
+function countOccurrences22(haystack, needle) {
+  if (!needle) return 0;
+  return haystack.split(needle).length - 1;
+}
+function stem2(word) {
+  let w = word;
+  if (w.length <= 3) return w;
+  if (w.endsWith("ies")) w = w.slice(0, -3) + "y";
+  else if (w.endsWith("ses") || w.endsWith("xes") || w.endsWith("zes")) w = w.slice(0, -2);
+  else if (w.endsWith("ches") || w.endsWith("shes")) w = w.slice(0, -2);
+  else if (w.endsWith("s") && !w.endsWith("ss")) w = w.slice(0, -1);
+  if (w.endsWith("ing") && w.length > 5) w = w.slice(0, -3);
+  if (w.endsWith("ed") && w.length > 4) w = w.slice(0, -2);
+  if (w.endsWith("ation") && w.length > 6) w = w.slice(0, -3);
+  else if (w.endsWith("tion") && w.length > 5) w = w.slice(0, -4) + "t";
+  else if (w.endsWith("ion") && w.length > 4) w = w.slice(0, -3);
+  if (w.endsWith("ment") && w.length > 6) w = w.slice(0, -4);
+  if (w.endsWith("ness") && w.length > 6) w = w.slice(0, -4);
+  if (w.endsWith("ly") && w.length > 4) w = w.slice(0, -2);
+  return w;
+}
+var CJK2 = /[\u3400-\u9fff\uf900-\ufaff\u3040-\u30ff\uac00-\ud7af]/;
+var CJK_RUN2 = new RegExp(`${CJK2.source}+`, "g");
+var LATIN_WORD2 = /[a-z][a-z0-9_]*[a-z0-9]|[a-z0-9]/g;
+function tokenize2(text, opts = {}) {
+  const lower = text.toLowerCase();
+  const tokens = [];
+  const latin = lower.match(LATIN_WORD2) ?? [];
+  for (let w of latin) {
+    if (w.length >= 2) {
+      if (opts.stem) w = stem2(w);
+      tokens.push(w);
+    }
+  }
+  const cjkRuns = lower.match(CJK_RUN2) ?? [];
+  for (const run of cjkRuns) {
+    if (run.length === 1) {
+      tokens.push(run);
+    } else {
+      for (let i = 0; i < run.length - 1; i++) tokens.push(run.slice(i, i + 2));
+      for (const ch of run) tokens.push(ch);
+    }
+  }
+  return tokens;
+}
+function charBigrams2(text) {
+  const grams = [];
+  for (let i = 0; i < text.length - 1; i++) {
+    const pair = text.slice(i, i + 2);
+    if (pair.trim().length === pair.length) grams.push(pair);
+  }
+  return grams;
+}
+function tfMap2(text, stem22) {
+  const m = /* @__PURE__ */ new Map();
+  for (const t of tokenize2(text, { stem: stem22 })) m.set(t, (m.get(t) ?? 0) + 1);
+  return m;
+}
+var bm25Algorithm2 = {
+  name: "bm25",
+  description: "BM25 with stemming + CJK bigram tokenization. IR-standard relevance ranking.",
+  score(docs, query) {
+    const N = docs.length;
+    const k1 = 1.2;
+    const b = 0.75;
+    const parsed = docs.map((d) => {
+      const text = d.text;
+      const tf = tfMap2(text, true);
+      let len = 0;
+      for (const v of tf.values()) len += v;
+      return { id: d.ref, tf, len };
+    });
+    const avgdl = parsed.reduce((s, d) => s + d.len, 0) / (N || 1);
+    const qTerms = tokenize2(query, { stem: true });
+    if (qTerms.length === 0) return docs.map((d) => ({ ref: d.ref, score: 0 }));
+    const idf = /* @__PURE__ */ new Map();
+    for (const t of new Set(qTerms)) {
+      let df = 0;
+      for (const d of parsed) if (d.tf.has(t)) df++;
+      idf.set(t, Math.log(1 + (N - df + 0.5) / (df + 0.5)));
+    }
+    return parsed.map((d) => {
+      let score = 0;
+      for (const t of qTerms) {
+        const f = d.tf.get(t) ?? 0;
+        if (f === 0) continue;
+        const idfT = idf.get(t) ?? 0;
+        score += idfT * (f * (k1 + 1)) / (f + k1 * (1 - b + b * d.len / (avgdl || 1)));
+      }
+      return { ref: d.id, score };
+    });
+  }
+};
+var fuzzyAlgorithm2 = {
+  name: "fuzzy",
+  description: "Character bigram overlap. Typo-tolerant, script-agnostic, high recall.",
+  score(docs, query) {
+    const qTokens = query.toLowerCase().split(/[\s,]+/).filter((t) => t.length >= 4);
+    if (qTokens.length === 0) return docs.map((d) => ({ ref: d.ref, score: 0 }));
+    const qGrams = /* @__PURE__ */ new Set();
+    for (const t of qTokens) for (const g of charBigrams2(t)) qGrams.add(g);
+    if (qGrams.size === 0) return docs.map((d) => ({ ref: d.ref, score: 0 }));
+    return docs.map((d) => {
+      const haystack = d.text.toLowerCase();
+      const docGrams = new Set(charBigrams2(haystack));
+      let hits = 0;
+      for (const g of qGrams) if (docGrams.has(g)) hits++;
+      return { ref: d.ref, score: hits / qGrams.size };
+    });
+  }
+};
+var W_BM252 = 0.7;
+var W_FUZZY2 = 0.3;
+var hybridAlgorithm2 = {
+  name: "hybrid",
+  description: "Weighted BM25(stem) + fuzzy n-gram. Default \u2014 best precision + recall.",
+  score(docs, query) {
+    const bm = bm25Algorithm2.score(docs, query);
+    const fz = fuzzyAlgorithm2.score(docs, query);
+    const maxBm = Math.max(...bm.map((r) => r.score), 1e-9);
+    const maxFz = Math.max(...fz.map((r) => r.score), 1e-9);
+    const bmMap = new Map(bm.map((r) => [r.ref, r.score / maxBm]));
+    const fzMap = new Map(fz.map((r) => [r.ref, r.score / maxFz]));
+    return docs.map((d) => ({
+      ref: d.ref,
+      score: W_BM252 * (bmMap.get(d.ref) ?? 0) + W_FUZZY2 * (fzMap.get(d.ref) ?? 0)
+    }));
+  }
+};
+var registry22 = /* @__PURE__ */ new Map();
+function registerSearchAlgorithm2(algo) {
+  registry22.set(algo.name, algo);
+}
+registerSearchAlgorithm2(substringAlgorithm2);
+registerSearchAlgorithm2(bm25Algorithm2);
+registerSearchAlgorithm2(fuzzyAlgorithm2);
+registerSearchAlgorithm2(hybridAlgorithm2);
+
 // node_modules/billion-context-kit/dist/index.js
 var VIABLE_RANGE_MIN_TOKENS = 200;
 function viableRanges(ranges) {
@@ -3779,14 +4314,14 @@ function buildStatusPanel(input) {
   const protectedRanges = nudge?.protectedRanges ?? [];
   if (ranges.length > 0 || protectedRanges.length > 0) {
     lines.push("");
-    lines.push(formatRanges(ranges, protectedRanges));
+    lines.push(formatRanges2(ranges, protectedRanges));
   }
   if (activeBlocksList.length > 0) {
     lines.push("");
     lines.push(`Blocks: ${activeBlocksList.length} active / ${totalBlocksList.length} total (${fmt2(state.stats.tokensCompressed)} tokens compressed)`);
     for (const b of activeBlocksList) {
       const topic = b.topic ? `: ${b.topic}` : `: ${topicFallback(b.summary || "")}`;
-      const summaryTok = defaultCountTokens(b.summary || "");
+      const summaryTok = defaultCountTokens2(b.summary || "");
       const origTok = b.compressedTokens > 0 ? b.compressedTokens : summaryTok;
       lines.push(`  [${b.blockId}] T${b.tier} ${fmt2(origTok)}\u2192${fmt2(summaryTok)}${topic}`);
     }
@@ -3814,6 +4349,7 @@ function makeStatusTool(runtime) {
   return {
     name: "acp_status",
     label: "ACP Status",
+    loadMode: "essential",
     description: "Context status: overview, compressed blocks, or uncompressed ranges/messages. No args = overview + totals + compressible ranges. scope:'uncompressed' + view:'messages' for per-message listing. scope:'compressed' for block drilldown.",
     parameters: StatusParams,
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
@@ -3956,7 +4492,7 @@ async function statusReport(runtime, ctx) {
   const coveredIds = collectCoveredMessageIds(state);
   const sentTokens = estimateTokens(coreMessages, coveredIds) + systemPromptTokens;
   const turn = runtime.core.processTurn({ messages: coreMessages, state, config, tokenCount: sentTokens });
-  const versionStr = "0.1.7" ? `billion-context-omp@${"0.1.7"}` : void 0;
+  const versionStr = "0.1.9" ? `billion-context-omp@${"0.1.9"}` : void 0;
   return buildStatusPanel({
     version: versionStr,
     tokenCount: sessionTokens,
@@ -4062,7 +4598,7 @@ async function summarizeMessages(ctx, messages, prompts, configuredModel, opts)
 User instructions for this compaction: ${custom}`;
     const userText = `ENTIRE conversation to compress (${slice.length} messages, ~${tokens} tokens). Compress it:
 
-` + formatSlice(slice, createInitialState());
+` + formatSlice(slice, opts?.messageRefs ? { ...createInitialState(), messageRefs: opts.messageRefs } : createInitialState());
     const response = await run(
       model,
       { systemPrompt: [instructions], messages: [{ role: "user", content: [{ type: "text", text: userText }], timestamp: Date.now() }] },
@@ -4108,7 +4644,7 @@ TOOLS
 
 You have four context-management tools:
 
-- compress \u2014 Replace a contiguous range of older conversation with a single detailed summary you write. Use when content is genuinely consumed (no longer needed for the current task step). Single range: compress({ content: [{ topic: "Session Opener", startId: "m00150", endId: "m00220", summary: "..." }] }) \u2014 topic is recommended but optional. Batch (multiple unrelated ranges, each with its own topic): compress({ content: [{ topic: "Auth", startId: "m00150", endId: "m00220", summary: "..." }, { topic: "Deploy", startId: "m00300", endId: "m00350", summary: "..." }] }). The JSON written to xd://compress must be strict \u2014 escape every double quote inside summaries.
+- compress \u2014 Replace a contiguous range of older conversation with a single detailed summary you write. Use when content is genuinely consumed (no longer needed for the current task step). Single range: compress({ content: [{ topic: "Session Opener", startId: "m00150", endId: "m00220", summary: "..." }] }) \u2014 topic is recommended but optional. Batch (multiple unrelated ranges, each with its own topic): compress({ content: [{ topic: "Auth", startId: "m00150", endId: "m00220", summary: "..." }, { topic: "Deploy", startId: "m00300", endId: "m00350", summary: "..." }] }). Call it as a normal tool \u2014 summaries are plain string arguments.
 - decompress \u2014 Restore a previously compressed block's content. The block stays compressed \u2014 context and cache prefix are not disrupted. By DEFAULT content is written to an auto-generated file (avoids context bloat); use the read tool to view it. Pass inline:true to return content in the tool result instead (appends to context). full:true recurses to original messages. Example: decompress({ blockId: "b5" }) or decompress({ blockId: "b5", full: true }) or decompress({ blockId: "b5", inline: true }).
 - search_context \u2014 Search compressed block summaries (and optionally visible messages) by keyword. Use BEFORE decompressing to find the right block. Example: search_context({ query: "auth token refresh" }).
 - acp_status \u2014 Context status with compressible ranges. No args = overview + totals. scope:"uncompressed" for range view; add view:"messages" for per-message listing. scope:"compressed" for block details.
@@ -4130,6 +4666,8 @@ WHEN NOT TO COMPRESS
 - Content the current task step is actively reading or reasoning about.
 - Important user messages \u2014 preserve their exact intent, constraints, and acceptance criteria. If a message in the range must stay verbatim, exclude it from the compress range instead of compressing it.
 - Protected tool outputs \u2014 hard-excluded from compression ranges, survive intact in visible context.
+- Nothing left worth compressing \u2014 if no compressible range can meet the minimum size, do NOT call compress at all. Compression is maintenance, never the task goal; when there is nothing to compress, do the task.
+- A rejected compress call \u2014 never retry a rejected range unchanged. Re-check acp_status first; after 3 rejections, stop compressing and continue the task.
 
 ${prompts.howToCompressRules}
 
@@ -4276,7 +4814,7 @@ var PACKAGE_NAME = "billion-context-omp";
 var REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
 var SEMVER_RE = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z-.]+)?$/;
 var CHECK_INTERVAL_MS = 3 * 60 * 1e3;
-var THROTTLE_FILE = join4(homeDir(), CONFIG_DIR_NAME3, "agent", ".billion-context-omp-update-check");
+var throttleFile = () => join4(homeDir(), CONFIG_DIR_NAME3, ".billion-context-omp-update-check");
 var updateInFlight = false;
 function parseVersion(v) {
   return v.replace(/^v/, "").split(".").map((n) => parseInt(n, 10) || 0);
@@ -4292,7 +4830,7 @@ function isNewer(latest, current) {
 }
 async function readLastCheck() {
   try {
-    const data = await readFile(THROTTLE_FILE, "utf-8");
+    const data = await readFile(throttleFile(), "utf-8");
     return parseInt(data.trim(), 10) || 0;
   } catch {
     return 0;
@@ -4300,8 +4838,8 @@ async function readLastCheck() {
 }
 async function writeLastCheck(timestamp) {
   try {
-    await mkdir2(dirname3(THROTTLE_FILE), { recursive: true });
-    await writeFile2(THROTTLE_FILE, String(timestamp), "utf-8");
+    await mkdir2(dirname3(throttleFile()), { recursive: true });
+    await writeFile2(throttleFile(), String(timestamp), "utf-8");
   } catch {
   }
 }
@@ -4383,12 +4921,12 @@ async function checkForUpdate(autoUpdate, notify) {
     const now = Date.now();
     const lastCheck = await readLastCheck();
     if (now - lastCheck < CHECK_INTERVAL_MS) return;
-    await writeLastCheck(now);
     const runtimeVersion = await getRuntimeVersion();
     const res = await fetch(REGISTRY_URL, {
       signal: AbortSignal.timeout(5e3),
       headers: { Accept: "application/json" }
     });
+    await writeLastCheck(now);
     if (!res.ok) {
       logWarn("update", { event: "check-http", status: res.status });
       return;
@@ -4396,7 +4934,7 @@ async function checkForUpdate(autoUpdate, notify) {
     const data = await res.json();
     const latest = data.version;
     if (!latest) return;
-    const current = runtimeVersion ?? "0.1.7";
+    const current = runtimeVersion ?? "0.1.9";
     const hasUpdate = isNewer(latest, current);
     debug.event("update-check", {
       current,
@@ -4431,10 +4969,27 @@ async function getRuntimeVersion() {
 }
 
 // src/dump.ts
-import { mkdirSync as mkdirSync2, writeFileSync, readdirSync } from "fs";
+import { mkdirSync as mkdirSync2, writeFileSync, readdirSync, unlinkSync } from "fs";
 import * as path2 from "path";
 import { CONFIG_DIR_NAME as CONFIG_DIR_NAME4 } from "@oh-my-pi/pi-utils";
 var counters = {};
+var MAX_FILES_PER_PREFIX = 200;
+function pruneDumps(dir, prefixTest, seqOf) {
+  try {
+    const files = readdirSync(dir).filter(prefixTest).map((f) => ({ f, n: seqOf(f) })).filter((x) => !Number.isNaN(x.n));
+    if (files.length <= MAX_FILES_PER_PREFIX) return;
+    files.sort((a, b) => a.n - b.n);
+    const excess = files.slice(0, files.length - MAX_FILES_PER_PREFIX);
+    for (const { f } of excess) {
+      try {
+        unlinkSync(path2.join(dir, f));
+      } catch {
+      }
+    }
+    debug.event("dump-pruned", { dir, removed: excess.length });
+  } catch {
+  }
+}
 function dumpDir() {
   return path2.join(homeDir(), CONFIG_DIR_NAME4, "acp-omp-dumps");
 }
@@ -4469,6 +5024,7 @@ function dumpContextMessages(messages, meta) {
       })
     );
     debug.event("context-out-dump", { path: fullPath, msgs: messages.length });
+    pruneDumps(dir, (f) => /^\d{4}\.json$/.test(f), (f) => parseInt(f, 10));
     return fullPath;
   } catch (e) {
     debug.event("context-out-dump-error", { error: e instanceof Error ? e.message : String(e) });
@@ -4552,6 +5108,7 @@ function dumpProviderRequest(payload, meta) {
       })
     );
     debug.event("provider-request-dump", { path: fullPath, ...summary });
+    pruneDumps(dir, (f) => /^req_\d+\.json$/.test(f), (f) => parseInt(f.slice(4, -5), 10));
     return fullPath;
   } catch (e) {
     debug.event("provider-request-dump-error", { error: e instanceof Error ? e.message : String(e) });
@@ -4568,11 +5125,12 @@ async function loadUserConfig(cwd) {
   const merged = {};
   for (const base of [join7(home, CONFIG_DIR_NAME5), join7(cwd, CONFIG_DIR_NAME5)]) {
     const file = join7(base, "acp-omp.json");
+    const allowPrompts = base.startsWith(home);
     try {
       const raw = await fs.readFile(file, "utf8");
       const parsed = JSON.parse(raw);
       if (parsed && typeof parsed === "object") {
-        Object.assign(merged, pickKnown(parsed));
+        Object.assign(merged, pickKnown(parsed, allowPrompts));
         debug.event("config-loaded", { file });
       }
     } catch (e) {
@@ -4600,11 +5158,15 @@ var KNOWN = /* @__PURE__ */ new Set([
   "prompts",
   "acknowledgePromptsRisk"
 ]);
-function pickKnown(parsed) {
+function pickKnown(parsed, allowPrompts) {
   const out = {};
   for (const [k, v] of Object.entries(parsed)) {
     if (KNOWN.has(k)) out[k] = v;
   }
+  if (!allowPrompts) {
+    delete out.prompts;
+    delete out.acknowledgePromptsRisk;
+  }
   return out;
 }
 function applyUserConfig(adapter, user) {
@@ -4649,11 +5211,13 @@ function wireCompactionDisable(pi, runtime) {
       const prep = event.preparation;
       const toSummarize = [...prep.messagesToSummarize ?? [], ...prep.turnPrefixMessages ?? []];
       if (toSummarize.length === 0) return void 0;
+      const slot = await runtime.stateFor(ctx);
       ctx.ui?.notify?.(`ACP: compacting ${toSummarize.length} messages\u2026`, "info");
       const result = await summarizeMessages(ctx, toSummarize, runtime.prompts, runtime.adapter.compress?.compressModel, {
         previousSummary: prep.previousSummary,
         customInstructions: event.customInstructions,
-        signal: event.signal
+        signal: event.signal,
+        messageRefs: slot.state.messageRefs
       });
       if (!result) {
         ctx.ui?.notify?.("ACP: compression fell back to Pi native compaction", "warning");
@@ -4684,7 +5248,7 @@ function wireCompactionDisable(pi, runtime) {
 function wireSessionLifecycle(pi, runtime) {
   pi.on("session_start", async (_event, ctx) => {
     const sid = ctx.sessionManager.getSessionId();
-    logInfo("session", { event: "start", sid, cwd: ctx.cwd, debug: runtime.adapter.debug ?? null, version: true ? "0.1.7" : null });
+    logInfo("session", { event: "start", sid, cwd: ctx.cwd, debug: runtime.adapter.debug ?? null, version: true ? "0.1.9" : null });
     try {
       const user = await loadUserConfig(ctx.cwd);
       runtime.setAdapter(applyUserConfig(runtime.adapter, user));
@@ -4723,6 +5287,9 @@ function wireContextTransform(pi, runtime) {
       }
       debug.event("context-in-raw", { sid, msgs: input.length });
       const { state, coreMessages, originalById, streamLen } = runtime.foldStream(ctx, input);
+      const preTurnNudgeBaseline = state.nudge.lastPerMessageNudgeTokens;
+      const preTurnNudgeShownTokens = state.nudge.lastNudgeShownTokens;
+      const preTurnNudgeShownByTier = state.nudge.lastShownByTier;
       const config = runtime.configFor(ctx);
       const coveredIds = collectCoveredMessageIds(state);
       const systemPromptTokens = estimateTextTokens2(getSystemPromptText(ctx) ?? "");
@@ -4778,29 +5345,49 @@ function wireContextTransform(pi, runtime) {
         rebuiltMsgs: rebuilt.length
       });
       const debugOn2 = debug.enabled;
+      let nudgeInjected = false;
       if (turn.nudge?.shouldInject) {
-        const emergency = turn.nudge.breakdown?.emergencyOverride === 1;
-        {
-          turn.nudge.compressibleRanges = viableRanges(turn.nudge.compressibleRanges);
-          const rendered = renderNudgeText(turn.nudge, runtime.prompts);
-          const top = [...turn.nudge.compressibleRanges].sort((a, b) => b.tokens - a.tokens)[0];
-          const example = top ? `
+        const lastUser = [...input].reverse().find((m) => m.role === "user");
+        const tailText = lastUser ? JSON.stringify(lastUser.content ?? "") : "";
+        const isFeedbackView = tailText.includes("efficiency nudge to compress early") || tailText.includes("Context limit reached");
+        if (isFeedbackView) {
+          debug.event("nudge-feedback-skip", { sid: ctx.sessionManager.getSessionId(), msgs: input.length });
+        } else {
+          const emergency = turn.nudge.breakdown?.emergencyOverride === 1;
+          const epochReset = turn.state.nudge.lastPerMessageNudgeTokens !== preTurnNudgeBaseline;
+          const prevShown = epochReset ? 0 : preTurnNudgeShownTokens;
+          const cadenceFloor = turn.nudge.breakdown?.growthFloor ?? 0;
+          const suppressed = !emergency && prevShown > 0 && tokenCount - prevShown < cadenceFloor;
+          if (suppressed) {
+            turn.state.nudge.lastNudgeShownTokens = prevShown;
+            turn.state.nudge.lastShownByTier = preTurnNudgeShownByTier;
+            logInfo("nudge", { sid, event: "cadence-suppressed", growth: tokenCount - prevShown, floor: cadenceFloor, pct: Math.round(turn.nudge.contextUsage * 100), reason: turn.nudge.reason });
+            debug.event("nudge-suppressed", { sid, growth: tokenCount - prevShown, floor: cadenceFloor, pct: Math.round(turn.nudge.contextUsage * 100), reason: turn.nudge.reason });
+          } else {
+            nudgeInjected = true;
+            {
+              turn.nudge.compressibleRanges = viableRanges(turn.nudge.compressibleRanges);
+              const rendered = renderNudgeText(turn.nudge, runtime.prompts);
+              const top = [...turn.nudge.compressibleRanges].sort((a, b) => b.tokens - a.tokens)[0];
+              const example = top ? `
 
 Example: compress({ content: [{ startId: "${top.startRef}", endId: "${top.endRef}", summary: "..." }] })` : "";
-          rebuilt.push(nudgeMessage(turn.nudge, turn.state.blocks.filter((b) => b.active), runtime.prompts, example));
-          if (emergency) {
-            logWarn("nudge", { sid: ctx.sessionManager.getSessionId(), event: "emergency-inject", pct: Math.round(turn.nudge.contextUsage * 100), voice: rendered.voice, compressible: turn.nudge.compressibleRanges.length });
-          }
-          if (debugOn2 && ctx.hasUI) {
-            ctx.ui.notify(`[ACP nudge \u2192 context]${emergency ? " [EMERGENCY]" : ""}
+              rebuilt.push(nudgeMessage(turn.nudge, turn.state.blocks.filter((b) => b.active), runtime.prompts, example));
+              if (emergency) {
+                logWarn("nudge", { sid: ctx.sessionManager.getSessionId(), event: "emergency-inject", pct: Math.round(turn.nudge.contextUsage * 100), voice: rendered.voice, compressible: turn.nudge.compressibleRanges.length });
+              }
+              if (debugOn2 && ctx.hasUI) {
+                ctx.ui.notify(`[ACP nudge \u2192 context]${emergency ? " [EMERGENCY]" : ""}
 ${rendered.text}${example}`);
+              }
+              debug.event("nudge-injected", { sid: ctx.sessionManager.getSessionId(), voice: rendered.voice, channels: ["context", debugOn2 ? "terminal" : null].filter(Boolean), emergency, text: rendered.text + example });
+            }
           }
-          debug.event("nudge-injected", { sid: ctx.sessionManager.getSessionId(), voice: rendered.voice, channels: ["context", debugOn2 ? "terminal" : null].filter(Boolean), emergency, text: rendered.text + example });
         }
       }
       dumpContextMessages(rebuilt, {
         sid,
-        injected: turn.nudge?.shouldInject ?? false,
+        injected: nudgeInjected,
         emergency: turn.nudge?.breakdown?.emergencyOverride === 1
       });
       await checkForUpdate(runtime.adapter.autoUpdate ?? true, (msg) => {