billion-context-pi 0.1.36 → 0.1.38

package/dist/index.js

@@ -132,9 +132,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)
+      )
     )
   );
 }
@@ -211,6 +213,24 @@ function stripOrphanedToolCalls(messages) {
     (m) => m.contentType !== "tool-call" || !m.toolCallId || m.toolName === "compress" || knownResultIds.has(m.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 j = i;
+    while (j + 1 < messages.length && messages[j + 1].contentType === "reasoning") {
+      j++;
+    }
+    const companion = messages[j + 1];
+    const hasCompanion = companion !== void 0 && companion.role === "assistant" && (companion.contentType === "text" || companion.contentType === "tool-call");
+    if (!hasCompanion) {
+      for (let k = i; k <= j; k++) drop.add(k);
+    }
+  }
+  if (drop.size === 0) return messages;
+  return messages.filter((_, i) => !drop.has(i));
+}
 function syncBlocks(messages, state) {
   const presentIds = new Set(messages.map((message) => message.id));
   const deactivated = [];
@@ -273,7 +293,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 },
@@ -343,6 +364,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);
@@ -355,13 +388,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];
   }
@@ -392,16 +420,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")}`;
@@ -778,6 +841,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 msg = messages[i];
+    if (!msg) continue;
+    if (msg.contentType === "reasoning") {
+      let j = i;
+      while (j + 1 < messages.length && messages[j + 1].contentType === "reasoning") {
+        j++;
+      }
+      const companion = messages[j + 1];
+      if (companion !== void 0 && companion.role === "assistant" && (companion.contentType === "text" || companion.contentType === "tool-call") && j + 1 > newEndIndex) {
+        newEndIndex = j + 1;
+      }
+    }
+    if (msg.role === "assistant" && (msg.contentType === "text" || msg.contentType === "tool-call")) {
+      let k = i - 1;
+      while (k >= 0 && messages[k].contentType === "reasoning") {
+        k--;
+      }
+      const runStart = k + 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;
@@ -924,6 +1019,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) {
@@ -932,6 +1065,9 @@ function runPipeline(nodes, initial, ctx) {
   }
   return io;
 }
+function rangeError(spec, message) {
+  return `range ${spec.startRef}..${spec.endRef}: ${message}`;
+}
 function createCore(ports = {}) {
   const countTokens = ports.countTokens ?? defaultCountTokens;
   function applyCompression(input) {
@@ -943,20 +1079,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((m) => m.id === id)
       ).filter((i) => i >= 0);
       rangeIndexSets.push({ spec, indices });
@@ -983,37 +1143,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 msg = input.messages.find((m) => m.id === id);
           totalRangeChars += msg?.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: []
           }
         };
@@ -1021,6 +1171,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,
@@ -1036,7 +1198,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;
@@ -1174,7 +1336,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 } };
@@ -1200,6 +1365,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;
@@ -1244,7 +1410,7 @@ function applySingleRange(input) {
     messages: input.messages,
     state: input.state
   });
-  const rangeMessageIds = applyToolPairAdjustment(
+  const rangeMessageIds = applyPairBoundaryAdjustments(
     resolved,
     input.messages
   );
@@ -1358,20 +1524,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 msg = messages[i];
     if (msg) ids.push(msg.id);
   }
@@ -1455,10 +1634,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);
@@ -1473,6 +1653,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;
@@ -1484,44 +1665,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);
@@ -1727,12 +1931,39 @@ 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 resolvePrompts(overrides, options = {}) {
+  const clean = {};
+  if (overrides) {
+    for (const [key, value] of Object.entries(overrides)) {
+      if (typeof value === "string") {
+        clean[key] = value;
+      }
+    }
+  }
+  const keys = Object.keys(clean);
+  if (keys.length > 0 && !options.acknowledgeRisk) {
+    throw new Error(
+      `resolvePrompts: overriding compression rules requires { acknowledgeRisk: true }. Overridden keys: ${keys.join(", ")}. These rules are quality-critical (tuned over months of production use); changing them can degrade summary quality and break retrieval (summaries may lose paths, signatures, decisions).`
+    );
+  }
+  return { ...defaultPrompts, ...clean };
+}
+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}`;
@@ -1840,43 +2071,45 @@ 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 ?? []);
+  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: [
-        EFFICIENCY_NOTE,
+        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: "..." }] })`,
         "",
-        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 || !!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.",
@@ -1888,11 +2121,11 @@ function renderNudgeText(decision) {
   return {
     voice: "gentle",
     text: [
-      EFFICIENCY_NOTE,
+      efficiencyNote(prompts),
       "",
       breakdownStr,
       "",
-      HOW_TO_COMPRESS_RULES,
+      prompts.howToCompressRules,
       "",
       rangesStr,
       "",
@@ -2231,9 +2464,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 = {
@@ -2980,6 +3213,99 @@ function mergeInitialState(parsed) {
   };
 }
 
+// src/sequence-match.ts
+function findUniqueLongestRun(candidates, live) {
+  if (candidates.length === 0 || live.length === 0) return void 0;
+  const ids = /* @__PURE__ */ new Map();
+  const intern = (key) => {
+    const existing = ids.get(key);
+    if (existing !== void 0) return existing;
+    const id = ids.size + 1;
+    ids.set(key, id);
+    return id;
+  };
+  const candidateIds = candidates.map(intern);
+  const liveIds = live.map(intern);
+  const separator = ids.size + 1;
+  const sequence = [...candidateIds, separator, ...liveIds];
+  const suffixArray = buildSuffixArray(sequence);
+  const lcp = buildLcp(sequence, suffixArray);
+  const candidateLength = candidates.length;
+  const liveOffset = candidateLength + 1;
+  const sourceOf = (suffix) => {
+    if (suffix < candidateLength) return 0;
+    if (suffix >= liveOffset) return 1;
+    return void 0;
+  };
+  let bestLength = 0;
+  for (let index = 1; index < suffixArray.length; index++) {
+    const leftSource = sourceOf(suffixArray[index - 1]);
+    const rightSource = sourceOf(suffixArray[index]);
+    if (leftSource === void 0 || rightSource === void 0 || leftSource === rightSource) continue;
+    bestLength = Math.max(bestLength, lcp[index]);
+  }
+  if (bestLength === 0) return void 0;
+  let pairCount = 0;
+  let uniqueCandidateStart = -1;
+  let uniqueLiveStart = -1;
+  for (let start = 0; start < suffixArray.length; ) {
+    let end = start;
+    while (end + 1 < suffixArray.length && lcp[end + 1] >= bestLength) end++;
+    if (end > start) {
+      const candidateStarts = [];
+      const liveStarts = [];
+      for (let index = start; index <= end; index++) {
+        const suffix = suffixArray[index];
+        const source = sourceOf(suffix);
+        if (source === 0) candidateStarts.push(suffix);
+        else if (source === 1) liveStarts.push(suffix - liveOffset);
+      }
+      const groupPairs = candidateStarts.length * liveStarts.length;
+      pairCount += groupPairs;
+      if (groupPairs === 1) {
+        uniqueCandidateStart = candidateStarts[0];
+        uniqueLiveStart = liveStarts[0];
+      }
+      if (pairCount > 1) return void 0;
+    }
+    start = end + 1;
+  }
+  return pairCount === 1 ? { candidateStart: uniqueCandidateStart, liveStart: uniqueLiveStart, length: bestLength } : void 0;
+}
+function buildSuffixArray(sequence) {
+  const suffixArray = sequence.map((_, index) => index);
+  let ranks = [...sequence];
+  for (let width = 1; width < sequence.length; width *= 2) {
+    suffixArray.sort((left, right) => ranks[left] - ranks[right] || (ranks[left + width] ?? -1) - (ranks[right + width] ?? -1));
+    const nextRanks = Array(sequence.length);
+    nextRanks[suffixArray[0]] = 0;
+    for (let index = 1; index < suffixArray.length; index++) {
+      const previous = suffixArray[index - 1];
+      const current = suffixArray[index];
+      const differs = ranks[previous] !== ranks[current] || (ranks[previous + width] ?? -1) !== (ranks[current + width] ?? -1);
+      nextRanks[current] = nextRanks[previous] + (differs ? 1 : 0);
+    }
+    ranks = nextRanks;
+    if (ranks[suffixArray.at(-1)] === sequence.length - 1) break;
+  }
+  return suffixArray;
+}
+function buildLcp(sequence, suffixArray) {
+  const positions = Array(sequence.length);
+  for (let index = 0; index < suffixArray.length; index++) positions[suffixArray[index]] = index;
+  const lcp = Array(sequence.length).fill(0);
+  let length = 0;
+  for (let start = 0; start < sequence.length; start++) {
+    const position = positions[start];
+    if (position === 0) continue;
+    const previous = suffixArray[position - 1];
+    while (start + length < sequence.length && previous + length < sequence.length && sequence[start + length] === sequence[previous + length]) length++;
+    lcp[position] = length;
+    if (length > 0) length--;
+  }
+  return lcp;
+}
+
 // src/runtime.ts
 function readContextEntries(sm) {
   const source = sm;
@@ -2993,15 +3319,17 @@ function isPiHost(sm) {
 }
 function mergeLiveEntries(entries, live, state, origins) {
   const persisted = entries.filter((e) => e.type === "message");
-  const matched = matchPersistedSuffix(persisted, live);
-  const prior = matchOrigins(origins, live);
+  const liveIdentities = live.map(messageIdentity);
+  const persistedIdentities = persisted.map((entry) => messageIdentity(entry.message));
+  const persistedRange = findUniqueLongestRun(persistedIdentities, normalizePersistedMatchKeys(persisted, persistedIdentities, live, liveIdentities));
+  const originRange = findUniqueLongestRun(origins.map((origin) => origin.identity), liveIdentities);
   const out = [];
   const nextOrigins = [];
   const usedIds = /* @__PURE__ */ new Set();
   for (let i = 0; i < live.length; i++) {
     const msg = live[i];
-    const entry = matched[i];
-    const origin = prior[i];
+    const entry = valueInRange(persisted, persistedRange, i);
+    const origin = valueInRange(origins, originRange, i);
     if (entry) {
       if (origin) migrateLiveRefs(state, origin.rawId, entry.id);
       else migrateTaggedRef(state, msg, entry.id);
@@ -3011,23 +3339,13 @@ function mergeLiveEntries(entries, live, state, origins) {
     const id = origin?.rawId ?? nextLiveId(state, usedIds, i);
     usedIds.add(id);
     out.push({ type: "message", id, parentId: null, timestamp: String(msg.timestamp ?? Date.now()), message: msg });
-    nextOrigins.push({ rawId: id, identity: messageIdentity(msg) });
+    nextOrigins.push({ rawId: id, identity: liveIdentities[i] });
   }
   origins.splice(0, origins.length, ...nextOrigins);
-  const unmatched = live.length - matched.length;
+  const unmatched = live.length - (persistedRange?.length ?? 0);
   if (unmatched > 0) logInfo("runtime", { event: "merge-live-entries", live: live.length, unmatched });
   return out;
 }
-function matchOrigins(origins, live) {
-  for (let start = 0; start < origins.length; start++) {
-    const count = origins.length - start;
-    if (count > live.length) continue;
-    if (origins.slice(start).every((origin, index) => origin.identity === messageIdentity(live[index]))) {
-      return [...origins.slice(start), ...Array(live.length - count)];
-    }
-  }
-  return Array(live.length);
-}
 function nextLiveId(state, used, index) {
   let id = `live-${index}`;
   let suffix = index;
@@ -3054,31 +3372,39 @@ function migrateLiveRefs(state, liveId, stableId) {
     delete state.messageRefs.byRaw[rawId];
   }
 }
-function matchPersistedSuffix(persisted, live) {
-  for (let start = 0; start < persisted.length; start++) {
-    const count = persisted.length - start;
-    if (count > live.length) continue;
-    const suffix = persisted.slice(start);
-    if (suffix.every((entry, index) => sameMessage(entry.message, live[index]))) return suffix;
-  }
-  return [];
+var NO_PERSISTED_MATCH = /* @__PURE__ */ Symbol("no-persisted-match");
+function normalizePersistedMatchKeys(persisted, persistedIdentities, live, liveIdentities) {
+  const persistedByStructure = /* @__PURE__ */ new Map();
+  for (let index = 0; index < persisted.length; index++) {
+    const key = toolResultStructureKey(persisted[index].message);
+    if (key === void 0) continue;
+    persistedByStructure.set(key, persistedByStructure.has(key) ? -1 : index);
+  }
+  return live.map((message, liveIndex) => {
+    const key = toolResultStructureKey(message);
+    const candidateIndex = key === void 0 ? void 0 : persistedByStructure.get(key);
+    if (candidateIndex === void 0) return liveIdentities[liveIndex];
+    if (candidateIndex < 0) return NO_PERSISTED_MATCH;
+    return sameToolResult(persisted[candidateIndex].message, message) ? persistedIdentities[candidateIndex] : liveIdentities[liveIndex];
+  });
 }
-function sameMessage(a, b) {
-  try {
-    if (messageIdentity(a) === messageIdentity(b)) return true;
-    const ra = a.role;
-    const rb = b.role;
-    if (ra !== rb || ra !== "toolResult") return false;
-    const ca = a.content;
-    const cb = b.content;
-    return sameNonTextBlocks(ca, cb) && matchesStoredText(extractText(ca), extractText(cb));
-  } catch (e) {
-    logWarn("runtime", { event: "message-compare-failed", error: e instanceof Error ? e.message : String(e) });
-    return a === b;
-  }
+function toolResultStructureKey(message) {
+  if (message.role !== "toolResult") return void 0;
+  return `${message.toolName}\0${message.toolCallId}`;
+}
+function valueInRange(values, range, liveIndex) {
+  if (!range || liveIndex < range.liveStart || liveIndex >= range.liveStart + range.length) return void 0;
+  return values[range.candidateStart + liveIndex - range.liveStart];
+}
+function sameToolResult(stored, visible) {
+  if (stored.role !== "toolResult" || visible.role !== "toolResult") return false;
+  return sameNonTextBlocks(stored.content, visible.content) && matchesStoredText(extractText(stored.content), extractText(visible.content));
 }
 function sameNonTextBlocks(a, b) {
-  const nonText = (blocks) => blocks.filter((block) => block.type !== "text");
+  const nonText = (blocks) => blocks.filter((block) => {
+    if (!block || typeof block !== "object" || !("type" in block)) return true;
+    return block.type !== "text";
+  });
   try {
     const na = Array.isArray(a) ? nonText(a) : [];
     const nb = Array.isArray(b) ? nonText(b) : [];
@@ -3106,6 +3432,7 @@ function createRuntime(adapter) {
   const store = new SessionStateStore();
   const locks = /* @__PURE__ */ new Map();
   let adapterRef = adapter;
+  let promptsRef = defaultPrompts;
   const nudgeShownTurns = /* @__PURE__ */ new Set();
   async function acquireLock(sid) {
     const prev = locks.get(sid) ?? Promise.resolve();
@@ -3154,6 +3481,10 @@ function createRuntime(adapter) {
     return adapterRef;
   }, setAdapter: (a) => {
     adapterRef = a;
+  }, get prompts() {
+    return promptsRef;
+  }, setPrompts: (p) => {
+    promptsRef = p;
   }, markNudgeShown: (k) => {
     nudgeShownTurns.add(k);
   }, nudgeShownFor: (k) => nudgeShownTurns.has(k), clearNudgeTracking: () => {
@@ -7581,6 +7912,23 @@ function lastUserMessageId(entries) {
   return void 0;
 }
 
+// src/compat.ts
+function normalizeSystemPrompt(input) {
+  if (input === void 0) return "";
+  if (Array.isArray(input)) return input.join("\n");
+  return input;
+}
+function formatSystemPromptForEvent(base, append) {
+  const normalized = normalizeSystemPrompt(base);
+  return `${normalized}
+
+${append}`;
+}
+function getSystemPromptText(ctx) {
+  const result = ctx.getSystemPrompt?.();
+  return normalizeSystemPrompt(result);
+}
+
 // src/compress-tool.ts
 function formatK2(n) {
   return n >= 1e3 ? `${(n / 1e3).toFixed(1)}K` : String(n);
@@ -7626,13 +7974,14 @@ async function handleCompress(args, runtime, ctx, toolCallId) {
   if (ranges.length === 0) return "No ranges provided.";
   const { state: initialState, coreMessages } = await runtime.stateFor(ctx);
   const config = runtime.configFor(ctx);
-  const estimatedTokens = estimateTokens(coreMessages, collectCoveredMessageIds(initialState));
-  const realUsage = ctx.getContextUsage?.();
+  const systemPromptText = getSystemPromptText(ctx);
+  const systemPromptTokens = systemPromptText ? defaultCountTokens(systemPromptText) : 0;
+  const sentTokens = estimateTokens(coreMessages, collectCoveredMessageIds(initialState)) + systemPromptTokens;
   const turn = runtime.core.processTurn({
     messages: coreMessages,
     state: initialState,
     config,
-    tokenCount: realUsage?.tokens && realUsage.tokens > 0 ? realUsage.tokens : estimatedTokens
+    tokenCount: sentTokens
   });
   const state = turn.state;
   const messages = turn.messages;
@@ -7768,6 +8117,18 @@ function findMessageContent(ref, ctx) {
   }
   return null;
 }
+function resolveBlockMessages(block, coreMessages, ctx) {
+  const neededBaseIds = new Set(block.effectiveMessageIds.map((id) => id.split("#")[0]));
+  const presentBaseIds = new Set(coreMessages.map((m) => m.id.split("#")[0]));
+  const missingBaseIds = [...neededBaseIds].filter((id) => !presentBaseIds.has(id));
+  if (missingBaseIds.length === 0) return coreMessages;
+  const extra = [];
+  for (const baseId of missingBaseIds) {
+    const entry = ctx.sessionManager.getEntry(baseId);
+    if (entry) extra.push(...entriesToCoreMessages([entry]));
+  }
+  return [...coreMessages, ...extra];
+}
 async function handleMessageRef(ref, ownerBlockId, args, ctx) {
   const found = findMessageContent(ref, ctx);
   if (!found || !found.text) {
@@ -7815,7 +8176,8 @@ async function handleDecompress(args, runtime, ctx) {
     return `Block ${blockId} not found. Active blocks: ${active || "(none)"}.`;
   }
   const full = args.full ?? false;
-  const { text, count } = collectBlockContent(state, block, coreMessages, { full });
+  const resolved = resolveBlockMessages(block, coreMessages, ctx);
+  const { text, count } = collectBlockContent(state, block, resolved, { full });
   if (count === 0) return `Block ${blockId} has no restorable message content.`;
   if (args.inline === true && !args.toFile) {
     debug.event("decompress", { blockId, full, count, mode: "inline" });
@@ -7973,105 +8335,624 @@ function formatSize(tokens) {
   return `${(tokens / 1e6).toFixed(1)}M`;
 }
 
-// src/delegate-tool.ts
-import {
-  spawn
-} from "child_process";
-import { createWriteStream } from "fs";
-import { mkdir as mkdir2, mkdtemp, writeFile as writeFile2, rm, appendFile } from "fs/promises";
-import { tmpdir as tmpdir2 } from "os";
-import { join as join4 } from "path";
-
-// src/footer-status.ts
-var FOOTER_STATUS_KEY = "billion-context-pi";
-var ui;
-var lastFooterText = "";
-function formatCompactTokens(count) {
-  if (count < 1e3) return count.toString();
-  if (count < 1e4) return `${(count / 1e3).toFixed(1)}k`;
-  if (count < 1e6) return `${Math.round(count / 1e3)}k`;
-  if (count < 1e7) return `${(count / 1e6).toFixed(1)}M`;
-  return `${Math.round(count / 1e6)}M`;
+// 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;
 }
-function initFooterStatus(ctx) {
-  ui = ctx.ui;
-  lastFooterText = void 0;
+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 updateFooterStatus() {
-  if (!ui) return;
-  const usage = getDelegateUsage();
-  let text;
-  if (usage && usage.totalTokens > 0) {
-    const costStr = usage.cost.total > 0 ? ` ($${usage.cost.total.toFixed(4)})` : "";
-    text = `sub-agents \u2191${formatCompactTokens(usage.input)} \u2193${formatCompactTokens(usage.output)}${costStr}`;
-  }
-  if ((text ?? "") === lastFooterText) return;
-  lastFooterText = text ?? "";
-  try {
-    ui.setStatus(FOOTER_STATUS_KEY, text);
-  } catch {
-  }
+function formatTokens3(tokens) {
+  if (tokens < 1e3) return String(tokens);
+  if (tokens < 1e4) return (tokens / 1e3).toFixed(1) + "K";
+  return Math.round(tokens / 1e3) + "K";
 }
-function disposeFooterStatus() {
-  if (ui) {
-    try {
-      ui.setStatus(FOOTER_STATUS_KEY, void 0);
-    } catch {
-    }
+function classifyType2(message) {
+  if (message.contentType === "tool-call" || message.contentType === "tool-result") {
+    return message.toolName || "tool";
   }
-  ui = void 0;
-  lastFooterText = "";
-}
-
-// src/fleet-widget.ts
-var DELEGATE_WIDGET_KEY = "billion-context-pi-delegates";
-var REFRESH_MS = 500;
-var MAX_TASK_LEN = 48;
-var ui2;
-var timer;
-var lastRenderKey = "";
-var runsSnapshot;
-function truncateTask(task) {
-  const oneLine = task.replace(/\n/g, " ").trim();
-  if (oneLine.length <= MAX_TASK_LEN) return oneLine;
-  return `${oneLine.slice(0, MAX_TASK_LEN - 1)}\u2026`;
+  return message.contentType;
 }
-function renderLines(runs2) {
-  if (runs2.length === 0) return void 0;
-  const now = Date.now();
-  const header = runs2.length === 1 ? `acp_delegate \xB7 1 running` : `acp_delegate \xB7 ${runs2.length} running`;
-  const rows = runs2.map((r) => {
-    const elapsed = Math.max(0, Math.round((now - r.startedAt) / 1e3));
-    return `  \u25CF ${r.agent} (${elapsed}s) \u2014 ${truncateTask(r.task)}`;
-  });
-  return [header, ...rows];
+function escapeRegex2(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function renderKeyFor(runs2) {
-  return runs2.map((r) => `${r.agent}:${Math.round((Date.now() - r.startedAt) / 1e3)}:${truncateTask(r.task)}`).join("|");
+var LT2 = "<";
+var GT2 = ">";
+var TAG_OPEN2 = LT2 + "acp ";
+var TAG_CLOSE2 = LT2 + "/acp" + GT2;
+function acpTag2(ref, tokens, type) {
+  return TAG_OPEN2 + 'tokens="' + formatTokens3(tokens) + '" type="' + type + '"' + GT2 + ref + TAG_CLOSE2;
 }
-function stopTimer() {
-  if (timer) {
-    clearInterval(timer);
-    timer = void 0;
+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 type = classifyType2(message);
+  const prefix = acpTag2(ref, tokens, type) + "\n";
+  if (!cleanText) return { ...message, text: prefix };
+  return { ...message, text: prefix + cleanText };
 }
-function clearWidget() {
-  if (!ui2) return;
-  try {
-    ui2.setWidget(DELEGATE_WIDGET_KEY, void 0);
-  } catch {
-  }
+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 refresh() {
-  if (!ui2) return;
-  const runs2 = runsSnapshot ? runsSnapshot() : [];
-  if (runs2.length === 0) {
-    if (lastRenderKey !== "") {
-      lastRenderKey = "";
-      clearWidget();
+function createRenderRefsNode2(strategy) {
+  return {
+    name: "render-refs",
+    run(io, ctx) {
+      return {
+        ...io,
+        messages: renderVisibleRefs2(io.messages, io.state, ctx.countTokens, strategy)
+      };
     }
-    updateFooterStatus();
-    stopTimer();
+  };
+}
+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 formatK3(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  ${formatK3(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  ${formatK3(e.tokens)} [${formatK3(e.compressibleTokens)} compressible | ${formatK3(e.protectedTokens)} protected: ${e.protectedTools.join(", ")}]${suffix}`;
+    }
+    return `  ${e.startRef}\u2013${e.endRef}  ${e.count} msgs  ${formatK3(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) {
+  return ranges.filter((r) => r.tokens >= VIABLE_RANGE_MIN_TOKENS);
+}
+function topicFallback(summary) {
+  const first = summary.split(/[.\n]/)[0] ?? "";
+  const t = first.trim().replace(/^["'`]+/, "").trim();
+  return t.length <= 30 ? t : `${t.slice(0, 30).trimEnd()}\u2026`;
+}
+function formatCompactTokens(count) {
+  if (count < 1e3) return count.toString();
+  if (count < 1e4) return `${(count / 1e3).toFixed(1)}k`;
+  if (count < 1e6) return `${Math.round(count / 1e3)}k`;
+  if (count < 1e7) return `${(count / 1e6).toFixed(1)}M`;
+  return `${Math.round(count / 1e6)}M`;
+}
+function bar(value, total, width = 20) {
+  if (total === 0) return "";
+  const filled = Math.max(0, Math.min(width, Math.round(value / total * width)));
+  return "\u2588".repeat(filled) + "\u2591".repeat(width - filled);
+}
+function buildStatusPanel(input) {
+  const { tokenCount, state, nudge, modelContextLimit } = input;
+  const fmt2 = input.fmtTokens ?? formatCompactTokens;
+  const bd = nudge?.contextBreakdown;
+  const limit = modelContextLimit;
+  const classified = bd ? bd.system + bd.tool + bd.summaries + bd.code + bd.text : 0;
+  const systemPromptTokens = input.systemPromptTokens;
+  const sentTotal = classified + systemPromptTokens;
+  const sessionOnly = input.unprunedTokens !== void 0 ? Math.max(0, input.unprunedTokens - sentTotal) : 0;
+  const displayTotal = tokenCount;
+  const displayPct = limit > 0 ? Math.round(displayTotal / limit * 100) : 0;
+  const sentPct = limit > 0 ? Math.round(sentTotal / limit * 100) : 0;
+  const activeBlocksList = state.blocks.filter((b) => b.active);
+  const totalBlocksList = state.blocks;
+  const lines = [];
+  lines.push("\u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E");
+  lines.push("\u2502           ACP Context Analysis              \u2502");
+  lines.push("\u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F");
+  if (input.version) lines.push(input.version);
+  lines.push("");
+  lines.push(`Context (session accounting, host footer scale): ${displayPct}% (${fmt2(displayTotal)} / ${fmt2(limit)}) \u2014 never shrinks; includes compressed originals`);
+  if (nudge && bd) {
+    const growth = bd.growth;
+    if (growth > 0 && displayTotal > 0) {
+      lines.push(`Growth: +${fmt2(growth)} since last nudge`);
+    }
+    lines.push("");
+    lines.push(`Sent to LLM (after compression, est.): ${fmt2(sentTotal)}${limit > 0 ? ` (${sentPct}% of limit)` : ""}`);
+    if (input.unprunedTokens !== void 0 && sessionOnly > 0) {
+      lines.push(`Session-only (compressed originals, est.): ${fmt2(sessionOnly)} \u2014 pruned from every request; the footer/nudge still count them`);
+    }
+    lines.push("");
+    lines.push("Token Breakdown (sent view):");
+    const categories = [
+      { label: "Tool", value: bd.tool },
+      { label: "SysPrompt", value: systemPromptTokens },
+      { label: "Text", value: bd.text },
+      { label: "Code", value: bd.code },
+      { label: "Summaries", value: bd.summaries }
+    ];
+    for (const cat of categories) {
+      if (cat.value <= 0) continue;
+      const pct2 = sentTotal > 0 ? Math.round(cat.value / sentTotal * 100) : 0;
+      const b = bar(cat.value, sentTotal);
+      lines.push(`  ${cat.label.padEnd(10)} ${b} ${String(pct2).padStart(3)}%  ${fmt2(cat.value)}`);
+    }
+  }
+  lines.push("");
+  if (nudge) {
+    if (nudge.shouldInject) {
+      const tierInfo = nudge.tier ? ` [T${nudge.tier} distillation]` : "";
+      lines.push(`Nudge: ACTIVE${tierInfo} \u2014 ${nudge.reason}`);
+    } else {
+      lines.push(`Nudge: idle \u2014 ${nudge.reason}`);
+    }
+  }
+  const ranges = viableRanges(nudge?.compressibleRanges ?? []);
+  const protectedRanges = nudge?.protectedRanges ?? [];
+  if (ranges.length > 0 || protectedRanges.length > 0) {
+    lines.push("");
+    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 = defaultCountTokens2(b.summary || "");
+      const origTok = b.compressedTokens > 0 ? b.compressedTokens : summaryTok;
+      lines.push(`  [${b.blockId}] T${b.tier} ${fmt2(origTok)}\u2192${fmt2(summaryTok)}${topic}`);
+    }
+  } else if (totalBlocksList.length > 0) {
+    lines.push("");
+    lines.push(`Blocks: 0 active / ${totalBlocksList.length} total (${fmt2(state.stats.tokensCompressed)} tokens compressed)`);
+  } else {
+    lines.push("");
+    lines.push("Blocks: none (nothing compressed yet)");
+  }
+  lines.push("");
+  lines.push("Tag visibility: tags injected to LLM only (deep copy), not persisted in session, not shown in terminal.");
+  return lines.join("\n");
+}
+
+// src/delegate-tool.ts
+import {
+  spawn
+} from "child_process";
+import { createWriteStream, existsSync as existsSync2 } from "fs";
+import { mkdir as mkdir2, mkdtemp, writeFile as writeFile2, rm, appendFile } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
+import { dirname as dirname3, join as join4, resolve as resolvePath } from "path";
+
+// src/footer-status.ts
+var FOOTER_STATUS_KEY = "billion-context-pi";
+var ui;
+var lastFooterText = "";
+function formatCompactTokens2(count) {
+  if (count < 1e3) return count.toString();
+  if (count < 1e4) return `${(count / 1e3).toFixed(1)}k`;
+  if (count < 1e6) return `${Math.round(count / 1e3)}k`;
+  if (count < 1e7) return `${(count / 1e6).toFixed(1)}M`;
+  return `${Math.round(count / 1e6)}M`;
+}
+function initFooterStatus(ctx) {
+  ui = ctx.ui;
+  lastFooterText = void 0;
+}
+function updateFooterStatus() {
+  if (!ui) return;
+  const usage = getDelegateUsage();
+  let text;
+  if (usage && usage.totalTokens > 0) {
+    const costStr = usage.cost.total > 0 ? ` ($${usage.cost.total.toFixed(4)})` : "";
+    text = `sub-agents \u2191${formatCompactTokens2(usage.input)} \u2193${formatCompactTokens2(usage.output)}${costStr}`;
+  }
+  if ((text ?? "") === lastFooterText) return;
+  lastFooterText = text ?? "";
+  try {
+    ui.setStatus(FOOTER_STATUS_KEY, text);
+  } catch {
+  }
+}
+function disposeFooterStatus() {
+  if (ui) {
+    try {
+      ui.setStatus(FOOTER_STATUS_KEY, void 0);
+    } catch {
+    }
+  }
+  ui = void 0;
+  lastFooterText = "";
+}
+
+// src/fleet-widget.ts
+var DELEGATE_WIDGET_KEY = "billion-context-pi-delegates";
+var REFRESH_MS = 500;
+var MAX_TASK_LEN = 48;
+var ui2;
+var timer;
+var lastRenderKey = "";
+var runsSnapshot;
+function truncateTask(task) {
+  const oneLine = task.replace(/\n/g, " ").trim();
+  if (oneLine.length <= MAX_TASK_LEN) return oneLine;
+  return `${oneLine.slice(0, MAX_TASK_LEN - 1)}\u2026`;
+}
+function renderLines(runs2) {
+  if (runs2.length === 0) return void 0;
+  const now = Date.now();
+  const header = runs2.length === 1 ? `acp_delegate \xB7 1 running` : `acp_delegate \xB7 ${runs2.length} running`;
+  const rows = runs2.map((r) => {
+    const elapsed = Math.max(0, Math.round((now - r.startedAt) / 1e3));
+    return `  \u25CF ${r.agent} (${elapsed}s) \u2014 ${truncateTask(r.task)}`;
+  });
+  return [header, ...rows];
+}
+function renderKeyFor(runs2) {
+  return runs2.map((r) => `${r.agent}:${Math.round((Date.now() - r.startedAt) / 1e3)}:${truncateTask(r.task)}`).join("|");
+}
+function stopTimer() {
+  if (timer) {
+    clearInterval(timer);
+    timer = void 0;
+  }
+}
+function clearWidget() {
+  if (!ui2) return;
+  try {
+    ui2.setWidget(DELEGATE_WIDGET_KEY, void 0);
+  } catch {
+  }
+}
+function refresh() {
+  if (!ui2) return;
+  const runs2 = runsSnapshot ? runsSnapshot() : [];
+  if (runs2.length === 0) {
+    if (lastRenderKey !== "") {
+      lastRenderKey = "";
+      clearWidget();
+    }
+    updateFooterStatus();
+    stopTimer();
     return;
   }
   const sorted = [...runs2].sort((a, b) => a.startedAt - b.startedAt);
@@ -8393,6 +9274,44 @@ function delegateSpawnOptions(cwd, env) {
     shell: false
   };
 }
+var PI_CLI_ENTRY_RE = /[\\/]pi-coding-agent[\\/]dist[\\/]cli\.js$/;
+var PI_PACKAGE_REL = join4("@earendil-works", "pi-coding-agent", "dist", "cli.js");
+function probeUpFromArgv(argv1) {
+  let dir = resolvePath(dirname3(argv1) || process.cwd());
+  for (; ; ) {
+    const candidate = join4(dir, "node_modules", PI_PACKAGE_REL);
+    if (existsSync2(candidate)) return candidate;
+    const parent = dirname3(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function piCliGlobalCandidates(env) {
+  const candidates = [];
+  if (process.platform === "win32") {
+    if (env.APPDATA) candidates.push(join4(env.APPDATA, "npm", "node_modules", PI_PACKAGE_REL));
+  } else {
+    const home = env.HOME ?? env.USERPROFILE;
+    if (home) candidates.push(join4(home, ".local", "lib", "node_modules", PI_PACKAGE_REL));
+    candidates.push(join4("/usr/local", "lib", "node_modules", PI_PACKAGE_REL));
+    candidates.push(join4("/usr", "lib", "node_modules", PI_PACKAGE_REL));
+  }
+  return candidates;
+}
+function resolvePiCliEntry(argv1, env = process.env, piHost = true) {
+  const explicit = env.PI_CLI_PATH;
+  if (explicit) return explicit;
+  if (argv1 && PI_CLI_ENTRY_RE.test(argv1)) return argv1;
+  if (piHost) {
+    const probed = probeUpFromArgv(argv1);
+    if (probed) return probed;
+    for (const candidate of piCliGlobalCandidates(env)) {
+      if (existsSync2(candidate)) return candidate;
+    }
+    logWarn("delegate", { event: "cli-entry-unresolved", argv1, fallback: "argv[1]" });
+  }
+  return argv1;
+}
 var ACP_TOOLS = ["compress", "decompress", "search_context", "acp_status"];
 var RESTRICTED_TOOLS = "read,bash,grep,find,ls";
 var AGENTS = {
@@ -8814,7 +9733,7 @@ async function runDelegate(pi, args, ctx, signal) {
   logInfo("delegate", { event: "spawn", agent: args.agent, runId, cwd, async: isAsync, useJsonStream, mode: ctx.mode, parentDepth });
   const child = spawn(
     process.execPath,
-    [process.argv[1], ...cliArgs],
+    [resolvePiCliEntry(process.argv[1] ?? "", process.env, isPiHost(ctx.sessionManager)), ...cliArgs],
     delegateSpawnOptions(cwd, childEnv)
   );
   child.stdin?.once("error", (e) => {
@@ -9187,13 +10106,15 @@ function makeStatusTool(runtime) {
 async function handleStatus(args, runtime, ctx) {
   const { state, coreMessages } = await runtime.stateFor(ctx);
   const config = runtime.configFor(ctx);
-  const tokenCount = estimateTokens(coreMessages, collectCoveredMessageIds(state));
-  const realUsage = ctx.getContextUsage?.();
+  const coveredIds = collectCoveredMessageIds(state);
+  const systemPromptText = getSystemPromptText(ctx);
+  const systemPromptTokens = systemPromptText ? defaultCountTokens(systemPromptText) : 0;
+  const sentTokens = estimateTokens(coreMessages, coveredIds) + systemPromptTokens;
   const turn = runtime.core.processTurn({
     messages: coreMessages,
     state,
     config,
-    tokenCount: realUsage?.tokens && realUsage.tokens > 0 ? realUsage.tokens : tokenCount
+    tokenCount: sentTokens
   });
   const processed = turn.messages;
   const base = buildStatusReport(turn.state, processed, defaultCountTokens, {
@@ -9205,7 +10126,7 @@ async function handleStatus(args, runtime, ctx) {
   });
   if (args.scope) return base;
   const nudge = turn.nudge;
-  const ranges = nudge?.compressibleRanges ?? [];
+  const ranges = viableRanges(nudge?.compressibleRanges ?? []);
   const protectedRanges = nudge?.protectedRanges ?? [];
   const extra = [];
   if (nudge) {
@@ -9236,23 +10157,6 @@ async function handleStatus(args, runtime, ctx) {
 ${extra.join("\n")}` : base;
 }
 
-// src/compat.ts
-function normalizeSystemPrompt(input) {
-  if (input === void 0) return "";
-  if (Array.isArray(input)) return input.join("\n");
-  return input;
-}
-function formatSystemPromptForEvent(base, append) {
-  const normalized = normalizeSystemPrompt(base);
-  return `${normalized}
-
-${append}`;
-}
-function getSystemPromptText(ctx) {
-  const result = ctx.getSystemPrompt?.();
-  return normalizeSystemPrompt(result);
-}
-
 // src/commands.ts
 function makeCommands(runtime) {
   return [
@@ -9320,110 +10224,39 @@ ${text}`);
     }
   ];
 }
-function fmtTokens(n) {
-  return formatCompactTokens(n);
-}
-function bar(value, total, width = 20) {
-  if (total === 0) return "";
-  const filled = Math.max(0, Math.min(width, Math.round(value / total * width)));
-  return "\u2588".repeat(filled) + "\u2591".repeat(width - filled);
-}
 async function statusReport(runtime, ctx) {
   const { state, coreMessages } = await runtime.stateFor(ctx);
   const config = runtime.configFor(ctx);
   const realUsage = ctx.getContextUsage?.();
-  const tokenCount = realUsage?.tokens && realUsage.tokens > 0 ? realUsage.tokens : defaultCountTokens(coreMessages.map((m) => m.text ?? "").join("\n"));
-  const turn = runtime.core.processTurn({ messages: coreMessages, state, config, tokenCount });
-  const nudge = turn.nudge;
-  const bd = nudge?.contextBreakdown;
-  const limit = config.modelContextLimit;
-  const classified = bd ? bd.system + bd.tool + bd.summaries + bd.code + bd.text : 0;
   const systemPromptText = getSystemPromptText(ctx);
   const systemPromptTokens = systemPromptText ? defaultCountTokens(systemPromptText) : 0;
-  const framework = bd ? Math.max(0, tokenCount - classified - systemPromptTokens) : 0;
-  const displayTotal = tokenCount;
-  const displayPct = limit > 0 ? Math.round(displayTotal / limit * 100) : 0;
-  const activeBlocksList = state.blocks.filter((b) => b.active);
-  const totalBlocksList = state.blocks;
-  const lines = [];
-  const versionStr = "0.1.36" ? `billion-context-pi@${"0.1.36"}` : "";
-  lines.push("\u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E");
-  lines.push("\u2502           ACP Context Analysis              \u2502");
-  lines.push("\u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F");
-  if (versionStr) lines.push(versionStr);
-  lines.push("");
-  lines.push(`Context: ${displayPct}% (${fmtTokens(displayTotal)} / ${fmtTokens(limit)})`);
-  if (nudge && bd) {
-    const growth = bd.growth;
-    if (growth > 0 && displayTotal > 0) {
-      lines.push(`Growth: +${fmtTokens(growth)} since last nudge`);
-    }
-    if (displayTotal > 0) {
-      lines.push("");
-      lines.push("Token Breakdown:");
-      const categories = [
-        { label: "Tool", value: bd.tool },
-        { label: "SysPrompt", value: systemPromptTokens },
-        { label: "Framework", value: framework },
-        { label: "Text", value: bd.text },
-        { label: "Code", value: bd.code },
-        { label: "Summaries", value: bd.summaries }
-      ];
-      for (const cat of categories) {
-        if (cat.value <= 0) continue;
-        const pct2 = displayTotal > 0 ? Math.round(cat.value / displayTotal * 100) : 0;
-        const b = bar(cat.value, displayTotal);
-        lines.push(`  ${cat.label.padEnd(10)} ${b} ${String(pct2).padStart(3)}%  ${fmtTokens(cat.value)}`);
-      }
-    }
-  }
-  lines.push("");
-  if (nudge) {
-    if (nudge.shouldInject) {
-      const tierInfo = nudge.tier ? ` [T${nudge.tier} distillation]` : "";
-      lines.push(`Nudge: ACTIVE${tierInfo} \u2014 ${nudge.reason}`);
-    } else {
-      lines.push(`Nudge: idle \u2014 ${nudge.reason}`);
-    }
-  }
-  const ranges = nudge?.compressibleRanges ?? [];
-  const protectedRanges = nudge?.protectedRanges ?? [];
-  if (ranges.length > 0 || protectedRanges.length > 0) {
-    lines.push("");
-    lines.push(formatRanges(ranges, protectedRanges));
-  }
-  if (activeBlocksList.length > 0) {
-    lines.push("");
-    lines.push(`Blocks: ${activeBlocksList.length} active / ${totalBlocksList.length} total (${fmtTokens(state.stats.tokensCompressed)} tokens compressed)`);
-    for (const b of activeBlocksList) {
-      const topic = b.topic ? `: ${b.topic}` : "";
-      const summaryTok = defaultCountTokens(b.summary || "");
-      const origTok = b.compressedTokens > 0 ? b.compressedTokens : summaryTok;
-      lines.push(`  [${b.blockId}] T${b.tier} ${fmtTokens(origTok)}\u2192${fmtTokens(summaryTok)}${topic}`);
-    }
-  } else if (totalBlocksList.length > 0) {
-    lines.push("");
-    lines.push(`Blocks: 0 active / ${totalBlocksList.length} total (${fmtTokens(state.stats.tokensCompressed)} tokens compressed)`);
-  } else {
-    lines.push("");
-    lines.push("Blocks: none (nothing compressed yet)");
-  }
-  lines.push("");
+  const sessionTokens = realUsage?.tokens && realUsage.tokens > 0 ? realUsage.tokens : defaultCountTokens(coreMessages.map((m) => m.text ?? "").join("\n"));
+  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.38" ? `billion-context-pi@${"0.1.38"}` : void 0;
+  let text = buildStatusPanel({
+    version: versionStr,
+    tokenCount: sessionTokens,
+    systemPromptTokens,
+    state: turn.state,
+    nudge: turn.nudge,
+    modelContextLimit: config.modelContextLimit,
+    unprunedTokens: coreMessages.reduce((sum, m) => sum + defaultCountTokens(m.text ?? ""), 0)
+  });
   const delegateUsage = getDelegateUsage();
   if (delegateUsage && delegateUsage.totalTokens > 0) {
-    lines.push("");
     const cost = delegateUsage.cost.total;
     const costStr = cost > 0 ? ` ($${cost.toFixed(4)})` : "";
-    lines.push("\u2500\u2500 Session delegate usage (excluded from main totals) \u2500\u2500");
-    lines.push(`Tokens: ${delegateUsage.input.toLocaleString()} in, ${delegateUsage.output.toLocaleString()} out (${delegateUsage.totalTokens.toLocaleString()} total)${costStr}`);
+    text += "\n\n\u2500\u2500 Session delegate usage (excluded from main totals) \u2500\u2500\n";
+    text += `Tokens: ${delegateUsage.input.toLocaleString()} in, ${delegateUsage.output.toLocaleString()} out (${delegateUsage.totalTokens.toLocaleString()} total)${costStr}`;
   }
-  lines.push("");
-  lines.push("Tag visibility: tags injected to LLM only (deep copy), not persisted in session, not shown in terminal.");
-  return lines.join("\n");
+  return text;
 }
 
 // src/system-prompt.ts
-var ACP_SYSTEM_PROMPT = `
+function buildAcpSystemPrompt(prompts) {
+  return `
 ACP context management
 
 ACP TAGS
@@ -9447,7 +10280,7 @@ You have four context-management tools:
 - 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.
 
-${COMPRESS_PHILOSOPHY}
+${prompts.compressPhilosophy}
 
 WHEN TO COMPRESS
 
@@ -9465,7 +10298,7 @@ WHEN NOT TO COMPRESS
 - 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.
 
-${HOW_TO_COMPRESS_RULES}
+${prompts.howToCompressRules}
 
 MULTI-TIER COMPRESSION
 
@@ -9473,9 +10306,9 @@ Summaries accumulate as the session grows. When tier-1 summaries pile up, the sy
 
 To compress blocks: use block IDs as boundaries: compress({ content: [{ startId: "b3", endId: "b15", summary: "..." }] }). This deactivates the consumed blocks and creates a new higher-tier block.
 
-${TIER2_DISTILL_RULES}
+${prompts.tier2DistillRules}
 
-${TIER3_CONDENSE_RULES}
+${prompts.tier3CondenseRules}
 
 THE PHILOSOPHY OF DECOMPRESS
 
@@ -9485,6 +10318,7 @@ CONTEXT BREAKDOWN
 
 When context usage passes a threshold, the system appends a breakdown showing where tokens are spent. Compress the largest ranges first when the current step no longer needs them.
 `;
+}
 var ACP_DELEGATE_PROMPT = `
 ACP_DELEGATE NOTIFICATIONS
 
@@ -9613,7 +10447,7 @@ function wireToolGuardrails(pi, runtime) {
 
 // src/update.ts
 import { readFile, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import { join as join5, dirname as dirname3 } from "path";
+import { join as join5, dirname as dirname4 } from "path";
 import { fileURLToPath } from "url";
 import { execFile } from "child_process";
 import { homedir as homedir3 } from "os";
@@ -9646,7 +10480,7 @@ async function readLastCheck() {
 }
 async function writeLastCheck(timestamp) {
   try {
-    await mkdir3(dirname3(THROTTLE_FILE), { recursive: true });
+    await mkdir3(dirname4(THROTTLE_FILE), { recursive: true });
     await writeFile3(THROTTLE_FILE, String(timestamp), "utf-8");
   } catch {
   }
@@ -9660,20 +10494,20 @@ async function readPackageJson(path4) {
   }
 }
 function findNpmRoot(extDir) {
-  let dir = dirname3(extDir);
+  let dir = dirname4(extDir);
   for (; ; ) {
-    if (dir.endsWith("node_modules")) return dirname3(dir);
-    const parent = dirname3(dir);
+    if (dir.endsWith("node_modules")) return dirname4(dir);
+    const parent = dirname4(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
 }
 async function findExtensionDir() {
-  let dir = dirname3(fileURLToPath(import.meta.url));
+  let dir = dirname4(fileURLToPath(import.meta.url));
   for (; ; ) {
     const pkg = await readPackageJson(join5(dir, "package.json"));
     if (pkg?.name === PACKAGE_NAME) return dir;
-    const parent = dirname3(dir);
+    const parent = dirname4(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -9722,7 +10556,7 @@ async function checkForUpdate(autoUpdate, notify) {
     const data = await res.json();
     const latest = data.version;
     if (!latest) return;
-    const current = runtimeVersion ?? "0.1.36";
+    const current = runtimeVersion ?? "0.1.38";
     const hasUpdate = isNewer(latest, current);
     debug.event("update-check", {
       current,
@@ -9758,7 +10592,7 @@ async function getRuntimeVersion() {
 
 // src/setup-subagent-tools.ts
 import { readFile as readFile2, writeFile as writeFile4, stat, copyFile, rename } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join6 } from "path";
 import { CONFIG_DIR_NAME as CONFIG_DIR_NAME3 } from "@earendil-works/pi-coding-agent";
@@ -9823,7 +10657,7 @@ async function ensureSubagentAcpTools(settingsPath) {
     return { path: path4, action: "skipped", reason: "all builtin agents already have ACP tools" };
   }
   const backupPath = `${path4}.acp-bak`;
-  if (!existsSync2(backupPath)) {
+  if (!existsSync3(backupPath)) {
     try {
       await copyFile(path4, backupPath);
     } catch {
@@ -9923,7 +10757,9 @@ var KNOWN = /* @__PURE__ */ new Set([
   "toolOutputMaxBytes",
   "delegate",
   "compress",
-  "displayUsage"
+  "displayUsage",
+  "prompts",
+  "acknowledgePromptsRisk"
 ]);
 function pickKnown(parsed) {
   const out = {};
@@ -9971,7 +10807,7 @@ function wireSessionLifecycle(pi, runtime) {
     resetDelegateUsage();
     setDelegateDisplayUsage("separate");
     const sid = ctx.sessionManager.getSessionId();
-    logInfo("session", { event: "start", sid, cwd: ctx.cwd, debug: runtime.adapter.debug ?? null, version: true ? "0.1.36" : null });
+    logInfo("session", { event: "start", sid, cwd: ctx.cwd, debug: runtime.adapter.debug ?? null, version: true ? "0.1.38" : null });
     try {
       const user = await loadUserConfig(ctx.cwd);
       runtime.setAdapter(applyUserConfig(runtime.adapter, user));
@@ -9980,6 +10816,12 @@ function wireSessionLifecycle(pi, runtime) {
     } catch (e) {
       logThrow("config", e, { sid, phase: "session_start" });
     }
+    try {
+      runtime.setPrompts(resolvePrompts(runtime.adapter.prompts, { acknowledgeRisk: runtime.adapter.acknowledgePromptsRisk === true }));
+    } catch (e) {
+      logWarn("config", { event: "prompts-resolve-failed", error: e instanceof Error ? e.message : String(e) });
+      runtime.setPrompts(defaultPrompts);
+    }
     if (resolveDelegate(runtime.adapter).enabled) {
       pi.registerTool(makeDelegateTool(pi));
       pi.registerTool(makeDelegateWaitTool(pi));
@@ -10005,17 +10847,17 @@ function wireContextTransform(pi, runtime) {
       const config = runtime.configFor(ctx);
       const coveredIds = collectCoveredMessageIds(state);
       const realUsage = ctx.getContextUsage?.();
-      const estimated = estimateTokens(coreMessages, coveredIds);
-      const tokenCount = realUsage?.tokens && realUsage.tokens > 0 ? realUsage.tokens : estimated;
+      const systemPromptText = getSystemPromptText(ctx);
+      const systemPromptTokens = systemPromptText ? defaultCountTokens(systemPromptText) : 0;
+      const sentTokens = estimateTokens(coreMessages, coveredIds) + systemPromptTokens;
+      const tokenCount = sentTokens;
       debug.event("context-in", {
         sid,
         eventMsgs: event.messages?.length ?? 0,
         entries: entries.length,
         coreMsgs: coreMessages.length,
         tokenCount,
-        estimatedTokens: estimated,
-        realTokens: realUsage?.tokens ?? null,
-        realPercent: realUsage?.percent ?? null,
+        sessionTokens: realUsage?.tokens ?? null,
         limit: config.modelContextLimit,
         blocksBefore: state.blocks.length,
         activeBefore: state.blocks.filter((b) => b.active).length
@@ -10040,7 +10882,7 @@ function wireContextTransform(pi, runtime) {
         prunedMsgs: coreMessages.length - turn.messages.length + turn.messages.filter((m) => m.id.startsWith("acp_summary")).length,
         nudgeShouldInject: turn.nudge?.shouldInject ?? false,
         nudgeReason: turn.nudge?.reason ?? null,
-        nudgeVoice: turn.nudge ? renderNudgeText(turn.nudge).voice : null,
+        nudgeVoice: turn.nudge ? renderNudgeText(turn.nudge, runtime.prompts).voice : null,
         nudgePct: turn.nudge ? Math.round(turn.nudge.contextUsage * 100) : null,
         nudgeTier: turn.nudge?.tier ?? null,
         nudgeCompressibleCount: turn.nudge?.compressibleRanges.length ?? 0,
@@ -10054,11 +10896,12 @@ function wireContextTransform(pi, runtime) {
       const debugOn2 = debug.enabled;
       if (turn.nudge?.shouldInject) {
         const emergency = turn.nudge.breakdown?.emergencyOverride === 1;
+        turn.nudge.compressibleRanges = viableRanges(turn.nudge.compressibleRanges);
         const turnKey = lastUserMessageId(entries) ?? sid;
         const alreadyShown = !emergency && runtime.nudgeShownFor(turnKey);
         if (!alreadyShown) {
-          rebuilt.push(nudgeMessage(turn.nudge, turn.state.blocks.filter((b) => b.active)));
-          const rendered = renderNudgeText(turn.nudge);
+          rebuilt.push(nudgeMessage(turn.nudge, turn.state.blocks.filter((b) => b.active), runtime.prompts));
+          const rendered = renderNudgeText(turn.nudge, runtime.prompts);
           const top = [...turn.nudge.compressibleRanges].sort((a, b) => b.tokens - a.tokens)[0];
           const example = top ? `
 
@@ -10092,8 +10935,9 @@ ${rendered.text}${example}`);
 function wireSystemPrompt(pi, runtime) {
   pi.on("before_agent_start", (event) => {
     const delegate = runtime.adapter.delegate !== false;
-    const prompt = delegate ? `${ACP_SYSTEM_PROMPT}
-${ACP_DELEGATE_PROMPT}` : ACP_SYSTEM_PROMPT;
+    const acp = buildAcpSystemPrompt(runtime.prompts);
+    const prompt = delegate ? `${acp}
+${ACP_DELEGATE_PROMPT}` : acp;
     return { systemPrompt: formatSystemPromptForEvent(event.systemPrompt, prompt) };
   });
 }
@@ -10109,8 +10953,8 @@ function collectOriginals(entries) {
   }
   return map;
 }
-function nudgeMessage(nudge, blocks) {
-  const rendered = renderNudgeText(nudge);
+function nudgeMessage(nudge, blocks, prompts) {
+  const rendered = renderNudgeText(nudge, prompts);
   const lines = [rendered.text];
   if (blocks.length > 0) {
     const totalSummary = blocks.reduce((s, b) => s + Math.ceil((b.summary || "").length / 4), 0);