billion-context 0.1.25 → 0.1.26

package/dist/index.js

@@ -17900,8 +17900,2279 @@ var require_lib = __commonJS({
   }
 });
 
+// node_modules/acp-kernel/dist/index.js
+import { createRequire } from "module";
+var REF_WIDTH = 5;
+var MIN_INDEX = 1;
+var MAX_INDEX = 99999;
+var REF_PATTERN = /^m0*(\d{1,5})$/;
+var BLOCKED_REF = "BLOCKED";
+function indexToRef(index) {
+  if (!Number.isInteger(index) || index < MIN_INDEX || index > MAX_INDEX) {
+    throw new RangeError(
+      `ref index out of bounds: ${index} (allowed ${MIN_INDEX}-${MAX_INDEX})`
+    );
+  }
+  return `m${String(index).padStart(REF_WIDTH, "0")}`;
+}
+function refToIndex(ref) {
+  const match = REF_PATTERN.exec(ref.trim().toLowerCase());
+  if (!match) return null;
+  const index = Number(match[1]);
+  if (index < MIN_INDEX || index > MAX_INDEX) return null;
+  return index;
+}
+function refForRaw(map, rawId) {
+  return map.byRaw[rawId] ?? null;
+}
+function assignRefs(messages, options) {
+  const map = {
+    byRaw: { ...options.existing.byRaw },
+    byRef: { ...options.existing.byRef }
+  };
+  let cursor = Number.isInteger(options.nextIndex) && options.nextIndex >= MIN_INDEX ? options.nextIndex : MIN_INDEX;
+  let newlyAssigned = 0;
+  for (const message of messages) {
+    if (!message.id || options.shouldSkip?.(message)) continue;
+    if (map.byRaw[message.id]) continue;
+    if (options.isProtected?.(message)) {
+      map.byRaw[message.id] = BLOCKED_REF;
+      continue;
+    }
+    const ref = allocateFreeRef(map, cursor);
+    cursor = ref.index + 1;
+    map.byRaw[message.id] = ref.text;
+    map.byRef[ref.text] = message.id;
+    newlyAssigned++;
+  }
+  return { map, nextIndex: cursor, newlyAssigned };
+}
+function allocateFreeRef(map, start) {
+  let candidate = Math.max(start, MIN_INDEX);
+  while (candidate <= MAX_INDEX) {
+    const text = indexToRef(candidate);
+    if (!map.byRef[text]) {
+      return { text, index: candidate };
+    }
+    candidate++;
+  }
+  throw new Error(
+    `ref capacity exhausted: cannot allocate beyond ${indexToRef(MAX_INDEX)}`
+  );
+}
+function highestUsedIndex(map) {
+  let highest = 0;
+  for (const ref of Object.values(map.byRaw)) {
+    const index = ref === BLOCKED_REF ? null : refToIndex(ref);
+    if (index !== null && index > highest) highest = index;
+  }
+  return highest;
+}
+function createInitialState() {
+  return {
+    blocks: [],
+    messageRefs: { byRaw: {}, byRef: {} },
+    nudge: {
+      lastPerMessageNudgeTokens: 0,
+      lastNudgeShownTokens: 0,
+      baselineTokens: 0,
+      anchors: {},
+      lastShownByTier: {}
+    },
+    stats: { tokensCompressed: 0, compressionCount: 0 },
+    nextBlockId: 1,
+    nextRunId: 1
+  };
+}
+function allocateBlockId(state) {
+  const id = state.nextBlockId;
+  state.nextBlockId = Math.max(1, id) + 1;
+  return `b${id}`;
+}
+function allocateRunId(state) {
+  const id = state.nextRunId;
+  state.nextRunId = Math.max(1, id) + 1;
+  return `r${id}`;
+}
+function blockById(state, blockId) {
+  return state.blocks.find((block) => block.blockId === blockId);
+}
+function activeBlocks(state) {
+  return state.blocks.filter((block) => block.active);
+}
+function coveredMessageIds(state) {
+  const covered = /* @__PURE__ */ new Set();
+  for (const block of state.blocks) {
+    if (!block.active) continue;
+    for (const id of block.effectiveMessageIds) covered.add(id);
+  }
+  return covered;
+}
+function advanceSurvival(state, promotionThreshold) {
+  for (const block of state.blocks) {
+    if (!block.active) continue;
+    block.survivedCount += 1;
+    if (block.survivedCount >= promotionThreshold) {
+      block.generation = "old";
+    }
+  }
+}
+var SUMMARY_HEADER = "[Compressed conversation section]";
+function prune(messages, state, options = {}) {
+  const covered = coveredMessageIds(state);
+  if (covered.size === 0) return [...messages];
+  const inject = options.injectSummaries ?? true;
+  const firstUserIndex = messages.findIndex(
+    (message) => message.role === "user"
+  );
+  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)
+    )
+  );
+}
+function collectSummaryAnchors(state, indexById) {
+  const anchors = [];
+  for (const block of activeBlocks(state)) {
+    let earliest = null;
+    for (const id of block.effectiveMessageIds) {
+      const index = indexById.get(id);
+      if (index !== void 0 && (earliest === null || index < earliest)) {
+        earliest = index;
+      }
+    }
+    anchors.push({
+      blockId: block.blockId,
+      summary: block.summary,
+      topic: block.topic,
+      insertAt: earliest ?? 0
+    });
+  }
+  anchors.sort((left, right) => left.insertAt - right.insertAt);
+  return anchors;
+}
+function rebuildMessages(messages, covered, firstUserIndex, anchors) {
+  const result = [];
+  const pending = [...anchors];
+  for (let index = 0; index < messages.length; index++) {
+    while (pending.length > 0 && pending[0].insertAt === index) {
+      result.push(renderSummary(pending.shift()));
+    }
+    if (index === firstUserIndex && firstUserIndex >= 0) {
+      result.push(messages[index]);
+      continue;
+    }
+    if (covered.has(messages[index].id)) continue;
+    result.push(messages[index]);
+  }
+  while (pending.length > 0) {
+    result.push(renderSummary(pending.shift()));
+  }
+  return result;
+}
+function renderSummary(anchor) {
+  const body = anchor.summary.trim();
+  const topicLine = anchor.topic ? `${SUMMARY_HEADER} \u2014 ${anchor.topic}` : SUMMARY_HEADER;
+  const text = body.length === 0 ? topicLine : `${topicLine}
+${body}`;
+  return {
+    id: `acp_summary_${anchor.blockId}`,
+    role: "system",
+    contentType: "text",
+    text
+  };
+}
+function stripOrphanedToolResults(messages) {
+  const knownCallIds = /* @__PURE__ */ new Set();
+  for (const m2 of messages) {
+    if (m2.contentType === "tool-call" && m2.toolCallId) {
+      knownCallIds.add(m2.toolCallId);
+    }
+  }
+  return messages.filter(
+    (m2) => m2.contentType !== "tool-result" || !m2.toolCallId || knownCallIds.has(m2.toolCallId)
+  );
+}
+function stripOrphanedToolCalls(messages) {
+  const knownResultIds = /* @__PURE__ */ new Set();
+  for (const m2 of messages) {
+    if (m2.contentType === "tool-result" && m2.toolCallId) {
+      knownResultIds.add(m2.toolCallId);
+    }
+  }
+  return messages.filter(
+    (m2) => m2.contentType !== "tool-call" || !m2.toolCallId || m2.toolName === "compress" || knownResultIds.has(m2.toolCallId)
+  );
+}
+function syncBlocks(messages, state) {
+  const presentIds = new Set(messages.map((message) => message.id));
+  const deactivated = [];
+  const result = {
+    blocks: state.blocks.map((block) => ({
+      ...block,
+      directMessageIds: [...block.directMessageIds],
+      effectiveMessageIds: [...block.effectiveMessageIds],
+      directBlockIds: [...block.directBlockIds]
+    })),
+    messageRefs: {
+      byRaw: { ...state.messageRefs.byRaw },
+      byRef: { ...state.messageRefs.byRef }
+    },
+    nudge: { ...state.nudge, anchors: { ...state.nudge.anchors } },
+    stats: { ...state.stats },
+    nextBlockId: state.nextBlockId,
+    nextRunId: state.nextRunId
+  };
+  const consumedBlockIds = /* @__PURE__ */ new Set();
+  for (const block of result.blocks) {
+    for (const consumedId of block.directBlockIds) {
+      consumedBlockIds.add(consumedId);
+    }
+  }
+  for (const block of result.blocks) {
+    if (consumedBlockIds.has(block.blockId)) {
+      block.active = false;
+      continue;
+    }
+    block.active = true;
+    const stillPresent = block.effectiveMessageIds.some(
+      (id) => presentIds.has(id)
+    );
+    if (!stillPresent) {
+      block.active = false;
+      deactivated.push(block.blockId);
+    }
+  }
+  return { state: result, deactivated };
+}
+var require2 = createRequire(import.meta.url);
+function defaultCountTokens(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 estimateTokensFast(text) {
+  if (!text) return 0;
+  return Math.ceil(text.length / 4);
+}
+function defaultConfig(modelContextLimit, overrides = {}) {
+  const base = {
+    tiers: { enabled: true, tier2Trigger: 5, tier3Trigger: 10 },
+    nudge: {
+      maxContextLimitPct: 0.55,
+      minContextLimitPct: 0.45,
+      frequency: 5,
+      iterationThreshold: 15,
+      force: "soft",
+      growthRatio: 0.05,
+      growthFloor: Math.max(2e4, Math.round(modelContextLimit * 0.05)),
+      growthCap: 5e4,
+      minGrowthFloor: 2e4,
+      minGrowthRatio: 0.45,
+      emergencyThresholdPct: 0.8
+    },
+    promotionThreshold: 5,
+    truncate: { threshold: 1 },
+    compress: {
+      minCompressRange: 5e3,
+      maxSummaryLength: 2e4,
+      minSummaryLength: 50
+    },
+    protectedTools: [],
+    preserveRecentMessages: 5,
+    preserveRecentTokens: 5e3,
+    modelContextLimit
+  };
+  return {
+    ...base,
+    ...overrides,
+    tiers: { ...base.tiers, ...overrides.tiers },
+    nudge: { ...base.nudge, ...overrides.nudge },
+    truncate: { ...base.truncate, ...overrides.truncate },
+    compress: { ...base.compress, ...overrides.compress }
+  };
+}
+function validateConfig(config) {
+  const errors = [];
+  if (!Number.isFinite(config.modelContextLimit) || config.modelContextLimit <= 0) {
+    errors.push("modelContextLimit must be a positive number");
+  }
+  if (config.nudge.minContextLimitPct > config.nudge.maxContextLimitPct) {
+    errors.push(
+      "nudge.minContextLimitPct must not exceed nudge.maxContextLimitPct"
+    );
+  }
+  if (config.promotionThreshold < 1) {
+    errors.push("promotionThreshold must be >= 1");
+  }
+  if (config.truncate.threshold <= 0 || config.truncate.threshold > 1) {
+    errors.push("truncate.threshold must be in (0, 1]");
+  }
+  for (const tier of [config.tiers.tier2Trigger, config.tiers.tier3Trigger]) {
+    if (tier < 1) errors.push("tier triggers must be >= 1");
+  }
+  if (config.tiers.tier3Trigger <= config.tiers.tier2Trigger) {
+    errors.push("tiers.tier3Trigger must be greater than tiers.tier2Trigger");
+  }
+  return errors;
+}
+var MESSAGE_REF_PATTERN = /^m0*(\d{1,5})$/;
+var BLOCK_REF_PATTERN = /^b(\d{1,9})$/;
+function parseBoundary(ref) {
+  const normalized = ref.trim().toLowerCase();
+  const messageMatch = MESSAGE_REF_PATTERN.exec(normalized);
+  if (messageMatch) {
+    const numericId = Number(messageMatch[1]);
+    if (numericId >= 1 && numericId <= 99999) {
+      return { kind: "message", numericId, raw: normalized };
+    }
+  }
+  const blockMatch = BLOCK_REF_PATTERN.exec(normalized);
+  if (blockMatch) {
+    const numericId = Number(blockMatch[1]);
+    if (numericId >= 1) return { kind: "block", numericId, raw: normalized };
+  }
+  return null;
+}
+function resolveBoundaries(input) {
+  const start = parseBoundary(input.startRef);
+  const end = parseBoundary(input.endRef);
+  if (!start || !end) {
+    throw new Error(
+      `Invalid boundary ref(s): startId="${input.startRef}", endId="${input.endRef}". Use mNNNNN or bN.`
+    );
+  }
+  const indexByRawId = /* @__PURE__ */ new Map();
+  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}".`
+    );
+  }
+  if (startIndex > endIndex) {
+    [startIndex, endIndex] = [endIndex, startIndex];
+  }
+  const messageIds = [];
+  for (let index = startIndex; index <= endIndex; index++) {
+    const message = input.messages[index];
+    if (message) messageIds.push(message.id);
+  }
+  const boundaryKind = start.kind === "block" || end.kind === "block" ? "block" : "message";
+  const nestedBlockIds = [];
+  const nestedSeen = /* @__PURE__ */ new Set();
+  for (const block of activeBlocks(input.state)) {
+    const anchor = earliestIndexOfIds(block.effectiveMessageIds, indexByRawId);
+    if (anchor !== null && anchor >= startIndex && anchor <= endIndex) {
+      if (!nestedSeen.has(block.blockId)) {
+        nestedSeen.add(block.blockId);
+        nestedBlockIds.push(block.blockId);
+      }
+    }
+  }
+  const protectedGaps = [];
+  return {
+    startIndex,
+    endIndex,
+    messageIds,
+    nestedBlockIds,
+    boundaryKind,
+    protectedGaps
+  };
+}
+function resolveAnchorIndex(boundary, state, indexByRawId) {
+  if (boundary.kind === "message") {
+    const rawId = state.messageRefs.byRef[boundary.raw] ?? state.messageRefs.byRef[formatPaddedRef(boundary.numericId)];
+    if (!rawId) return null;
+    const index = indexByRawId.get(rawId);
+    return index === void 0 ? null : index;
+  }
+  const block = blockById(state, `b${boundary.numericId}`);
+  if (!block || !block.active) return null;
+  return earliestIndexOfIds(block.effectiveMessageIds, indexByRawId);
+}
+function formatPaddedRef(index) {
+  return `m${String(index).padStart(5, "0")}`;
+}
+function earliestIndexOfIds(ids, indexByRawId) {
+  let earliest = null;
+  for (const id of ids) {
+    const index = indexByRawId.get(id);
+    if (index !== void 0 && (earliest === null || index < earliest)) {
+      earliest = index;
+    }
+  }
+  return earliest;
+}
+var TRUNCATION_MARKER = "[truncated for context space]";
+var DEFAULTS = {
+  minOutputTokens: 1e3,
+  keepPrefixChars: 2e3,
+  keepSuffixChars: 2e3,
+  protectRecentMessages: 3
+};
+function truncateLargeToolOutputs(messages, tokenCount, config, countTokens, options = {}) {
+  const opts = { ...DEFAULTS, ...options };
+  if (config.modelContextLimit <= 0) return { messages, truncatedCount: 0, savedTokens: 0 };
+  const threshold = config.truncate.threshold * config.modelContextLimit;
+  if (tokenCount < threshold) return { messages, truncatedCount: 0, savedTokens: 0 };
+  const protectedIndex = messages.length - opts.protectRecentMessages;
+  const candidates = [];
+  for (let index = 0; index < messages.length; index++) {
+    if (index >= protectedIndex) break;
+    const message = messages[index];
+    if (message.contentType !== "tool-result") continue;
+    const text = message.text ?? "";
+    if (text.length === 0 || text.includes(TRUNCATION_MARKER)) continue;
+    const tokens = countTokens(text);
+    if (tokens < opts.minOutputTokens) continue;
+    candidates.push({ index, tokens });
+  }
+  if (candidates.length === 0) return { messages, truncatedCount: 0, savedTokens: 0 };
+  candidates.sort((left, right) => right.tokens - left.tokens);
+  const targetTokens = threshold * 0.9;
+  let savedTokens = 0;
+  const edits = /* @__PURE__ */ new Map();
+  let truncatedCount = 0;
+  for (const candidate of candidates) {
+    if (tokenCount - savedTokens <= targetTokens) break;
+    const original = messages[candidate.index].text ?? "";
+    if (original.length <= opts.keepPrefixChars + opts.keepSuffixChars) continue;
+    const prefix = original.slice(0, opts.keepPrefixChars);
+    const suffix = original.slice(-opts.keepSuffixChars);
+    const replacement = prefix + `
+
+...${TRUNCATION_MARKER} \u2014 original ~${candidate.tokens} tokens]...
+
+` + suffix;
+    edits.set(candidate.index, replacement);
+    savedTokens += candidate.tokens - countTokens(replacement);
+    truncatedCount++;
+  }
+  if (truncatedCount === 0) return { messages, truncatedCount: 0, savedTokens: 0 };
+  const updated = messages.map(
+    (message, index) => edits.has(index) ? { ...message, text: edits.get(index) } : message
+  );
+  return { messages: updated, truncatedCount, savedTokens };
+}
+var KEEP_LAST_ORPHANED = 0;
+function hideConsumedCompressCalls(state, messages) {
+  const activeCallIds = /* @__PURE__ */ new Set();
+  const allBlockCallIds = /* @__PURE__ */ new Set();
+  for (const block of state.blocks) {
+    if (block.compressCallId) {
+      allBlockCallIds.add(block.compressCallId);
+      if (block.active) activeCallIds.add(block.compressCallId);
+    }
+  }
+  const lastOrphanedCallIds = [];
+  for (let i = messages.length - 1; i >= 0 && lastOrphanedCallIds.length < KEEP_LAST_ORPHANED; i--) {
+    const message = messages[i];
+    if (message.toolName !== "compress" || message.contentType !== "tool-call") continue;
+    const callId = message.toolCallId;
+    if (callId && !allBlockCallIds.has(callId)) {
+      lastOrphanedCallIds.push(callId);
+    }
+  }
+  const keepCallIds = /* @__PURE__ */ new Set([...activeCallIds, ...lastOrphanedCallIds]);
+  const hiddenCallIds = /* @__PURE__ */ new Set();
+  for (const message of messages) {
+    if (message.toolName === "compress" && message.contentType === "tool-call" && (!message.toolCallId || !keepCallIds.has(message.toolCallId))) {
+      if (message.toolCallId) hiddenCallIds.add(message.toolCallId);
+    }
+  }
+  let hidden = 0;
+  const result = [];
+  for (const message of messages) {
+    if (message.toolName === "compress" && message.contentType === "tool-call" && (!message.toolCallId || !keepCallIds.has(message.toolCallId))) {
+      hidden++;
+      continue;
+    }
+    if (message.contentType === "tool-result" && message.toolCallId && hiddenCallIds.has(message.toolCallId)) {
+      hidden++;
+      continue;
+    }
+    result.push(message);
+  }
+  return { messages: result, hidden };
+}
+var registry = /* @__PURE__ */ new Map();
+function listMessageFilters() {
+  return [...registry.values()];
+}
+function applyMessageFilters(messages, config) {
+  if (!config?.enabled) {
+    return { messages, partsFiltered: 0, partsDropped: 0, partsModified: 0 };
+  }
+  const active = listMessageFilters().filter(
+    (filter) => config.filters?.[filter.name]?.enabled !== false
+  );
+  if (active.length === 0) {
+    return { messages, partsFiltered: 0, partsDropped: 0, partsModified: 0 };
+  }
+  let working = messages.map((message) => ({ ...message }));
+  const tally = { partsFiltered: 0, partsDropped: 0, partsModified: 0 };
+  const total = working.length;
+  const immediate = active.filter((filter) => !filter.keepLastOnly);
+  for (let index = 0; index < working.length; index++) {
+    const message = working[index];
+    const text = message.text ?? "";
+    if (text.length === 0) continue;
+    let current = text;
+    const baseCtx = {
+      text: current,
+      role: message.role,
+      messageIndex: index,
+      totalMessages: total,
+      toolName: message.toolName
+    };
+    for (const filter of immediate) {
+      let decision;
+      try {
+        decision = filter.filter(baseCtx);
+      } catch {
+        continue;
+      }
+      if (decision.action === "keep") continue;
+      tally.partsFiltered++;
+      if (decision.action === "drop") {
+        current = "";
+        tally.partsDropped++;
+      } else if (decision.action === "modify" && decision.text !== void 0) {
+        current = decision.text;
+        tally.partsModified++;
+      }
+      baseCtx.text = current;
+    }
+    if (current !== text) working[index] = { ...message, text: current };
+  }
+  const keepLast = active.filter((filter) => filter.keepLastOnly);
+  for (const filter of keepLast) {
+    let foundLast = false;
+    for (let index = working.length - 1; index >= 0; index--) {
+      const message = working[index];
+      const text = message.text ?? "";
+      if (text.length === 0) continue;
+      const ctx = {
+        text,
+        role: message.role,
+        messageIndex: index,
+        totalMessages: total,
+        toolName: message.toolName
+      };
+      let decision;
+      try {
+        decision = filter.filter(ctx);
+      } catch {
+        continue;
+      }
+      if (decision.action !== "drop" && decision.action !== "modify") continue;
+      if (foundLast) {
+        tally.partsFiltered++;
+        tally.partsDropped++;
+        working[index] = { ...message, text: "" };
+      } else {
+        foundLast = true;
+        if (decision.action === "modify" && decision.text !== void 0) {
+          tally.partsFiltered++;
+          tally.partsModified++;
+          working[index] = { ...message, text: decision.text };
+        }
+      }
+    }
+  }
+  return { messages: working, ...tally };
+}
+function formatTokens(tokens) {
+  if (tokens < 1e3) return String(tokens);
+  if (tokens < 1e4) return (tokens / 1e3).toFixed(1) + "K";
+  return Math.round(tokens / 1e3) + "K";
+}
+function classifyType(message) {
+  if (message.contentType === "tool-call" || message.contentType === "tool-result") {
+    return message.toolName || "tool";
+  }
+  return message.contentType;
+}
+function escapeRegex(s3) {
+  return s3.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var LT = "<";
+var GT = ">";
+var TAG_OPEN = LT + "acp ";
+var TAG_CLOSE = LT + "/acp" + GT;
+function acpTag(ref, tokens, type) {
+  return TAG_OPEN + 'tokens="' + formatTokens(tokens) + '" type="' + type + '"' + GT + ref + TAG_CLOSE;
+}
+function renderMessage(message, map, countTokens, strategy) {
+  const ref = refForRaw(map, message.id);
+  if (!ref || ref === BLOCKED_REF) return message;
+  if (strategy === "none") return message;
+  if (strategy === "text-only" && message.contentType !== "text") {
+    return message;
+  }
+  const ownTagRe = new RegExp(
+    "^" + escapeRegex(TAG_OPEN) + "[^>]*" + GT + escapeRegex(ref) + escapeRegex(TAG_CLOSE) + "\\n?"
+  );
+  const cleanText = (message.text || "").replace(ownTagRe, "");
+  const tokens = countTokens(cleanText);
+  const type = classifyType(message);
+  const prefix = acpTag(ref, tokens, type) + "\n";
+  if (!cleanText) return { ...message, text: prefix };
+  return { ...message, text: prefix + cleanText };
+}
+function renderVisibleRefs(messages, state, countTokens = (text) => Math.ceil(text.length / 4), strategy = "all") {
+  const map = state.messageRefs;
+  return messages.map(
+    (message) => renderMessage(message, map, countTokens, strategy)
+  );
+}
+function createRenderRefsNode(strategy) {
+  return {
+    name: "render-refs",
+    run(io2, ctx) {
+      return {
+        ...io2,
+        messages: renderVisibleRefs(io2.messages, io2.state, ctx.countTokens, strategy)
+      };
+    }
+  };
+}
+var renderRefsNode = createRenderRefsNode("all");
+var ALWAYS_PROTECTED_TOOLS = ["compress"];
+var NEVER_PRESERVE_RECENT_TOOLS = [
+  "decompress",
+  "search_context",
+  "read",
+  "bash"
+];
+function isNeverPreserveRecent(msg2) {
+  if (msg2.contentType !== "tool-call" && msg2.contentType !== "tool-result") {
+    return false;
+  }
+  if (!msg2.toolName) return false;
+  return NEVER_PRESERVE_RECENT_TOOLS.includes(msg2.toolName);
+}
+function matchToolPattern(toolName, pattern) {
+  if (pattern.endsWith("*")) {
+    return toolName.startsWith(pattern.slice(0, -1));
+  }
+  return toolName === pattern;
+}
+function isMessageProtected(msg2, config) {
+  if (msg2.contentType !== "tool-call" && msg2.contentType !== "tool-result" || !msg2.toolName) {
+    return false;
+  }
+  if (ALWAYS_PROTECTED_TOOLS.includes(msg2.toolName)) {
+    return true;
+  }
+  for (const pattern of config.protectedTools) {
+    if (matchToolPattern(msg2.toolName, pattern)) return true;
+  }
+  if (config.isToolProtected?.(msg2.toolName, msg2.text)) return true;
+  return false;
+}
+function collectProtectedToolCallIds(messages, config) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const m2 of messages) {
+    if (m2.contentType === "tool-call" && m2.toolCallId && isMessageProtected(m2, config)) {
+      ids.add(m2.toolCallId);
+    }
+  }
+  return ids;
+}
+function isMessageProtectedWithPairing(msg2, config, protectedCallIds) {
+  if (isMessageProtected(msg2, config)) return true;
+  if (msg2.contentType === "tool-result" && msg2.toolCallId && protectedCallIds.has(msg2.toolCallId)) {
+    return true;
+  }
+  return false;
+}
+function adjustBoundariesForToolPairs(startIndex, endIndex, messages, maxScan = 20) {
+  const callIdsInRange = /* @__PURE__ */ new Set();
+  for (let i = startIndex; i <= endIndex; i++) {
+    const msg2 = messages[i];
+    if (!msg2 || !msg2.toolCallId) continue;
+    if (msg2.toolName === "compress") continue;
+    callIdsInRange.add(msg2.toolCallId);
+  }
+  if (callIdsInRange.size === 0) {
+    return { startIndex, endIndex };
+  }
+  let newEndIndex = endIndex;
+  for (let i = endIndex + 1; i < messages.length && i <= endIndex + maxScan; i++) {
+    const msg2 = messages[i];
+    if (!msg2) break;
+    if (msg2.toolCallId && callIdsInRange.has(msg2.toolCallId)) {
+      newEndIndex = i;
+    } else if (newEndIndex > endIndex) {
+      break;
+    }
+  }
+  let newStartIndex = startIndex;
+  for (let i = startIndex - 1; i >= 0 && i >= startIndex - maxScan; i--) {
+    const msg2 = messages[i];
+    if (!msg2) break;
+    if (msg2.toolCallId && callIdsInRange.has(msg2.toolCallId)) {
+      newStartIndex = i;
+    } else if (newStartIndex < startIndex) {
+      break;
+    }
+  }
+  return { startIndex: newStartIndex, endIndex: newEndIndex };
+}
+function refNum(ref) {
+  const n = parseInt(ref.slice(1), 10);
+  return Number.isNaN(n) ? -1 : n;
+}
+function estimateMessageTokens(message) {
+  return Math.ceil((message.text ?? "").length / 4);
+}
+function isToolMessage(message) {
+  return message.contentType === "tool-call" || message.contentType === "tool-result";
+}
+function isSyntheticOrPruned(message, state) {
+  if (message.text?.startsWith("[Compressed conversation section]")) return true;
+  for (const block of state.blocks) {
+    if (block.active && block.effectiveMessageIds.includes(message.id)) return true;
+  }
+  return false;
+}
+function computeProtectedRefs(messages, state, config) {
+  const preserveN = config.preserveRecentMessages;
+  const preserveTokens = config.preserveRecentTokens;
+  const result = /* @__PURE__ */ new Set();
+  const visible = [];
+  for (const msg2 of messages) {
+    if (isSyntheticOrPruned(msg2, state)) continue;
+    if (isNeverPreserveRecent(msg2)) continue;
+    const ref = state.messageRefs.byRaw[msg2.id];
+    if (!ref || ref === "BLOCKED") continue;
+    visible.push({ ref, tokens: estimateMessageTokens(msg2) });
+  }
+  if (preserveN > 0) {
+    for (const m2 of visible.slice(-preserveN)) {
+      result.add(m2.ref);
+    }
+  }
+  if (preserveTokens > 0) {
+    let tokenAccum = 0;
+    for (let i = visible.length - 1; i >= 0 && tokenAccum < preserveTokens; i--) {
+      result.add(visible[i].ref);
+      tokenAccum += visible[i].tokens;
+    }
+  }
+  if (preserveN > 0) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const msg2 = messages[i];
+      if (msg2.role !== "user" || isSyntheticOrPruned(msg2, state)) continue;
+      const ref = state.messageRefs.byRaw[msg2.id];
+      if (ref && ref !== "BLOCKED") result.add(ref);
+      break;
+    }
+  }
+  return result;
+}
+function buildCompressibleRanges(messages, state, config, protectedZoneRefs) {
+  const compressibleMsgs = [];
+  const protectedMsgs = [];
+  const protectedCallIds = collectProtectedToolCallIds(messages, config);
+  for (const msg2 of messages) {
+    if (isSyntheticOrPruned(msg2, state)) continue;
+    const ref = state.messageRefs.byRaw[msg2.id];
+    if (!ref || ref === "BLOCKED") continue;
+    const rn2 = refNum(ref);
+    if (isMessageProtectedWithPairing(msg2, config, protectedCallIds)) {
+      protectedMsgs.push({
+        ref,
+        refNum: rn2,
+        tokens: estimateMessageTokens(msg2),
+        tools: msg2.toolName ? [msg2.toolName] : []
+      });
+      continue;
+    }
+    if (protectedZoneRefs?.has(ref)) {
+      continue;
+    }
+    compressibleMsgs.push({
+      ref,
+      refNum: rn2,
+      tokens: estimateMessageTokens(msg2),
+      isTool: isToolMessage(msg2),
+      isUser: msg2.role === "user"
+    });
+  }
+  const compressible = [];
+  let cur = null;
+  let prevRefNum = -2;
+  for (const info of compressibleMsgs) {
+    const hasGap = info.refNum > prevRefNum + 1;
+    if (cur && (info.isUser && cur.count >= 3 || hasGap)) {
+      compressible.push(cur);
+      cur = null;
+    }
+    prevRefNum = info.refNum;
+    if (!cur) {
+      cur = {
+        startRef: info.ref,
+        endRef: info.ref,
+        count: 1,
+        tokens: info.tokens,
+        toolPct: info.isTool ? 100 : 0,
+        textPct: info.isTool ? 0 : 100
+      };
+    } else {
+      cur.endRef = info.ref;
+      cur.count++;
+      cur.tokens += info.tokens;
+      if (info.isTool) {
+        cur.toolPct = Math.round((cur.toolPct * (cur.count - 1) + 100) / cur.count);
+      } else {
+        cur.toolPct = Math.round(cur.toolPct * (cur.count - 1) / cur.count);
+      }
+      cur.textPct = 100 - cur.toolPct;
+    }
+  }
+  if (cur) compressible.push(cur);
+  const protectedRanges = [];
+  let pcur = null;
+  let pPrevRefNum = -2;
+  for (const info of protectedMsgs) {
+    const hasGap = info.refNum > pPrevRefNum + 1;
+    if (pcur && hasGap) {
+      protectedRanges.push(pcur);
+      pcur = null;
+    }
+    pPrevRefNum = info.refNum;
+    if (!pcur) {
+      pcur = {
+        startRef: info.ref,
+        endRef: info.ref,
+        count: 1,
+        tokens: info.tokens,
+        tools: [...info.tools]
+      };
+    } else {
+      pcur.endRef = info.ref;
+      pcur.count++;
+      pcur.tokens += info.tokens;
+      for (const t of info.tools) {
+        if (!pcur.tools.includes(t)) pcur.tools.push(t);
+      }
+    }
+  }
+  if (pcur) protectedRanges.push(pcur);
+  return {
+    compressible: compressible.filter((g2) => g2.tokens > 0),
+    protected: protectedRanges
+  };
+}
+function runPipeline(nodes, initial, ctx) {
+  let io2 = initial;
+  for (const node of nodes) {
+    if (node.enabled && !node.enabled(io2, ctx)) continue;
+    io2 = node.run(io2, ctx);
+  }
+  return io2;
+}
+function createCore(ports = {}) {
+  const countTokens = ports.countTokens ?? defaultCountTokens;
+  function applyCompression(input) {
+    const state = cloneState(input.state);
+    const runId = allocateRunId(state);
+    let blocksCreated = 0;
+    let tokensCompressed = 0;
+    const errors = [];
+    const warnings = [];
+    const protectedMessageIds = input.protectedMessageIds ?? computeProtectedRefs(input.messages, input.state, input.config);
+    const preExistingCoverage = collectCoverage(state);
+    const rangeIndexSets = [];
+    for (const spec of input.ranges) {
+      let resolved;
+      try {
+        resolved = resolveBoundaries({
+          startRef: spec.startRef,
+          endRef: spec.endRef,
+          messages: input.messages,
+          state
+        });
+      } catch {
+        continue;
+      }
+      const indices = resolved.messageIds.map(
+        (id) => input.messages.findIndex((m2) => m2.id === id)
+      ).filter((i) => i >= 0);
+      rangeIndexSets.push({ spec, indices });
+    }
+    const sortedRanges = [...rangeIndexSets].sort((a, b2) => {
+      const aMin = a.indices.length > 0 ? Math.min(...a.indices) : Infinity;
+      const bMin = b2.indices.length > 0 ? Math.min(...b2.indices) : Infinity;
+      return aMin - bMin;
+    });
+    for (let i = 1; i < sortedRanges.length; i++) {
+      const prev = sortedRanges[i - 1];
+      const curr = sortedRanges[i];
+      const prevMax = prev.indices.length > 0 ? Math.max(...prev.indices) : -1;
+      const currMin = curr.indices.length > 0 ? Math.min(...curr.indices) : -1;
+      if (prevMax >= currMin && prevMax >= 0) {
+        return {
+          state: input.state,
+          result: {
+            blocksCreated: 0,
+            tokensCompressed: 0,
+            errors: [
+              `content: range (${prev.spec.startRef}..${prev.spec.endRef}) overlaps (${curr.spec.startRef}..${curr.spec.endRef}). Overlapping ranges cannot be compressed in the same batch.`
+            ],
+            warnings: []
+          }
+        };
+      }
+    }
+    if (input.config.compress.minCompressRange > 0 && input.ranges.length > 0) {
+      let totalRangeChars = 0;
+      let hasBlockBoundaryRange = false;
+      for (const spec of input.ranges) {
+        let resolved;
+        try {
+          resolved = resolveBoundaries({
+            startRef: spec.startRef,
+            endRef: spec.endRef,
+            messages: input.messages,
+            state
+          });
+        } catch {
+          continue;
+        }
+        if (resolved.boundaryKind === "block") {
+          hasBlockBoundaryRange = true;
+          continue;
+        }
+        for (const id of resolved.messageIds) {
+          const msg2 = input.messages.find((m2) => m2.id === id);
+          totalRangeChars += msg2?.text?.length ?? 0;
+        }
+      }
+      if (!hasBlockBoundaryRange && totalRangeChars < input.config.compress.minCompressRange) {
+        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.`
+            ],
+            warnings: []
+          }
+        };
+      }
+    }
+    for (const spec of input.ranges) {
+      try {
+        const outcome = applySingleRange({
+          spec,
+          messages: input.messages,
+          state,
+          runId,
+          config: input.config,
+          protectedMessageIds,
+          countTokens,
+          preExistingCoverage
+        });
+        blocksCreated++;
+        tokensCompressed += outcome.tokens;
+        warnings.push(...outcome.warnings);
+      } catch (error) {
+        errors.push(error instanceof Error ? error.message : String(error));
+      }
+    }
+    state.stats.compressionCount += blocksCreated;
+    state.stats.tokensCompressed += tokensCompressed;
+    if (blocksCreated > 0) {
+      state.nudge.lastPerMessageNudgeTokens = 0;
+      state.nudge.lastNudgeShownTokens = 0;
+      state.nudge.lastShownByTier = {};
+    }
+    return { state, result: { blocksCreated, tokensCompressed, errors, warnings } };
+  }
+  function processTurn(input) {
+    const configErrors = validateConfig(input.config);
+    if (configErrors.length > 0) {
+      console.warn(`[acp-kernel] Config validation warnings: ${configErrors.join("; ")}. Thresholds may not fire correctly.`);
+    }
+    const ctx = {
+      config: input.config,
+      tokenCount: input.tokenCount,
+      countTokens
+    };
+    const initial = {
+      messages: input.messages,
+      state: input.state,
+      effects: {}
+    };
+    const strategy = input.renderTags ?? "all";
+    const nodes = buildNodes(strategy);
+    const result = runPipeline(nodes, initial, ctx);
+    return {
+      messages: result.messages,
+      state: result.state,
+      nudge: result.effects.nudge
+    };
+  }
+  function decompress(blockId, state) {
+    return blockById(state, blockId);
+  }
+  function search(query, state) {
+    const terms = query.toLowerCase().split(/\s+/).filter((term) => term.length > 0);
+    if (terms.length === 0) return [];
+    const scored = activeBlocks(state).map((block) => ({ block, score: scoreRelevance(block, terms) })).filter((entry) => entry.score > 0.1).sort((left, right) => right.score - left.score);
+    return scored.map((entry) => entry.block);
+  }
+  function status(state, tokenCount, config) {
+    const active = activeBlocks(state);
+    const usage = config.modelContextLimit > 0 ? tokenCount / config.modelContextLimit : 0;
+    return {
+      contextUsage: usage,
+      tokenCount,
+      modelContextLimit: config.modelContextLimit,
+      activeBlocks: active.length,
+      totalBlocks: state.blocks.length,
+      tokensCompressed: state.stats.tokensCompressed,
+      breakdown: { active: active.length, total: state.blocks.length }
+    };
+  }
+  function defaultNodes() {
+    return buildNodes("all");
+  }
+  function buildNodes(strategy) {
+    const base = [
+      assignRefsNode,
+      syncBlocksNode,
+      pruneNode,
+      filterNode,
+      hideCompressCallsNode,
+      recommendNode,
+      nudgeNode,
+      emergencyTruncateNode
+    ];
+    if (strategy === "none") return base;
+    return [...base, createRenderRefsNode(strategy)];
+  }
+  return { processTurn, applyCompression, defaultNodes, decompress, search, status };
+}
+var assignRefsNode = {
+  name: "assign-refs",
+  run(io2, ctx) {
+    const hasProtection = ctx.config.protectedTools.length > 0 || !!ctx.config.isToolProtected;
+    const protectedFn = hasProtection ? (m2) => isMessageProtected(m2, ctx.config) : void 0;
+    const refResult = assignRefs(io2.messages, {
+      existing: io2.state.messageRefs,
+      nextIndex: highestUsedIndex(io2.state.messageRefs) + 1,
+      isProtected: protectedFn
+    });
+    return { ...io2, state: { ...io2.state, messageRefs: refResult.map } };
+  }
+};
+var syncBlocksNode = {
+  name: "sync-blocks",
+  run(io2, ctx) {
+    const synced = syncBlocks(io2.messages, io2.state);
+    advanceSurvival(synced.state, ctx.config.promotionThreshold);
+    return { ...io2, state: synced.state };
+  }
+};
+var pruneNode = {
+  name: "prune",
+  run(io2) {
+    return { ...io2, messages: prune(io2.messages, io2.state) };
+  }
+};
+var filterNode = {
+  name: "filter",
+  enabled: (_io, ctx) => !!ctx.config.messageFilters?.enabled && listMessageFilters().length > 0,
+  run(io2, ctx) {
+    const applied = applyMessageFilters(io2.messages, ctx.config.messageFilters);
+    return { ...io2, messages: applied.messages };
+  }
+};
+var hideCompressCallsNode = {
+  name: "hide-compress-calls",
+  run(io2) {
+    const hidden = hideConsumedCompressCalls(io2.state, io2.messages);
+    return { ...io2, messages: hidden.messages };
+  }
+};
+var recommendNode = {
+  name: "recommend",
+  run(io2, ctx) {
+    const protectedRefs = computeProtectedRefs(
+      io2.messages,
+      io2.state,
+      ctx.config
+    );
+    const contextRanges = buildCompressibleRanges(
+      io2.messages,
+      io2.state,
+      ctx.config,
+      protectedRefs
+    );
+    const nothingToCompress = contextRanges.compressible.length === 0;
+    const recommendation = {
+      contextRanges,
+      recommendedRanges: contextRanges.compressible,
+      nothingToCompress
+    };
+    return { ...io2, effects: { ...io2.effects, recommendation } };
+  }
+};
+var nudgeNode = {
+  name: "nudge-inject",
+  run(io2, ctx) {
+    const nudge = decideNudge({
+      tokenCount: ctx.tokenCount,
+      config: ctx.config,
+      state: io2.state,
+      messages: io2.messages,
+      recommendation: io2.effects.recommendation,
+      countTokens: ctx.countTokens
+    });
+    const baseline = io2.state.nudge.lastPerMessageNudgeTokens;
+    const nudgeGrowthTokens = resolveAdaptiveGrowth(
+      ctx.config.modelContextLimit,
+      ctx.config.nudge
+    );
+    let stamped = { ...io2.state.nudge };
+    if (baseline > 0 && ctx.tokenCount < baseline - nudgeGrowthTokens) {
+      stamped.lastPerMessageNudgeTokens = ctx.tokenCount;
+      stamped.lastNudgeShownTokens = 0;
+    }
+    if (stamped.lastPerMessageNudgeTokens === 0) {
+      stamped.lastPerMessageNudgeTokens = ctx.tokenCount;
+    }
+    if (nudge.shouldInject) {
+      stamped.lastNudgeShownTokens = ctx.tokenCount;
+      if (nudge.tier !== null) {
+        stamped.lastShownByTier = { ...stamped.lastShownByTier, [nudge.tier]: ctx.tokenCount };
+      }
+    }
+    return {
+      ...io2,
+      state: { ...io2.state, nudge: stamped },
+      effects: { ...io2.effects, nudge }
+    };
+  }
+};
+var emergencyTruncateNode = {
+  name: "emergency-truncate",
+  run(io2, ctx) {
+    const usage = ctx.config.modelContextLimit > 0 ? ctx.tokenCount / ctx.config.modelContextLimit : 0;
+    if (usage < ctx.config.truncate.threshold) return io2;
+    const trunc = truncateLargeToolOutputs(
+      io2.messages,
+      ctx.tokenCount,
+      ctx.config,
+      ctx.countTokens,
+      { protectRecentMessages: ctx.config.preserveRecentMessages }
+    );
+    return {
+      ...io2,
+      messages: trunc.messages,
+      effects: { ...io2.effects, truncatedCount: trunc.truncatedCount }
+    };
+  }
+};
+function applySingleRange(input) {
+  const warnings = [];
+  const resolved = resolveBoundaries({
+    startRef: input.spec.startRef,
+    endRef: input.spec.endRef,
+    messages: input.messages,
+    state: input.state
+  });
+  const rangeMessageIds = applyToolPairAdjustment(
+    resolved,
+    input.messages
+  );
+  if (rangeMessageIds.length > resolved.messageIds.length) {
+    const indexByRawId = /* @__PURE__ */ new Map();
+    input.messages.forEach((m2, i) => indexByRawId.set(m2.id, i));
+    const adjustedStart = indexByRawId.get(rangeMessageIds[0]) ?? resolved.startIndex;
+    const adjustedEnd = indexByRawId.get(rangeMessageIds[rangeMessageIds.length - 1]) ?? resolved.endIndex;
+    const nestedSeen = new Set(resolved.nestedBlockIds);
+    for (const block2 of activeBlocks(input.state)) {
+      if (nestedSeen.has(block2.blockId)) continue;
+      const anchor = earliestIndexOfIds(block2.effectiveMessageIds, indexByRawId);
+      if (anchor !== null && anchor >= adjustedStart && anchor <= adjustedEnd) {
+        nestedSeen.add(block2.blockId);
+        resolved.nestedBlockIds.push(block2.blockId);
+      }
+    }
+  }
+  const isBlockBoundary = resolved.boundaryKind === "block";
+  const targetTier = resolveTargetTier(
+    input.state,
+    resolved.nestedBlockIds,
+    isBlockBoundary
+  );
+  const outputTier = isBlockBoundary ? Math.min(3, targetTier + 1) : 1;
+  const consumedBlockIds = resolved.nestedBlockIds.filter((id) => {
+    const block2 = blockById(input.state, id);
+    return block2?.active && block2.tier === targetTier;
+  });
+  const effectiveMessageIds = new Set(rangeMessageIds);
+  for (const consumedId of consumedBlockIds) {
+    const consumed = blockById(input.state, consumedId);
+    if (consumed) {
+      for (const id of consumed.effectiveMessageIds)
+        effectiveMessageIds.add(id);
+    }
+  }
+  const directMessageIds = [...effectiveMessageIds].filter(
+    (id) => !input.preExistingCoverage.has(id)
+  );
+  let filteredIds = filterProtectedToolMessages(
+    directMessageIds,
+    input.messages,
+    input.config
+  );
+  if (filteredIds.length < directMessageIds.length) {
+    const kept = new Set(filteredIds);
+    for (const id of directMessageIds) {
+      if (!kept.has(id)) effectiveMessageIds.delete(id);
+    }
+  }
+  const protectedRefs = input.protectedMessageIds;
+  const hitProtectedRaw = protectedRefs ? filteredIds.filter((id) => {
+    const ref = input.state.messageRefs.byRaw[id];
+    return ref !== void 0 && protectedRefs.has(ref);
+  }) : [];
+  if (hitProtectedRaw.length > 0) {
+    const protectedSet = new Set(hitProtectedRaw);
+    filteredIds = filteredIds.filter((id) => !protectedSet.has(id));
+    for (const id of hitProtectedRaw) effectiveMessageIds.delete(id);
+    const hitRefs = hitProtectedRaw.map((id) => input.state.messageRefs.byRaw[id]).filter((v2) => typeof v2 === "string");
+    if (filteredIds.length === 0 && consumedBlockIds.length === 0) {
+      const recentN = input.config.preserveRecentMessages;
+      throw new Error(
+        `Range is entirely within the protected zone (the last ${recentN} messages and/or the most recent user message): ${hitRefs.join(
+          ", "
+        )}. Adjust startId/endId to older messages.`
+      );
+    }
+    warnings.push(
+      `Excluded ${hitProtectedRaw.length} protected message(s) ${hitRefs.join(
+        ", "
+      )} from compression range (recent/last-user zone).`
+    );
+  }
+  validateCompressionRange(input, filteredIds, consumedBlockIds.length);
+  let compressedTokens = 0;
+  for (const id of filteredIds) {
+    const message = input.messages.find((entry) => entry.id === id);
+    compressedTokens += input.countTokens(message?.text ?? "");
+  }
+  for (const consumedId of consumedBlockIds) {
+    const consumed = blockById(input.state, consumedId);
+    if (consumed) {
+      compressedTokens += input.countTokens(consumed.summary);
+    }
+  }
+  const blockId = allocateBlockId(input.state);
+  const block = {
+    blockId,
+    runId: input.runId,
+    tier: outputTier,
+    topic: input.spec.topic,
+    summary: input.spec.summary,
+    directMessageIds: filteredIds,
+    effectiveMessageIds: [...effectiveMessageIds],
+    directBlockIds: [...consumedBlockIds],
+    compressedTokens,
+    createdAt: Date.now(),
+    survivedCount: 0,
+    generation: "young",
+    active: true,
+    compressCallId: input.spec.compressCallId
+  };
+  input.state.blocks.push(block);
+  for (const consumedId of consumedBlockIds) {
+    const consumed = blockById(input.state, consumedId);
+    if (consumed) consumed.active = false;
+  }
+  return { tokens: compressedTokens, warnings };
+}
+function applyToolPairAdjustment(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) {
+    return resolved.messageIds;
+  }
+  const ids = [];
+  for (let i = adjusted.startIndex; i <= adjusted.endIndex; i++) {
+    const msg2 = messages[i];
+    if (msg2) ids.push(msg2.id);
+  }
+  return ids;
+}
+function validateCompressionRange(input, directMessageIds, consumedBlockCount) {
+  const cfg = input.config.compress;
+  const summary = input.spec.summary?.trim() ?? "";
+  if (summary.length === 0) {
+    throw new Error(
+      "Summary is empty \u2014 provide a meaningful summary of the compressed range."
+    );
+  }
+  if (cfg.minSummaryLength > 0 && summary.length < cfg.minSummaryLength) {
+    throw new Error(
+      `Summary too short (${summary.length} chars, min ${cfg.minSummaryLength}). The summary must capture the compressed range's key information.`
+    );
+  }
+  const effectiveMax = input.spec.summaryMaxChars ?? cfg.maxSummaryLength;
+  if (effectiveMax > 0 && summary.length > effectiveMax) {
+    throw new Error(
+      `Summary too long (${summary.length} chars, max ${effectiveMax}). Strip noise \u2014 keep critical paths, decisions, errors, and code references. Or pass summaryMaxChars to increase the limit \u2014 don't lose critical info just to fit.`
+    );
+  }
+  if (directMessageIds.length === 0 && consumedBlockCount === 0) {
+    throw new Error(
+      "Range contains no compressible messages \u2014 all are already covered by active blocks or protected."
+    );
+  }
+}
+function filterProtectedToolMessages(directMessageIds, messages, config) {
+  const protectedCallIds = /* @__PURE__ */ new Set();
+  const removedIds = /* @__PURE__ */ new Set();
+  for (const msg2 of messages) {
+    if (isMessageProtected(msg2, config) && msg2.toolCallId) {
+      protectedCallIds.add(msg2.toolCallId);
+    }
+  }
+  for (const id of directMessageIds) {
+    const msg2 = messages.find((m2) => m2.id === id);
+    if (!msg2) continue;
+    if (isMessageProtected(msg2, config)) {
+      removedIds.add(id);
+      if (msg2.toolCallId) protectedCallIds.add(msg2.toolCallId);
+    }
+  }
+  for (const id of directMessageIds) {
+    if (removedIds.has(id)) continue;
+    const msg2 = messages.find((m2) => m2.id === id);
+    if (!msg2) continue;
+    if (msg2.contentType === "tool-result" && msg2.toolCallId && protectedCallIds.has(msg2.toolCallId)) {
+      removedIds.add(id);
+    }
+  }
+  return directMessageIds.filter((id) => !removedIds.has(id));
+}
+function resolveTargetTier(state, nestedBlockIds, isBlockBoundary) {
+  if (!isBlockBoundary) return 1;
+  if (nestedBlockIds.length === 0) return 1;
+  let minTier = 3;
+  for (const id of nestedBlockIds) {
+    const block = blockById(state, id);
+    if (block && block.tier < minTier) minTier = block.tier;
+  }
+  return minTier;
+}
+function collectCoverage(state) {
+  const coverage = /* @__PURE__ */ new Set();
+  for (const block of activeBlocks(state)) {
+    for (const id of block.effectiveMessageIds) coverage.add(id);
+  }
+  return coverage;
+}
+function resolveAdaptiveGrowth(modelContextLimit, nudge) {
+  if (!modelContextLimit || modelContextLimit <= 0) return nudge.growthFloor;
+  return Math.min(
+    nudge.growthCap,
+    Math.max(
+      nudge.growthFloor,
+      Math.round(modelContextLimit * nudge.growthRatio)
+    )
+  );
+}
+function pendingByTier(state, recommendation, countTokens) {
+  const out = {};
+  const compressible = recommendation?.contextRanges.compressible ?? [];
+  out[1] = { pending: compressible.reduce((s3, r) => s3 + r.tokens, 0), targetBlocks: [] };
+  const active = activeBlocks(state);
+  const t1 = active.filter((b2) => b2.tier === 1);
+  const t2 = active.filter((b2) => b2.tier === 2);
+  out[2] = { pending: t1.reduce((s3, b2) => s3 + countTokens(b2.summary), 0), targetBlocks: t1 };
+  out[3] = { pending: t2.reduce((s3, b2) => s3 + countTokens(b2.summary), 0), targetBlocks: t2 };
+  return out;
+}
+function decideNudge(input) {
+  const { config, state, tokenCount, recommendation, countTokens } = input;
+  const limit = config.modelContextLimit;
+  const usage = limit > 0 ? tokenCount / limit : 0;
+  const nudgeGrowthTokens = resolveAdaptiveGrowth(limit, config.nudge);
+  const emergencyOverride = usage >= config.nudge.emergencyThresholdPct;
+  const baseline = state.nudge.lastPerMessageNudgeTokens;
+  const hadPendingNudge = state.nudge.lastNudgeShownTokens > 0;
+  const hasPendingNudge = hadPendingNudge;
+  const effectiveThreshold = hasPendingNudge ? Math.floor(nudgeGrowthTokens / 2) : nudgeGrowthTokens;
+  const growthReference = state.nudge.lastNudgeShownTokens > 0 ? state.nudge.lastNudgeShownTokens : baseline > 0 ? baseline : tokenCount;
+  const growthFloor = Math.max(
+    config.nudge.minGrowthFloor,
+    config.nudge.minGrowthRatio * nudgeGrowthTokens
+  );
+  const growthSinceReference = tokenCount - growthReference;
+  const rec = recommendation;
+  const tiers = pendingByTier(state, rec, countTokens);
+  let injectedTier = null;
+  let injectedReason = "";
+  const growthReady = growthSinceReference >= growthFloor;
+  if (!emergencyOverride && 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 shouldInject = emergencyOverride || injectedTier !== null;
+  let reason;
+  if (emergencyOverride) {
+    reason = `EMERGENCY: usage ${Math.round(usage * 100)}% >= ${Math.round(config.nudge.emergencyThresholdPct * 100)}%`;
+  } else if (injectedTier !== null) {
+    reason = injectedReason;
+  } else {
+    const tiersList = [1, 2, 3];
+    const eligible = tiersList.filter((t) => config.tiers.enabled || t === 1);
+    const ready = eligible.filter((t) => (tiers[t]?.pending ?? 0) >= nudgeGrowthTokens).map((t) => `T${t} ${tiers[t].pending}`);
+    const readyHint = ready.length > 0 ? `, ready: ${ready.join(", ")}` : "";
+    const blocked = eligible.filter((t) => (tiers[t]?.pending ?? 0) >= nudgeGrowthTokens && (state.nudge.lastShownByTier[t] ?? 0) > 0 && tokenCount - (state.nudge.lastShownByTier[t] ?? 0) < growthFloor).map((t) => `T${t} (cadence)`);
+    const blockedHint = blocked.length > 0 ? `, blocked: ${blocked.join(", ")}` : "";
+    const maxPending = Math.max(0, ...Object.values(tiers).map((t) => t.pending));
+    const pendingShort = maxPending < nudgeGrowthTokens;
+    const growthShort = growthSinceReference < growthFloor;
+    const parts = [];
+    if (pendingShort) parts.push(`max compressible ${maxPending} < threshold ${nudgeGrowthTokens}`);
+    if (growthShort) parts.push(`growth ${growthSinceReference} < floor ${growthFloor}`);
+    if (parts.length === 0) parts.push(`max compressible ${maxPending}, growth ${growthSinceReference}`);
+    reason = `${parts.join("; ")}${readyHint}${blockedHint}`;
+  }
+  const ctxBreakdown = computeContextBreakdown(input.messages, tokenCount, growthSinceReference, countTokens);
+  return {
+    shouldInject,
+    reason,
+    compressibleRanges: rec?.recommendedRanges ?? [],
+    protectedRanges: rec?.contextRanges.protected ?? [],
+    tierTargetBlocks: injectedTier ? tiers[injectedTier].targetBlocks : [],
+    contextUsage: usage,
+    tier: injectedTier,
+    breakdown: {
+      usage,
+      growth: growthSinceReference,
+      growthReference,
+      effectiveThreshold,
+      nudgeGrowthTokens,
+      growthFloor,
+      hasPendingNudge: hasPendingNudge ? 1 : 0,
+      emergencyOverride: emergencyOverride ? 1 : 0,
+      pendingT1: tiers[1].pending,
+      pendingT2: tiers[2].pending,
+      pendingT3: tiers[3].pending
+    },
+    contextBreakdown: ctxBreakdown
+  };
+}
+function computeContextBreakdown(messages, total, growth, countTokens) {
+  const count = countTokens ?? ((t) => Math.ceil(t.length / 4));
+  let system = 0, tool = 0, summaries = 0, code = 0, text = 0;
+  for (const msg2 of messages) {
+    const tokens = count(msg2.text ?? "");
+    if (msg2.text?.startsWith("[Compressed conversation section]")) {
+      summaries += tokens;
+    } else if (msg2.contentType === "tool-call" || msg2.contentType === "tool-result") {
+      tool += tokens;
+    } else if (msg2.role === "system") {
+      system += tokens;
+    } else if (msg2.text?.includes("```")) {
+      code += tokens;
+    } else {
+      text += tokens;
+    }
+  }
+  return { system, tool, summaries, code, text, total, growth };
+}
+function cloneState(state) {
+  return {
+    blocks: state.blocks.map((block) => ({
+      ...block,
+      directMessageIds: [...block.directMessageIds],
+      effectiveMessageIds: [...block.effectiveMessageIds],
+      directBlockIds: [...block.directBlockIds]
+    })),
+    messageRefs: {
+      byRaw: { ...state.messageRefs.byRaw },
+      byRef: { ...state.messageRefs.byRef }
+    },
+    nudge: { ...state.nudge, anchors: { ...state.nudge.anchors } },
+    stats: { ...state.stats },
+    nextBlockId: state.nextBlockId,
+    nextRunId: state.nextRunId
+  };
+}
+function scoreRelevance(block, terms) {
+  const topic = (block.topic ?? "").toLowerCase();
+  const summary = block.summary.toLowerCase();
+  let score = 0;
+  for (const term of terms) {
+    const topicHits = countOccurrences(topic, term);
+    if (topicHits > 0) score += Math.min(topicHits * 0.15, 0.45);
+    const summaryHits = countOccurrences(summary, term);
+    if (summaryHits > 0) score += Math.min(summaryHits * 0.04, 0.2);
+  }
+  return Math.min(score, 1);
+}
+function countOccurrences(haystack, needle) {
+  if (!haystack || !needle) return 0;
+  let count = 0;
+  let position = 0;
+  while ((position = haystack.indexOf(needle, position)) !== -1) {
+    count++;
+    position += needle.length;
+  }
+  return count;
+}
+var COMPRESS_PHILOSOPHY = `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_RULES = `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_RULES = `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_RULES = `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 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.
+
+${COMPRESS_PHILOSOPHY}`;
+var EMERGENCY_HEADER = `\u26A0\uFE0F Context limit reached \u2014 compress now. Prioritize consumed tool outputs.
+
+${COMPRESS_PHILOSOPHY}`;
+function formatK(n) {
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+  return `${n}`;
+}
+function formatBreakdown(bd) {
+  if (!bd) return "";
+  const parts = [];
+  if (bd.system > 0) parts.push(`${formatK(bd.system)} system`);
+  if (bd.tool > 0) parts.push(`${formatK(bd.tool)} tool`);
+  if (bd.summaries > 0) parts.push(`${formatK(bd.summaries)} summaries`);
+  if (bd.code > 0) parts.push(`${formatK(bd.code)} code`);
+  if (bd.text > 0) parts.push(`${formatK(bd.text)} text`);
+  const growth = bd.growth > 0 ? `
++${formatK(bd.growth)} since last nudge` : "";
+  return `Context breakdown: ${parts.join(" | ")}${growth}`;
+}
+function formatTierTargetBlocks(blocks) {
+  if (blocks.length === 0) {
+    return "Target blocks: (none \u2014 no tier blocks found)";
+  }
+  const lines = blocks.map((b2) => {
+    const summaryTokens = Math.ceil((b2.summary ?? "").length / 4);
+    const topic = b2.topic ? `  "${b2.topic}"` : "";
+    return `  ${b2.blockId}  ${b2.effectiveMessageIds.length} msgs  ${formatK(b2.compressedTokens)}\u2192${formatK(summaryTokens)}${topic}`;
+  });
+  return `Target ${blocks[0].tier === 1 ? "tier-1" : "tier-2"} blocks to distill (${blocks.length}):
+${lines.join("\n")}`;
+}
+function formatRanges(compressible, protectedRanges) {
+  if (compressible.length === 0 && protectedRanges.length === 0) {
+    return "[No specific ranges detected \u2014 compress any consumed content.]";
+  }
+  const refNum2 = (ref) => {
+    const m2 = ref.match(/\d+/);
+    return m2 ? parseInt(m2[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, b2) => a.startNum - b2.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  ${formatK(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  ${formatK(e.tokens)} [${formatK(e.compressibleTokens)} compressible | ${formatK(e.protectedTokens)} protected: ${e.protectedTools.join(", ")}]${suffix}`;
+    }
+    return `  ${e.startRef}\u2013${e.endRef}  ${e.count} msgs  ${formatK(e.tokens)} [tool ${e.toolPct}% | text ${e.textPct}%]${suffix}`;
+  });
+  return `Compressible ranges (${merged.length}, oldest first):
+${lines.join("\n")}`;
+}
+function renderNudgeText(decision) {
+  const breakdownStr = formatBreakdown(decision.contextBreakdown);
+  const rangesStr = formatRanges(decision.compressibleRanges, decision.protectedRanges ?? []);
+  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";
+    return {
+      voice: "gentle",
+      text: [
+        EFFICIENCY_NOTE,
+        "",
+        breakdownStr,
+        "",
+        `[TIER ${decision.tier} ${isT2 ? "DISTILLATION" : "CONDENSATION"} TRIGGER]`,
+        isT2 ? `Your tier-1 compression summaries have accumulated. Distill them into a single denser tier-2 summary. Use block IDs as boundaries.` : `Your tier-2 compression summaries have accumulated. Condense them further into a tier-3 ultra-condensed summary. Use block IDs as boundaries.`,
+        blockList,
+        `Example: compress({ content: [{ startId: "${startId}", endId: "${endId}", summary: "..." }] })`,
+        "",
+        HOW_TO_COMPRESS_RULES,
+        "",
+        isT2 ? TIER2_DISTILL_RULES : TIER3_CONDENSE_RULES
+      ].join("\n")
+    };
+  }
+  const isEmergency = !!decision.breakdown?.emergencyOverride;
+  if (isEmergency) {
+    return {
+      voice: "emergency",
+      text: [
+        EMERGENCY_HEADER,
+        "",
+        breakdownStr,
+        "",
+        HOW_TO_COMPRESS_RULES,
+        "",
+        `{ "topic": "...", "content": [{ "startId": "<ID>", "endId": "<ID>", "summary": "..." }] }`,
+        "Only use IDs from visible messages above. Compress older work first.",
+        "",
+        rangesStr
+      ].join("\n")
+    };
+  }
+  return {
+    voice: "gentle",
+    text: [
+      EFFICIENCY_NOTE,
+      "",
+      breakdownStr,
+      "",
+      HOW_TO_COMPRESS_RULES,
+      "",
+      rangesStr,
+      "",
+      `\u{1F4A1} Compress all ranges in one call (pass multiple content entries: \`content: [{...}, {...}]\`).`
+    ].join("\n")
+  };
+}
+function deactivateBlock(state, blockIds, options = {}) {
+  const targets = new Set(blockIds);
+  const updated = state.blocks.map((block) => {
+    if (!targets.has(block.blockId) || !block.active) return block;
+    return {
+      ...block,
+      active: false,
+      durationMs: block.durationMs,
+      createdAt: block.createdAt
+    };
+  });
+  let final = updated;
+  if (options.deep) {
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [];
+    for (const id of blockIds) {
+      const block = updated.find((b2) => b2.blockId === id);
+      if (block) queue.push(...block.directBlockIds);
+    }
+    while (queue.length > 0) {
+      const id = queue.shift();
+      if (visited.has(id)) continue;
+      visited.add(id);
+      final = final.map((block) => {
+        if (block.blockId !== id) return block;
+        queue.push(...block.directBlockIds);
+        return block.active ? { ...block, active: false } : block;
+      });
+    }
+  }
+  return { ...state, blocks: final };
+}
+function collectBlockContent(state, block, messages, options = {}) {
+  const full = options.full ?? false;
+  const targetIds = new Set(block.effectiveMessageIds);
+  if (full) {
+    const msgs = messages.filter((m2) => targetIds.has(m2.id));
+    if (msgs.length === 0) return { text: "", count: 0 };
+    return { text: msgs.map(formatMessage).join("\n\n"), count: msgs.length };
+  }
+  const nestedChildren = [];
+  const nestedCovered = /* @__PURE__ */ new Set();
+  for (const childId of block.directBlockIds) {
+    const child = state.blocks.find((b2) => b2.blockId === childId);
+    if (!child?.active) continue;
+    nestedChildren.push(child);
+    for (const id of child.effectiveMessageIds) nestedCovered.add(id);
+  }
+  const parts = [];
+  for (const child of nestedChildren) {
+    const label = child.topic ? `${child.blockId}: ${child.topic}` : child.blockId;
+    parts.push(`${SUMMARY_HEADER} \u2014 ${label}
+${child.summary}`);
+  }
+  let directCount = 0;
+  for (const m2 of messages) {
+    if (targetIds.has(m2.id) && !nestedCovered.has(m2.id)) {
+      parts.push(formatMessage(m2));
+      directCount++;
+    }
+  }
+  const count = directCount + nestedChildren.length;
+  if (count === 0) return { text: "", count: 0 };
+  return { text: parts.join("\n\n"), count };
+}
+function formatMessage(message) {
+  const text = message.text ?? "";
+  if (message.toolName && message.contentType !== "text") {
+    return `[${message.role} \u2022 ${message.toolName}]
+${text}`;
+  }
+  return `[${message.role}]
+${text}`;
+}
+function formatTokens2(n) {
+  if (!Number.isFinite(n) || n <= 0) return "0";
+  return n >= 1e3 ? `${(n / 1e3).toFixed(1)}K` : String(n);
+}
+function pct(n, total) {
+  if (n <= 0 || total <= 0) return 0;
+  return Math.max(1, Math.round(n / total * 100));
+}
+function numericPart2(blockId) {
+  const match = /^b(\d+)$/.exec(blockId);
+  return match && match[1] !== void 0 ? Number(match[1]) : 0;
+}
+function summaryTokensOf(block, countTokens) {
+  return countTokens(block.summary);
+}
+function effectiveCompressedTokens(block, _state, _countTokens) {
+  return block.compressedTokens;
+}
+function tierLabel(block) {
+  return `T${block.tier}`;
+}
+function tierBreakdown(blocks, countTokens) {
+  const tierTokens = {};
+  for (const block of blocks) {
+    tierTokens[block.tier] = (tierTokens[block.tier] ?? 0) + summaryTokensOf(block, countTokens);
+  }
+  const tiers = Object.keys(tierTokens).map(Number);
+  if (tiers.length <= 1) return null;
+  const parts = [];
+  for (const tier of [1, 2, 3]) {
+    if (tierTokens[tier]) parts.push(`T${tier}: ${formatTokens2(tierTokens[tier])}`);
+  }
+  return parts.join(" | ");
+}
+function collectVisible(messages, state, countTokens) {
+  const coveredIds = /* @__PURE__ */ new Set();
+  for (const block of state.blocks) {
+    if (!block.active) continue;
+    for (const id of block.effectiveMessageIds) coveredIds.add(id);
+  }
+  let summaryTokens = 0;
+  for (const block of state.blocks) {
+    if (block.active) summaryTokens += summaryTokensOf(block, countTokens);
+  }
+  const visible = [];
+  messages.forEach((message, index) => {
+    if (coveredIds.has(message.id)) return;
+    const ref = refForRaw(state.messageRefs, message.id);
+    if (!ref) return;
+    const tokens = countTokens(message.text ?? "");
+    const tool = message.toolName ?? "text";
+    if (tokens > 0) visible.push({ ref, tokens, tool, index });
+  });
+  return { visible, summaryTokens };
+}
+function buildStatusReport(state, messages, countTokens, options = {}) {
+  const scope = options.scope;
+  const view = options.view ?? "ranges";
+  const toolFilter = options.tool;
+  const sort = options.sort ?? "size";
+  const limit = options.limit ?? 30;
+  const activeBlocks2 = state.blocks.filter((b2) => b2.active).sort((a, b2) => numericPart2(a.blockId) - numericPart2(b2.blockId));
+  if (scope === "compressed") {
+    return renderCompressedDrilldown(activeBlocks2, state, sort, limit, countTokens);
+  }
+  const { visible, summaryTokens } = collectVisible(messages, state, countTokens);
+  if (scope === "uncompressed") {
+    if (view === "messages") {
+      return renderMessageDrilldown(visible, toolFilter, sort, limit);
+    }
+    return renderUncompressedRanges(visible);
+  }
+  return renderOverview(visible, summaryTokens, activeBlocks2, state, countTokens, limit);
+}
+function renderOverview(visible, summaryTokens, blocks, state, countTokens, limit) {
+  const lines = [];
+  const toolTypeMap = /* @__PURE__ */ new Map();
+  for (const message of visible) {
+    toolTypeMap.set(message.tool, (toolTypeMap.get(message.tool) ?? 0) + message.tokens);
+  }
+  const topTool = [...toolTypeMap.entries()].sort((a, b2) => b2[1] - a[1])[0]?.[0];
+  const totalTool = visible.filter((m2) => m2.tool !== "text").reduce((sum, m2) => sum + m2.tokens, 0);
+  const totalText = visible.filter((m2) => m2.tool === "text").reduce((sum, m2) => sum + m2.tokens, 0);
+  const total = summaryTokens + totalTool + totalText;
+  lines.push("CONTEXT BREAKDOWN");
+  lines.push(
+    `  ${formatTokens2(totalTool)} tool (${pct(totalTool, total)}%) | ${formatTokens2(totalText)} text (${pct(totalText, total)}%) | ${formatTokens2(summaryTokens)} summaries (${pct(summaryTokens, total)}%)`
+  );
+  const topTypes = [...toolTypeMap.entries()].sort((a, b2) => b2[1] - a[1]).slice(0, 3);
+  if (topTypes.length > 0) {
+    lines.push(`  Top tools: ${topTypes.map(([t, n]) => `${t} (${pct(n, total)}%)`).join(", ")}`);
+  }
+  lines.push("");
+  if (blocks.length === 0) {
+    lines.push("COMPRESSED BLOCKS");
+    lines.push("  No compressed blocks.");
+  } else {
+    const totalSummary = blocks.reduce((s3, b2) => s3 + summaryTokensOf(b2, countTokens), 0);
+    const totalEffective = blocks.reduce(
+      (s3, b2) => s3 + effectiveCompressedTokens(b2, state, countTokens),
+      0
+    );
+    lines.push(
+      `COMPRESSED BLOCKS \u2014 ${blocks.length} active (${formatTokens2(totalSummary)} summary, ${formatTokens2(totalEffective)} original)`
+    );
+    const breakdown = tierBreakdown(blocks, countTokens);
+    if (breakdown) lines.push(`  Tier usage: ${breakdown}`);
+    lines.push("");
+    const sorted = [...blocks].sort(
+      (a, b2) => effectiveCompressedTokens(b2, state, countTokens) - effectiveCompressedTokens(a, state, countTokens) || b2.createdAt - a.createdAt
+    );
+    for (const block of sorted.slice(0, limit)) {
+      const topic = block.topic ?? "(no topic)";
+      const eff = effectiveCompressedTokens(block, state, countTokens);
+      lines.push(
+        `  ${block.blockId} (${tierLabel(block)})  ${formatTokens2(eff)}\u2192${formatTokens2(summaryTokensOf(block, countTokens))}  ${block.effectiveMessageIds.length} msgs  "${topic}"`
+      );
+    }
+  }
+  lines.push("");
+  lines.push(
+    `Tip: buildStatusReport({scope:"uncompressed", view:"messages", tool:"${topTool ?? "bash"}"}) for per-message listing`
+  );
+  return lines.join("\n");
+}
+function renderUncompressedRanges(visible) {
+  const lines = [];
+  const totalTokens = visible.reduce((s3, m2) => s3 + m2.tokens, 0);
+  lines.push(`UNCOMPRESSED \u2014 ${formatTokens2(totalTokens)} | ${visible.length} visible messages`);
+  lines.push("");
+  if (visible.length === 0) {
+    lines.push("  (no uncompressed messages)");
+    return lines.join("\n");
+  }
+  const refNum2 = (ref) => {
+    const m2 = ref.match(/\d+/);
+    return m2 ? parseInt(m2[0], 10) : 0;
+  };
+  const merged = [];
+  for (const m2 of visible) {
+    const num = refNum2(m2.ref);
+    const last = merged[merged.length - 1];
+    if (last && num === last.startNum + last.count) {
+      last.endRef = m2.ref;
+      last.count += 1;
+      last.tokens += m2.tokens;
+    } else {
+      merged.push({ startRef: m2.ref, endRef: m2.ref, startNum: num, count: 1, tokens: m2.tokens, tool: m2.tool });
+    }
+  }
+  for (const r of merged.slice(0, 30)) {
+    const range = r.count === 1 ? r.startRef : `${r.startRef}\u2013${r.endRef}`;
+    lines.push(`  ${range}  (${r.count} msgs, ${formatTokens2(r.tokens)}${r.count > 1 ? ` (${Math.round(r.tokens / r.count)}/msg)` : ""}) ${r.tool}`);
+  }
+  if (merged.length > 30) {
+    lines.push(`  ... and ${merged.length - 30} more ranges`);
+  }
+  return lines.join("\n");
+}
+function renderMessageDrilldown(visible, toolFilter, sort, limit) {
+  let filtered = visible;
+  if (toolFilter) filtered = filtered.filter((m2) => m2.tool === toolFilter);
+  if (sort === "time") filtered.sort((a, b2) => a.index - b2.index);
+  else if (sort === "tool") filtered.sort((a, b2) => a.tool.localeCompare(b2.tool) || b2.tokens - a.tokens);
+  else filtered.sort((a, b2) => b2.tokens - a.tokens);
+  const totalTokens = filtered.reduce((s3, m2) => s3 + m2.tokens, 0);
+  const allTokens = visible.reduce((s3, m2) => s3 + m2.tokens, 0);
+  const header = toolFilter ? `UNCOMPRESSED \u2014 ${toolFilter}: ${formatTokens2(totalTokens)} | ${filtered.length} msgs | ${pct(totalTokens, allTokens)}% of visible` : `UNCOMPRESSED \u2014 ${formatTokens2(totalTokens)} | ${filtered.length} msgs`;
+  const lines = [header, `Sorted by ${sort}`, ""];
+  const shown = filtered.slice(0, limit);
+  for (const message of shown) {
+    lines.push(`  ${message.ref} (${formatTokens2(message.tokens)}) ${message.tool}`);
+  }
+  if (filtered.length > shown.length) {
+    lines.push("");
+    lines.push(`${shown.length} of ${filtered.length} shown.`);
+  }
+  return lines.join("\n");
+}
+function renderCompressedDrilldown(blocks, state, sort, limit, countTokens) {
+  let sorted = [...blocks];
+  if (sort === "time") sorted.sort((a, b2) => a.createdAt - b2.createdAt);
+  else if (sort === "age") sorted.sort((a, b2) => b2.survivedCount - a.survivedCount);
+  else
+    sorted.sort(
+      (a, b2) => effectiveCompressedTokens(b2, state, countTokens) - effectiveCompressedTokens(a, state, countTokens) || b2.createdAt - a.createdAt
+    );
+  const totalSummary = sorted.reduce((s3, b2) => s3 + summaryTokensOf(b2, countTokens), 0);
+  const totalEffective = sorted.reduce(
+    (s3, b2) => s3 + effectiveCompressedTokens(b2, state, countTokens),
+    0
+  );
+  const lines = [
+    `COMPRESSED \u2014 ${sorted.length} blocks | ${formatTokens2(totalEffective)} original \u2192 ${formatTokens2(totalSummary)} summary`
+  ];
+  const breakdown = tierBreakdown(sorted, countTokens);
+  if (breakdown) lines.push(`Tier usage: ${breakdown}`);
+  lines.push("");
+  const shown = sorted.slice(0, limit);
+  for (const block of shown) {
+    const nested = block.directBlockIds.length > 0 ? ` nested=[${block.directBlockIds.join(",")}]` : "";
+    const topic = block.topic ?? "(no topic)";
+    const eff = effectiveCompressedTokens(block, state, countTokens);
+    lines.push(
+      `  ${block.blockId} (${tierLabel(block)})  ${formatTokens2(eff)}\u2192${formatTokens2(summaryTokensOf(block, countTokens))}  ${block.effectiveMessageIds.length} msgs  age=${block.survivedCount} ${block.generation}${nested}`
+    );
+    lines.push(`    "${topic}"`);
+  }
+  if (sorted.length > shown.length) {
+    lines.push("");
+    lines.push(`${shown.length} of ${sorted.length} shown.`);
+  }
+  return lines.join("\n");
+}
+var substringAlgorithm = {
+  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 += countOccurrences2(haystack, term);
+      return { ref: d.ref, score };
+    });
+  }
+};
+function countOccurrences2(haystack, needle) {
+  if (!needle) return 0;
+  return haystack.split(needle).length - 1;
+}
+function stem(word) {
+  let w2 = word;
+  if (w2.length <= 3) return w2;
+  if (w2.endsWith("ies")) w2 = w2.slice(0, -3) + "y";
+  else if (w2.endsWith("ses") || w2.endsWith("xes") || w2.endsWith("zes")) w2 = w2.slice(0, -2);
+  else if (w2.endsWith("ches") || w2.endsWith("shes")) w2 = w2.slice(0, -2);
+  else if (w2.endsWith("s") && !w2.endsWith("ss")) w2 = w2.slice(0, -1);
+  if (w2.endsWith("ing") && w2.length > 5) w2 = w2.slice(0, -3);
+  if (w2.endsWith("ed") && w2.length > 4) w2 = w2.slice(0, -2);
+  if (w2.endsWith("ation") && w2.length > 6) w2 = w2.slice(0, -3);
+  else if (w2.endsWith("tion") && w2.length > 5) w2 = w2.slice(0, -4) + "t";
+  else if (w2.endsWith("ion") && w2.length > 4) w2 = w2.slice(0, -3);
+  if (w2.endsWith("ment") && w2.length > 6) w2 = w2.slice(0, -4);
+  if (w2.endsWith("ness") && w2.length > 6) w2 = w2.slice(0, -4);
+  if (w2.endsWith("ly") && w2.length > 4) w2 = w2.slice(0, -2);
+  return w2;
+}
+var CJK = /[\u3400-\u9fff\uf900-\ufaff\u3040-\u30ff\uac00-\ud7af]/;
+var CJK_RUN = new RegExp(`${CJK.source}+`, "g");
+var LATIN_WORD = /[a-z][a-z0-9_]*[a-z0-9]|[a-z0-9]/g;
+function tokenize(text, opts = {}) {
+  const lower = text.toLowerCase();
+  const tokens = [];
+  const latin = lower.match(LATIN_WORD) ?? [];
+  for (let w2 of latin) {
+    if (w2.length >= 2) {
+      if (opts.stem) w2 = stem(w2);
+      tokens.push(w2);
+    }
+  }
+  const cjkRuns = lower.match(CJK_RUN) ?? [];
+  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 charBigrams(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 tfMap(text, stem2) {
+  const m2 = /* @__PURE__ */ new Map();
+  for (const t of tokenize(text, { stem: stem2 })) m2.set(t, (m2.get(t) ?? 0) + 1);
+  return m2;
+}
+var bm25Algorithm = {
+  name: "bm25",
+  description: "BM25 with stemming + CJK bigram tokenization. IR-standard relevance ranking.",
+  score(docs, query) {
+    const N2 = docs.length;
+    const k1 = 1.2;
+    const b2 = 0.75;
+    const parsed = docs.map((d) => {
+      const text = d.text;
+      const tf = tfMap(text, true);
+      let len = 0;
+      for (const v2 of tf.values()) len += v2;
+      return { id: d.ref, tf, len };
+    });
+    const avgdl = parsed.reduce((s3, d) => s3 + d.len, 0) / (N2 || 1);
+    const qTerms = tokenize(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 + (N2 - df + 0.5) / (df + 0.5)));
+    }
+    return parsed.map((d) => {
+      let score = 0;
+      for (const t of qTerms) {
+        const f2 = d.tf.get(t) ?? 0;
+        if (f2 === 0) continue;
+        const idfT = idf.get(t) ?? 0;
+        score += idfT * (f2 * (k1 + 1)) / (f2 + k1 * (1 - b2 + b2 * d.len / (avgdl || 1)));
+      }
+      return { ref: d.id, score };
+    });
+  }
+};
+var fuzzyAlgorithm = {
+  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 g2 of charBigrams(t)) qGrams.add(g2);
+    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(charBigrams(haystack));
+      let hits = 0;
+      for (const g2 of qGrams) if (docGrams.has(g2)) hits++;
+      return { ref: d.ref, score: hits / qGrams.size };
+    });
+  }
+};
+var W_BM25 = 0.7;
+var W_FUZZY = 0.3;
+var hybridAlgorithm = {
+  name: "hybrid",
+  description: "Weighted BM25(stem) + fuzzy n-gram. Default \u2014 best precision + recall.",
+  score(docs, query) {
+    const bm = bm25Algorithm.score(docs, query);
+    const fz = fuzzyAlgorithm.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_BM25 * (bmMap.get(d.ref) ?? 0) + W_FUZZY * (fzMap.get(d.ref) ?? 0)
+    }));
+  }
+};
+var registry2 = /* @__PURE__ */ new Map();
+function registerSearchAlgorithm(algo) {
+  registry2.set(algo.name, algo);
+}
+registerSearchAlgorithm(substringAlgorithm);
+registerSearchAlgorithm(bm25Algorithm);
+registerSearchAlgorithm(fuzzyAlgorithm);
+registerSearchAlgorithm(hybridAlgorithm);
+
 // src/config.ts
-import { defaultConfig } from "acp-kernel";
 import { readFileSync, existsSync, mkdirSync as mkdirSync2, writeFileSync } from "fs";
 import { dirname } from "path";
 
@@ -18191,7 +20462,6 @@ function parseRouteEntry(v2) {
 import http from "http";
 import fs3 from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { createCore, renderNudgeText, deactivateBlock as deactivateBlock4 } from "acp-kernel";
 
 // src/registry.ts
 import { readFile, writeFile, mkdir } from "fs/promises";
@@ -18409,19 +20679,32 @@ function anthropicToCore(body) {
             role: "tool",
             contentType: "tool-result",
             toolCallId: b2.tool_use_id,
-            text
+            text,
+            ...b2.is_error === true ? { toolIsError: true } : {}
           });
           if (b2.cache_control) cacheControls.set(id, b2.cache_control);
           break;
         }
         case "thinking": {
           const base = deriveMessageId("assistant", "reasoning", b2.thinking);
-          msgs.push({ id: clusters.next(base), role: "assistant", contentType: "reasoning", text: b2.thinking });
+          msgs.push({
+            id: clusters.next(base),
+            role: "assistant",
+            contentType: "reasoning",
+            text: b2.thinking,
+            ...b2.signature ? { thinkingSignature: b2.signature } : {}
+          });
           break;
         }
         case "image": {
           const base = deriveMessageId(m2.role, "text", "[image]");
-          msgs.push({ id: clusters.next(base), role: m2.role, contentType: "text", text: "[image]" });
+          msgs.push({
+            id: clusters.next(base),
+            role: m2.role,
+            contentType: "text",
+            text: "[image]",
+            rawAnthropicBlock: b2
+          });
           break;
         }
       }
@@ -18449,9 +20732,14 @@ function coreToAnthropic(messages, cacheControls) {
       current = { role: target, blocks: [] };
     }
     switch (m2.contentType) {
-      case "text":
+      case "text": {
+        if (m2.rawAnthropicBlock) {
+          current.blocks.push(m2.rawAnthropicBlock);
+          break;
+        }
         current.blocks.push({ type: "text", text: m2.text ?? "", ...cc(m2.id) });
         break;
+      }
       case "tool-call":
         current.blocks.push({
           type: "tool_use",
@@ -18466,11 +20754,16 @@ function coreToAnthropic(messages, cacheControls) {
           type: "tool_result",
           tool_use_id: m2.toolCallId ?? "",
           content: m2.text ?? "",
+          ...m2.toolIsError ? { is_error: true } : {},
           ...cc(m2.id)
         });
         break;
       case "reasoning":
-        current.blocks.push({ type: "thinking", thinking: m2.text ?? "" });
+        current.blocks.push({
+          type: "thinking",
+          thinking: m2.text ?? "",
+          ...m2.thinkingSignature ? { signature: m2.thinkingSignature } : {}
+        });
         break;
     }
   }
@@ -18499,6 +20792,13 @@ function safeParse(s3) {
   }
 }
 
+// src/bili-message.ts
+function parseDataUrl(url) {
+  const m2 = /^data:([^;,]+)(?:;base64)?,(.+)$/i.exec(url);
+  if (!m2) return void 0;
+  return { mediaType: m2[1], base64: m2[2] };
+}
+
 // src/openai.ts
 function openaiToCore(body) {
   const msgs = [];
@@ -18508,12 +20808,20 @@ function openaiToCore(body) {
       case "system":
       case "developer": {
         const base = deriveMessageId(m2.role, "text", stringContent(m2.content));
-        msgs.push({ id: clusters.next(base), role: "system", contentType: "text", text: stringContent(m2.content) });
+        msgs.push({ id: clusters.next(base), role: "system", contentType: "text", text: stringContent(m2.content), originalRole: m2.role });
         break;
       }
       case "user": {
-        const base = deriveMessageId("user", "text", stringContent(m2.content));
-        msgs.push({ id: clusters.next(base), role: "user", contentType: "text", text: stringContent(m2.content) });
+        const text = stringContent(m2.content);
+        const img = firstImagePart(m2.content);
+        const base = deriveMessageId("user", "text", text);
+        msgs.push({
+          id: clusters.next(base),
+          role: "user",
+          contentType: "text",
+          text,
+          ...img ? { rawOpenaiContent: img.part, imageMediaType: img.mediaType, imageBase64: img.base64 } : {}
+        });
         break;
       }
       case "assistant": {
@@ -18588,9 +20896,20 @@ function coreToOpenai(messages) {
     } else {
       flush();
       if (m2.role === "system") {
-        out.push({ role: "system", content: m2.text ?? "" });
+        out.push({ role: m2.originalRole === "developer" ? "developer" : "system", content: m2.text ?? "" });
       } else if (m2.role === "user") {
-        out.push({ role: "user", content: m2.text ?? "" });
+        if (m2.rawOpenaiContent || m2.imageBase64) {
+          const parts = [];
+          if (m2.text) parts.push({ type: "text", text: m2.text });
+          if (m2.rawOpenaiContent) {
+            parts.push(m2.rawOpenaiContent);
+          } else if (m2.imageBase64 && m2.imageMediaType) {
+            parts.push({ type: "image_url", image_url: { url: `data:${m2.imageMediaType};base64,${m2.imageBase64}` } });
+          }
+          out.push({ role: "user", content: parts });
+        } else {
+          out.push({ role: "user", content: m2.text ?? "" });
+        }
       } else if (m2.role === "tool") {
         out.push({ role: "tool", tool_call_id: m2.toolCallId ?? "", content: m2.text ?? "" });
       }
@@ -18628,6 +20947,20 @@ function stringContent(content) {
   }
   return "";
 }
+function firstImagePart(content) {
+  if (!Array.isArray(content)) return void 0;
+  for (const p2 of content) {
+    if (p2 && typeof p2 === "object" && p2.type === "image_url") {
+      const iu = p2.image_url;
+      const url = iu?.url;
+      if (typeof url === "string") {
+        const parsed = parseDataUrl(url);
+        if (parsed) return { part: p2, mediaType: parsed.mediaType, base64: parsed.base64 };
+      }
+    }
+  }
+  return void 0;
+}
 
 // src/responses.ts
 var OPAQUE_ITEM_TYPES = /* @__PURE__ */ new Set([
@@ -18657,6 +20990,20 @@ function messageContent(c) {
   if (Array.isArray(c)) return c.map(partText).join("\n");
   return "";
 }
+function findInputImage(c) {
+  if (!Array.isArray(c)) return void 0;
+  for (const p2 of c) {
+    if (p2 && typeof p2 === "object" && p2.type === "input_image") {
+      const url = p2.image_url;
+      if (typeof url === "string") {
+        const parsed = parseDataUrl(url);
+        if (parsed) return { mediaType: parsed.mediaType, base64: parsed.base64 };
+      }
+      return {};
+    }
+  }
+  return void 0;
+}
 function responsesToCore(body) {
   const msgs = [];
   const systemParts = [];
@@ -18686,8 +21033,18 @@ function responsesToCore(body) {
         if (m2.role === "system" || m2.role === "developer") {
           systemParts.push(text);
         } else if (m2.role === "user") {
+          const img = findInputImage(m2.content);
           const base = deriveMessageId("user", "text", text);
-          msgs.push({ id: clusters.next(base), role: "user", contentType: "text", text });
+          msgs.push({
+            id: clusters.next(base),
+            role: "user",
+            contentType: "text",
+            text,
+            ...img ? {
+              rawResponsesItem: it2,
+              ...img.mediaType && img.base64 ? { imageMediaType: img.mediaType, imageBase64: img.base64 } : {}
+            } : {}
+          });
           idx++;
         } else if (m2.role === "assistant") {
           if (text) {
@@ -18778,7 +21135,11 @@ function coreToResponses(messages, customToolCallIds = /* @__PURE__ */ new Set()
     if (m2.role === "system") {
       out.push({ type: "message", role: "developer", content: m2.text ?? "" });
     } else if (m2.role === "user") {
-      out.push({ type: "message", role: "user", content: m2.text ?? "" });
+      if (m2.rawResponsesItem) {
+        out.push(m2.rawResponsesItem);
+      } else {
+        out.push({ type: "message", role: "user", content: m2.text ?? "" });
+      }
     } else if (m2.role === "assistant") {
       if (m2.contentType === "text") {
         out.push({ type: "message", role: "assistant", content: m2.text ?? "" });
@@ -18840,15 +21201,11 @@ function conversationSignalResponses(body, headerValue2) {
   return hashId(seed);
 }
 
-// src/session.ts
-import { createInitialState as createInitialState2 } from "acp-kernel";
-
 // src/persist.ts
 import { promises as fs } from "fs";
 import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync2, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
 import { createHash as createHash2 } from "crypto";
 import * as path4 from "path";
-import { createInitialState } from "acp-kernel";
 var PERSIST_VERSION = 2;
 function mergeState(parsed) {
   const fresh = createInitialState();
@@ -18886,6 +21243,12 @@ var SessionStore = class {
   /** Monotonic counter for unique temp filenames within a process. */
   tmpSeq = 0;
   log;
+  /** Per-session write serialization chain. Each writeNow/flushSync chains
+   *  onto the previous write for the SAME session, so two concurrent writes
+   *  to the same session never race on fs.rename (Windows: EPERM/EBUSY when
+   *  two renames target the same file). The promise resolves when this
+   *  session's write queue is fully drained. */
+  writeChains = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.dir = opts?.dir ?? defaultDir();
     this.debounceMs = opts?.debounceMs ?? defaultDebounce();
@@ -18989,8 +21352,21 @@ var SessionStore = class {
     this.timers.set(session.id, timer2);
   }
   /** Asynchronously persist a session right now (skips the debounce). Throws
-   *  on write failure so callers can react (e.g. avoid evicting). */
+   *  on write failure so callers can react (e.g. avoid evicting). Serialized
+   *  per-session via writeChains so concurrent writes don't race on rename. */
   async writeNow(session) {
+    if (!this.enabled) return;
+    const id = session.id;
+    const prev = this.writeChains.get(id) ?? Promise.resolve();
+    const next = prev.catch(() => {
+    }).then(() => this.writeNowInner(session));
+    this.writeChains.set(id, next);
+    next.finally(() => {
+      if (this.writeChains.get(id) === next) this.writeChains.delete(id);
+    });
+    return next;
+  }
+  async writeNowInner(session) {
     if (!this.enabled) return;
     const record = buildRecord(session);
     const file = this.filePath(session.id, session.meta.protocol, session.meta.upstreamOrigin);
@@ -19003,7 +21379,7 @@ var SessionStore = class {
     const data = JSON.stringify(record);
     try {
       await fs.writeFile(tmp, data, "utf8");
-      await fs.rename(tmp, file);
+      await renameWithRetry(tmp, file);
     } catch (e) {
       try {
         await fs.unlink(tmp).catch(() => {
@@ -19028,6 +21404,7 @@ var SessionStore = class {
     }
     const record = buildRecord(session);
     const file = this.filePath(session.id, session.meta.protocol, session.meta.upstreamOrigin);
+    const data = JSON.stringify(record);
     try {
       mkdirSync3(path4.dirname(file), { recursive: true });
     } catch (e) {
@@ -19035,8 +21412,21 @@ var SessionStore = class {
     }
     const tmp = this.tempPath(session.id);
     try {
-      writeFileSync2(tmp, JSON.stringify(record), "utf8");
-      renameSync2(tmp, file);
+      writeFileSync2(tmp, data, "utf8");
+      let lastErr;
+      for (let attempt = 0; attempt < 3; attempt++) {
+        try {
+          renameSync2(tmp, file);
+          lastErr = void 0;
+          break;
+        } catch (e) {
+          lastErr = e;
+          const code = e.code;
+          if (code !== "EPERM" && code !== "EBUSY" && code !== "EACCES") break;
+          Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20 * (attempt + 1));
+        }
+      }
+      if (lastErr) throw lastErr;
       return true;
     } catch (e) {
       this.log("error", `[persist] flushSync FAILED for ${session.id}: ${msg(e)} \u2014 session NOT evicted to prevent loss`);
@@ -19131,6 +21521,21 @@ function isValidRecord(parsed) {
 function msg(e) {
   return e instanceof Error ? e.message : String(e);
 }
+async function renameWithRetry(src, dest) {
+  let lastErr;
+  for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+      await fs.rename(src, dest);
+      return;
+    } catch (e) {
+      lastErr = e;
+      const code = e.code;
+      if (code !== "EPERM" && code !== "EBUSY" && code !== "EACCES") throw e;
+      await new Promise((r) => setTimeout(r, 20 * (attempt + 1)));
+    }
+  }
+  throw lastErr;
+}
 function defaultDir() {
   return sessionsDir();
 }
@@ -19201,7 +21606,7 @@ function getSession(id, meta) {
     meta: { protocol: meta?.protocol, upstreamOrigin: meta?.upstreamOrigin, label: meta?.label },
     stats: { requests: 0, tokensSaved: 0, inputTokens: 0, cachedTokens: 0, outputTokens: 0, cacheSamples: 0, lastInputTokens: 0, contextTokens: 0 },
     metadata: {},
-    state: createInitialState2(),
+    state: createInitialState(),
     createdAt: Date.now(),
     lastSeen: Date.now(),
     blockContents: /* @__PURE__ */ new Map(),
@@ -19263,7 +21668,6 @@ async function flushAllSessions() {
 }
 
 // src/compress-tool.ts
-import { COMPRESS_PHILOSOPHY, HOW_TO_COMPRESS_RULES } from "acp-kernel";
 var COMPRESS_TOOL_NAME = "compress";
 var ACP_TEXT_OPEN = "<acp_compress>";
 var ACP_TEXT_CLOSE = "</acp_compress>";
@@ -19484,14 +21888,7 @@ var PROXY_TOOL_NAMES = /* @__PURE__ */ new Set([
   ACP_STATUS_TOOL_NAME
 ]);
 
-// src/stream.ts
-import { buildStatusReport, collectBlockContent as collectBlockContent2, estimateTokensFast } from "acp-kernel";
-
 // src/decompress-shared.ts
-import {
-  collectBlockContent,
-  deactivateBlock
-} from "acp-kernel";
 import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
 import { dirname as dirname3, join as join2 } from "path";
 import { tmpdir } from "os";
@@ -19597,8 +21994,8 @@ function applyRanges(ranges, ctx) {
     ctx.session.state = res.state;
     for (const b2 of res.state.blocks) {
       if (beforeIds.has(b2.blockId)) continue;
-      const full = collectBlockContent2(res.state, b2, ctx.messages, { full: true });
-      const one = collectBlockContent2(res.state, b2, ctx.messages, { full: false });
+      const full = collectBlockContent(res.state, b2, ctx.messages, { full: true });
+      const one = collectBlockContent(res.state, b2, ctx.messages, { full: false });
       if (full.count > 0 || one.count > 0) {
         cacheBlockContent(ctx.session, b2.blockId, {
           one: { text: one.text, count: one.count },
@@ -20115,10 +22512,6 @@ function reapOrphanBlocks(session, visible, deactivate) {
 }
 
 // src/compress-loop.ts
-import {
-  buildStatusReport as buildStatusReport2,
-  estimateTokensFast as estimateTokensFast2
-} from "acp-kernel";
 function executeProxyTool(toolName, args, ctx) {
   if (toolName === "compress") {
     return applyRanges(parseCompressInput(args), ctx);
@@ -20143,7 +22536,7 @@ function executeProxyTool(toolName, args, ctx) {
 ${lines.join("\n\n")}`;
   }
   if (toolName === "acp_status") {
-    return buildStatusReport2(ctx.session.state, ctx.messages, estimateTokensFast2);
+    return buildStatusReport(ctx.session.state, ctx.messages, estimateTokensFast);
   }
   return `[Unknown proxy tool: ${toolName}]`;
 }
@@ -20476,10 +22869,6 @@ async function* compressLoopStream(initialUpstream, ctx, requestBody, requestOpt
 }
 
 // src/compress-loop-anthropic.ts
-import {
-  buildStatusReport as buildStatusReport3,
-  estimateTokensFast as estimateTokensFast3
-} from "acp-kernel";
 function executeProxyTool2(toolName, args, ctx) {
   if (toolName === "compress") {
     return applyRanges(parseCompressInput(args), ctx);
@@ -20504,7 +22893,7 @@ function executeProxyTool2(toolName, args, ctx) {
 ${lines.join("\n\n")}`;
   }
   if (toolName === "acp_status") {
-    return buildStatusReport3(ctx.session.state, ctx.messages, estimateTokensFast3);
+    return buildStatusReport(ctx.session.state, ctx.messages, estimateTokensFast);
   }
   return `[Unknown proxy tool: ${toolName}]`;
 }
@@ -20779,10 +23168,6 @@ function routeAnthropicEvent(eventStr, isFirstRound, state, cb) {
 }
 
 // src/compress-loop-responses.ts
-import {
-  buildStatusReport as buildStatusReport4,
-  estimateTokensFast as estimateTokensFast4
-} from "acp-kernel";
 var TEXT_PROTOCOL = process.env.ACP_COMPRESS_PROTOCOL === "text";
 function extractTextTriggers(text) {
   const calls = [];
@@ -20840,7 +23225,7 @@ function executeProxyTool3(toolName, args, ctx) {
 ${lines.join("\n\n")}`;
   }
   if (toolName === "acp_status") {
-    return buildStatusReport4(ctx.session.state, ctx.messages, estimateTokensFast4);
+    return buildStatusReport(ctx.session.state, ctx.messages, estimateTokensFast);
   }
   return `[Unknown proxy tool: ${toolName}]`;
 }
@@ -21347,9 +23732,9 @@ data: ${JSON.stringify({ type: "message_stop" })}
 // src/session-id.ts
 function extractKey(headers) {
   const auth = headers["authorization"];
-  if (typeof auth === "string" && auth.length > 0) return auth.trim().toLowerCase();
+  if (typeof auth === "string" && auth.length > 0) return auth.trim();
   const apiKey = headers["x-api-key"];
-  if (typeof apiKey === "string" && apiKey.length > 0) return `key:${apiKey.trim().toLowerCase()}`;
+  if (typeof apiKey === "string" && apiKey.length > 0) return `key:${apiKey.trim()}`;
   return "(no-key)";
 }
 function clientConversationHeader(headers) {
@@ -21672,7 +24057,17 @@ async function startServer(opts) {
   }
   return server;
 }
+function isLoopback(addr) {
+  if (!addr) return false;
+  return addr === "::1" || addr === "127.0.0.1" || addr.startsWith("127.") || addr.startsWith("::ffff:127.");
+}
 async function handle(req, res, opts, core, config, log2) {
+  const isAdminPath = req.url === "/__bili/" || req.url?.startsWith("/__bili/") || req.url === "/__acp/" || req.url?.startsWith("/__acp/");
+  if (isAdminPath && !isLoopback(req.socket.remoteAddress)) {
+    res.writeHead(403, { "content-type": "application/json" });
+    res.end(JSON.stringify({ error: "management endpoints are loopback-only; access denied for " + (req.socket.remoteAddress ?? "unknown") }));
+    return;
+  }
   if (req.method === "GET" && req.url === "/__bili/stats") return sendStats(res);
   if (req.method === "GET" && req.url === "/") {
     const accept = req.headers.accept ?? "";
@@ -21791,14 +24186,14 @@ function diagNudge(turn, sessionId, tokenCount, limit) {
   const n = turn.nudge;
   if (!n) return `[${sessionId}] nudge: unavailable`;
   const b2 = n.breakdown ?? {};
-  const pct = limit > 0 ? `${Math.round(tokenCount / limit * 100)}%` : "?";
+  const pct2 = limit > 0 ? `${Math.round(tokenCount / limit * 100)}%` : "?";
   const growth = b2["growth"] ?? 0;
   const floor = b2["growthFloor"] ?? 0;
   const interval = b2["nudgeGrowthTokens"] ?? 0;
   const pendingT1 = b2["pendingT1"] ?? 0;
   const ref = b2["growthReference"] ?? 0;
   const inject = n.shouldInject ? `INJECT T${n.tier ?? "?"}` : "idle";
-  return `[${sessionId}] nudge ${inject}: usage=${pct} (${tokenCount}/${limit}), growth=${growth}/${floor} (ref=${ref}, interval=${interval}), pendingT1=${pendingT1}/${interval}, reason="${n.reason.slice(0, 120)}"`;
+  return `[${sessionId}] nudge ${inject}: usage=${pct2} (${tokenCount}/${limit}), growth=${growth}/${floor} (ref=${ref}, interval=${interval}), pendingT1=${pendingT1}/${interval}, reason="${n.reason.slice(0, 120)}"`;
 }
 function prepareAnthropic(parsed, req, opts, core, config, log2, session) {
   const sessionId = session.id;
@@ -21824,7 +24219,7 @@ function prepareAnthropic(parsed, req, opts, core, config, log2, session) {
     log2("info", diagTagSummary(turn.messages, sessionId, "text-only"));
     log2("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit));
     processedMessages = turn.messages;
-    reapOrphanBlocks(session, msgs, deactivateBlock4);
+    reapOrphanBlocks(session, msgs, deactivateBlock);
     rebuiltMessages = coreToAnthropic(processedMessages, cacheControls);
     systemOut = injectSystem(parsed, opts);
     if (opts.compress.injectTool) {
@@ -21872,7 +24267,7 @@ function prepareOpenai(parsed, req, opts, core, config, log2, session) {
     log2("info", diagTagSummary(turn.messages, sessionId, "text-only"));
     log2("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit));
     processedMessages = turn.messages;
-    reapOrphanBlocks(session, msgs, deactivateBlock4);
+    reapOrphanBlocks(session, msgs, deactivateBlock);
     rebuiltMessages = coreToOpenai(processedMessages);
     const sysParts = [];
     if (shouldInject) sysParts.push(buildCompressSystemPrompt());
@@ -21927,7 +24322,7 @@ function prepareResponses(parsed, req, opts, core, config, log2, session) {
     log2("info", diagTagSummary(turn.messages, sessionId, "text-only"));
     log2("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit));
     processedMessages = turn.messages;
-    reapOrphanBlocks(session, msgs, deactivateBlock4);
+    reapOrphanBlocks(session, msgs, deactivateBlock);
     const conversationItems = coreToResponses(processedMessages, customToolCallIds);
     if (preamble.length > 0) {
       log2("info", `[${sessionId}] preserved ${preamble.length} opaque preamble item(s): ${preamble.map((p2) => p2.type).join(",")}`);
@@ -22324,7 +24719,7 @@ function logMsg(opts, level, msg2) {
 }
 
 // src/update.ts
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, access, constants, rm, cp } from "fs/promises";
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, access, constants, rm, cp, unlink } from "fs/promises";
 
 // node_modules/tar/dist/esm/index.min.js
 import Qr from "events";
@@ -25386,6 +27781,15 @@ async function tryAcquireLock() {
       return null;
     }
     log("info", `[update] stealing stale lock (pid=${existing.pid}, age=${Math.round(age / 1e3)}s, alive=${holderAlive})`);
+    try {
+      await unlink(LOCK_FILE);
+    } catch (e) {
+      const code = e.code;
+      if (code !== "ENOENT") {
+        log("warn", `[update] could not remove stale lock: ${e.message}`);
+        return null;
+      }
+    }
   }
   try {
     await writeFile2(LOCK_FILE, JSON.stringify({ pid, ts: now }), { flag: "wx" });