billion-context-pi 0.1.36 → 0.1.37

package/dist/index.js

@@ -132,9 +132,11 @@ function prune(messages, state, options = {}) {
   const indexById = /* @__PURE__ */ new Map();
   messages.forEach((message, index) => indexById.set(message.id, index));
   const anchors = inject ? collectSummaryAnchors(state, indexById) : [];
-  return stripOrphanedToolResults(
-    stripOrphanedToolCalls(
-      rebuildMessages(messages, covered, firstUserIndex, anchors)
+  return stripOrphanedReasoning(
+    stripOrphanedToolResults(
+      stripOrphanedToolCalls(
+        rebuildMessages(messages, covered, firstUserIndex, anchors)
+      )
     )
   );
 }
@@ -211,6 +213,24 @@ function stripOrphanedToolCalls(messages) {
     (m) => m.contentType !== "tool-call" || !m.toolCallId || m.toolName === "compress" || knownResultIds.has(m.toolCallId)
   );
 }
+function stripOrphanedReasoning(messages) {
+  const drop = /* @__PURE__ */ new Set();
+  for (let i = 0; i < messages.length; i++) {
+    if (drop.has(i)) continue;
+    if (messages[i].contentType !== "reasoning") continue;
+    let j = i;
+    while (j + 1 < messages.length && messages[j + 1].contentType === "reasoning") {
+      j++;
+    }
+    const companion = messages[j + 1];
+    const hasCompanion = companion !== void 0 && companion.role === "assistant" && (companion.contentType === "text" || companion.contentType === "tool-call");
+    if (!hasCompanion) {
+      for (let k = i; k <= j; k++) drop.add(k);
+    }
+  }
+  if (drop.size === 0) return messages;
+  return messages.filter((_, i) => !drop.has(i));
+}
 function syncBlocks(messages, state) {
   const presentIds = new Set(messages.map((message) => message.id));
   const deactivated = [];
@@ -343,6 +363,18 @@ function parseBoundary(ref) {
   }
   return null;
 }
+var BoundaryNotFoundError = class extends Error {
+  code = "BOUNDARY_NOT_FOUND";
+  kind;
+  endpoint;
+  constructor(kind, endpoint, message) {
+    super(message);
+    this.name = "BoundaryNotFoundError";
+    this.code = "BOUNDARY_NOT_FOUND";
+    this.kind = kind;
+    this.endpoint = endpoint;
+  }
+};
 function resolveBoundaries(input) {
   const start = parseBoundary(input.startRef);
   const end = parseBoundary(input.endRef);
@@ -355,13 +387,8 @@ function resolveBoundaries(input) {
   input.messages.forEach(
     (message, index) => indexByRawId.set(message.id, index)
   );
-  let startIndex = resolveAnchorIndex(start, input.state, indexByRawId);
-  let endIndex = resolveAnchorIndex(end, input.state, indexByRawId);
-  if (startIndex === null || endIndex === null) {
-    throw new Error(
-      `Boundary not found in visible context (likely consumed by an existing block). startId="${input.startRef}", endId="${input.endRef}".`
-    );
-  }
+  let startIndex = resolveAnchorIndex(start, input.state, indexByRawId, "start");
+  let endIndex = resolveAnchorIndex(end, input.state, indexByRawId, "end");
   if (startIndex > endIndex) {
     [startIndex, endIndex] = [endIndex, startIndex];
   }
@@ -392,16 +419,51 @@ function resolveBoundaries(input) {
     protectedGaps
   };
 }
-function resolveAnchorIndex(boundary, state, indexByRawId) {
+function resolveAnchorIndex(boundary, state, indexByRawId, endpoint) {
+  const label = endpoint === "start" ? "startId" : "endId";
   if (boundary.kind === "message") {
     const rawId = state.messageRefs.byRef[boundary.raw] ?? state.messageRefs.byRef[formatPaddedRef(boundary.numericId)];
-    if (!rawId) return null;
+    if (!rawId) {
+      throw new BoundaryNotFoundError(
+        "unknown",
+        endpoint,
+        `${label}="${boundary.raw}" does not exist in this session (typo or wrong session) \u2014 run acp_status for current refs.`
+      );
+    }
     const index = indexByRawId.get(rawId);
-    return index === void 0 ? null : index;
+    if (index === void 0) {
+      throw new BoundaryNotFoundError(
+        "consumed",
+        endpoint,
+        `${label}="${boundary.raw}" not found in visible context (likely consumed by an existing block).`
+      );
+    }
+    return index;
   }
   const block = blockById(state, `b${boundary.numericId}`);
-  if (!block || !block.active) return null;
-  return earliestIndexOfIds(block.effectiveMessageIds, indexByRawId);
+  if (!block) {
+    throw new BoundaryNotFoundError(
+      "unknown",
+      endpoint,
+      `${label}="b${boundary.numericId}" does not exist in this session (typo or wrong session) \u2014 run acp_status for current refs.`
+    );
+  }
+  if (!block.active) {
+    throw new BoundaryNotFoundError(
+      "consumed",
+      endpoint,
+      `${label}="b${boundary.numericId}" not found in visible context (block distilled/consumed by a higher-tier block).`
+    );
+  }
+  const anchor = earliestIndexOfIds(block.effectiveMessageIds, indexByRawId);
+  if (anchor === null) {
+    throw new BoundaryNotFoundError(
+      "consumed",
+      endpoint,
+      `${label}="b${boundary.numericId}" not found in visible context (block messages consumed by a higher-tier block).`
+    );
+  }
+  return anchor;
 }
 function formatPaddedRef(index) {
   return `m${String(index).padStart(5, "0")}`;
@@ -778,6 +840,38 @@ function adjustBoundariesForToolPairs(startIndex, endIndex, messages, maxScan =
   }
   return { startIndex: newStartIndex, endIndex: newEndIndex };
 }
+function adjustBoundariesForReasoningPairs(startIndex, endIndex, messages) {
+  if (startIndex > endIndex) {
+    return { startIndex, endIndex };
+  }
+  let newStartIndex = startIndex;
+  let newEndIndex = endIndex;
+  for (let i = startIndex; i <= endIndex && i < messages.length; i++) {
+    const msg = messages[i];
+    if (!msg) continue;
+    if (msg.contentType === "reasoning") {
+      let j = i;
+      while (j + 1 < messages.length && messages[j + 1].contentType === "reasoning") {
+        j++;
+      }
+      const companion = messages[j + 1];
+      if (companion !== void 0 && companion.role === "assistant" && (companion.contentType === "text" || companion.contentType === "tool-call") && j + 1 > newEndIndex) {
+        newEndIndex = j + 1;
+      }
+    }
+    if (msg.role === "assistant" && (msg.contentType === "text" || msg.contentType === "tool-call")) {
+      let k = i - 1;
+      while (k >= 0 && messages[k].contentType === "reasoning") {
+        k--;
+      }
+      const runStart = k + 1;
+      if (runStart < i && runStart >= 0 && messages[runStart].contentType === "reasoning" && runStart < newStartIndex) {
+        newStartIndex = runStart;
+      }
+    }
+  }
+  return { startIndex: newStartIndex, endIndex: newEndIndex };
+}
 function refNum(ref) {
   const n = parseInt(ref.slice(1), 10);
   return Number.isNaN(n) ? -1 : n;
@@ -932,6 +1026,9 @@ function runPipeline(nodes, initial, ctx) {
   }
   return io;
 }
+function rangeError(spec, message) {
+  return `range ${spec.startRef}..${spec.endRef}: ${message}`;
+}
 function createCore(ports = {}) {
   const countTokens = ports.countTokens ?? defaultCountTokens;
   function applyCompression(input) {
@@ -943,20 +1040,44 @@ function createCore(ports = {}) {
     const warnings = [];
     const protectedMessageIds = input.protectedMessageIds ?? computeProtectedRefs(input.messages, input.state, input.config, countTokens);
     const preExistingCoverage = collectCoverage(state);
-    const rangeIndexSets = [];
+    const classifications = /* @__PURE__ */ new Map();
+    const classificationErrors = [];
+    const consumedRanges = [];
     for (const spec of input.ranges) {
-      let resolved;
       try {
-        resolved = resolveBoundaries({
+        const resolved = resolveBoundaries({
           startRef: spec.startRef,
           endRef: spec.endRef,
           messages: input.messages,
           state
         });
-      } catch {
-        continue;
+        classifications.set(spec, { status: "ok", resolved });
+      } catch (error) {
+        if (error instanceof BoundaryNotFoundError) {
+          classifications.set(
+            spec,
+            error.kind === "unknown" ? { status: "unknown", error } : { status: "consumed", error }
+          );
+          if (error.kind === "consumed") {
+            consumedRanges.push(spec);
+          } else {
+            classificationErrors.push(rangeError(spec, error.message));
+          }
+        } else {
+          classifications.set(spec, {
+            status: "invalid",
+            error: error instanceof Error ? error : new Error(String(error))
+          });
+          classificationErrors.push(
+            rangeError(spec, error instanceof Error ? error.message : String(error))
+          );
+        }
       }
-      const indices = resolved.messageIds.map(
+    }
+    const rangeIndexSets = [];
+    for (const [spec, resolution] of classifications) {
+      if (resolution.status !== "ok") continue;
+      const indices = resolution.resolved.messageIds.map(
         (id) => input.messages.findIndex((m) => m.id === id)
       ).filter((i) => i >= 0);
       rangeIndexSets.push({ spec, indices });
@@ -983,37 +1104,27 @@ function createCore(ports = {}) {
     if (input.config.compress.minCompressRange > 0 && input.ranges.length > 0) {
       let totalRangeChars = 0;
       let hasBlockBoundaryRange = false;
-      for (const spec of input.ranges) {
-        if (skipSpecs.has(spec)) continue;
-        let resolved;
-        try {
-          resolved = resolveBoundaries({
-            startRef: spec.startRef,
-            endRef: spec.endRef,
-            messages: input.messages,
-            state
-          });
-        } catch {
-          continue;
-        }
-        if (resolved.boundaryKind === "block") {
+      let countedRanges = 0;
+      for (const [spec, resolution] of classifications) {
+        if (resolution.status !== "ok" || skipSpecs.has(spec)) continue;
+        if (resolution.resolved.boundaryKind === "block") {
           hasBlockBoundaryRange = true;
           continue;
         }
-        for (const id of resolved.messageIds) {
+        countedRanges++;
+        for (const id of resolution.resolved.messageIds) {
           const msg = input.messages.find((m) => m.id === id);
           totalRangeChars += msg?.text?.length ?? 0;
         }
       }
       if (!hasBlockBoundaryRange && totalRangeChars < input.config.compress.minCompressRange) {
+        const gateMessage = consumedRanges.length > 0 ? `Requested range(s) already compressed (e.g. ${consumedRanges[0].startRef}..${consumedRanges[0].endRef}); remaining compressible content ${totalRangeChars} chars < min ${input.config.compress.minCompressRange}. Nothing to do \u2014 run acp_status to see current compressible ranges.` : `Total compressible content too small (${totalRangeChars} chars across ${countedRanges} range(s), min ${input.config.compress.minCompressRange}). Combine more messages into your range(s) to meet the threshold.`;
         return {
           state: input.state,
           result: {
             blocksCreated: 0,
             tokensCompressed: 0,
-            errors: [
-              `Total compressible content too small (${totalRangeChars} chars across ${input.ranges.length} range(s), min ${input.config.compress.minCompressRange}). Combine more messages into your range(s) to meet the threshold.`
-            ],
+            errors: [gateMessage, ...classificationErrors],
             warnings: []
           }
         };
@@ -1021,6 +1132,18 @@ function createCore(ports = {}) {
     }
     for (const spec of input.ranges) {
       if (skipSpecs.has(spec)) continue;
+      const resolution = classifications.get(spec);
+      if (resolution === void 0) continue;
+      if (resolution.status === "consumed") {
+        warnings.push(
+          `Skipped range (${spec.startRef}..${spec.endRef}) \u2014 already compressed (messages consumed by existing block(s)); nothing to compress.`
+        );
+        continue;
+      }
+      if (resolution.status === "unknown" || resolution.status === "invalid") {
+        errors.push(rangeError(spec, resolution.error.message));
+        continue;
+      }
       try {
         const outcome = applySingleRange({
           spec,
@@ -1036,7 +1159,7 @@ function createCore(ports = {}) {
         tokensCompressed += outcome.tokens;
         warnings.push(...outcome.warnings);
       } catch (error) {
-        errors.push(error instanceof Error ? error.message : String(error));
+        errors.push(rangeError(spec, error instanceof Error ? error.message : String(error)));
       }
     }
     state.stats.compressionCount += blocksCreated;
@@ -1244,7 +1367,7 @@ function applySingleRange(input) {
     messages: input.messages,
     state: input.state
   });
-  const rangeMessageIds = applyToolPairAdjustment(
+  const rangeMessageIds = applyPairBoundaryAdjustments(
     resolved,
     input.messages
   );
@@ -1358,20 +1481,33 @@ function applySingleRange(input) {
   }
   return { tokens: compressedTokens, warnings };
 }
-function applyToolPairAdjustment(resolved, messages) {
+function applyPairBoundaryAdjustments(resolved, messages) {
   if (resolved.boundaryKind === "block") {
     return resolved.messageIds;
   }
-  const adjusted = adjustBoundariesForToolPairs(
-    resolved.startIndex,
-    resolved.endIndex,
-    messages
-  );
-  if (adjusted.startIndex === resolved.startIndex && adjusted.endIndex === resolved.endIndex) {
+  let startIndex = resolved.startIndex;
+  let endIndex = resolved.endIndex;
+  for (let pass = 0; pass < 2; pass++) {
+    const reasoningAdjusted = adjustBoundariesForReasoningPairs(
+      startIndex,
+      endIndex,
+      messages
+    );
+    const toolAdjusted = adjustBoundariesForToolPairs(
+      reasoningAdjusted.startIndex,
+      reasoningAdjusted.endIndex,
+      messages
+    );
+    const changed = toolAdjusted.startIndex !== startIndex || toolAdjusted.endIndex !== endIndex;
+    startIndex = toolAdjusted.startIndex;
+    endIndex = toolAdjusted.endIndex;
+    if (!changed) break;
+  }
+  if (startIndex === resolved.startIndex && endIndex === resolved.endIndex) {
     return resolved.messageIds;
   }
   const ids = [];
-  for (let i = adjusted.startIndex; i <= adjusted.endIndex; i++) {
+  for (let i = startIndex; i <= endIndex; i++) {
     const msg = messages[i];
     if (msg) ids.push(msg.id);
   }
@@ -1727,12 +1863,39 @@ DROP:
 - Anything marked [OBSOLETE] or [SUPERSEDED] \u2014 drop entirely, note "[N blocks obsolete]" in the summary.
 
 SIZE TARGET: 30-60 tokens per source block (including header). For a batch of N source blocks, total output \u2248 N \xD7 40 tokens. If a source block has only one trivial fact, output just the header + one line.`;
-var EFFICIENCY_NOTE = `This is an efficiency nudge to compress early and keep context lean \u2014 not an overflow warning. A separate, stronger alert will appear if the context is actually full.
+var defaultPrompts = Object.freeze({
+  compressPhilosophy: COMPRESS_PHILOSOPHY,
+  howToCompressRules: HOW_TO_COMPRESS_RULES,
+  tier2DistillRules: TIER2_DISTILL_RULES,
+  tier3CondenseRules: TIER3_CONDENSE_RULES
+});
+function resolvePrompts(overrides, options = {}) {
+  const clean = {};
+  if (overrides) {
+    for (const [key, value] of Object.entries(overrides)) {
+      if (typeof value === "string") {
+        clean[key] = value;
+      }
+    }
+  }
+  const keys = Object.keys(clean);
+  if (keys.length > 0 && !options.acknowledgeRisk) {
+    throw new Error(
+      `resolvePrompts: overriding compression rules requires { acknowledgeRisk: true }. Overridden keys: ${keys.join(", ")}. These rules are quality-critical (tuned over months of production use); changing them can degrade summary quality and break retrieval (summaries may lose paths, signatures, decisions).`
+    );
+  }
+  return { ...defaultPrompts, ...clean };
+}
+function efficiencyNote(prompts) {
+  return `This is an efficiency nudge to compress early and keep context lean \u2014 not an overflow warning. A separate, stronger alert will appear if the context is actually full.
 
-${COMPRESS_PHILOSOPHY}`;
-var EMERGENCY_HEADER = `\u26A0\uFE0F Context limit reached \u2014 compress now. Prioritize consumed tool outputs.
+${prompts.compressPhilosophy}`;
+}
+function emergencyHeader(prompts) {
+  return `\u26A0\uFE0F Context limit reached \u2014 compress now. Prioritize consumed tool outputs.
 
-${COMPRESS_PHILOSOPHY}`;
+${prompts.compressPhilosophy}`;
+}
 function formatK(n) {
   if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
   return `${n}`;
@@ -1840,7 +2003,7 @@ function formatRanges(compressible, protectedRanges) {
   return `Compressible ranges (${merged.length}, oldest first):
 ${lines.join("\n")}`;
 }
-function renderNudgeText(decision) {
+function renderNudgeText(decision, prompts = defaultPrompts) {
   const breakdownStr = formatBreakdown(decision.contextBreakdown);
   const rangesStr = formatRanges(decision.compressibleRanges, decision.protectedRanges ?? []);
   if (decision.tier !== null && decision.tier >= 2) {
@@ -1852,7 +2015,7 @@ function renderNudgeText(decision) {
     return {
       voice: "gentle",
       text: [
-        EFFICIENCY_NOTE,
+        efficiencyNote(prompts),
         "",
         breakdownStr,
         "",
@@ -1861,9 +2024,9 @@ function renderNudgeText(decision) {
         blockList,
         `Example: compress({ content: [{ startId: "${startId}", endId: "${endId}", summary: "..." }] })`,
         "",
-        HOW_TO_COMPRESS_RULES,
+        prompts.howToCompressRules,
         "",
-        isT2 ? TIER2_DISTILL_RULES : TIER3_CONDENSE_RULES
+        isT2 ? prompts.tier2DistillRules : prompts.tier3CondenseRules
       ].join("\n")
     };
   }
@@ -1872,11 +2035,11 @@ function renderNudgeText(decision) {
     return {
       voice: "emergency",
       text: [
-        EMERGENCY_HEADER,
+        emergencyHeader(prompts),
         "",
         breakdownStr,
         "",
-        HOW_TO_COMPRESS_RULES,
+        prompts.howToCompressRules,
         "",
         `{ "topic": "...", "content": [{ "startId": "<ID>", "endId": "<ID>", "summary": "..." }] }`,
         "Only use IDs from visible messages above. Compress older work first.",
@@ -1888,11 +2051,11 @@ function renderNudgeText(decision) {
   return {
     voice: "gentle",
     text: [
-      EFFICIENCY_NOTE,
+      efficiencyNote(prompts),
       "",
       breakdownStr,
       "",
-      HOW_TO_COMPRESS_RULES,
+      prompts.howToCompressRules,
       "",
       rangesStr,
       "",
@@ -2980,6 +3143,99 @@ function mergeInitialState(parsed) {
   };
 }
 
+// src/sequence-match.ts
+function findUniqueLongestRun(candidates, live) {
+  if (candidates.length === 0 || live.length === 0) return void 0;
+  const ids = /* @__PURE__ */ new Map();
+  const intern = (key) => {
+    const existing = ids.get(key);
+    if (existing !== void 0) return existing;
+    const id = ids.size + 1;
+    ids.set(key, id);
+    return id;
+  };
+  const candidateIds = candidates.map(intern);
+  const liveIds = live.map(intern);
+  const separator = ids.size + 1;
+  const sequence = [...candidateIds, separator, ...liveIds];
+  const suffixArray = buildSuffixArray(sequence);
+  const lcp = buildLcp(sequence, suffixArray);
+  const candidateLength = candidates.length;
+  const liveOffset = candidateLength + 1;
+  const sourceOf = (suffix) => {
+    if (suffix < candidateLength) return 0;
+    if (suffix >= liveOffset) return 1;
+    return void 0;
+  };
+  let bestLength = 0;
+  for (let index = 1; index < suffixArray.length; index++) {
+    const leftSource = sourceOf(suffixArray[index - 1]);
+    const rightSource = sourceOf(suffixArray[index]);
+    if (leftSource === void 0 || rightSource === void 0 || leftSource === rightSource) continue;
+    bestLength = Math.max(bestLength, lcp[index]);
+  }
+  if (bestLength === 0) return void 0;
+  let pairCount = 0;
+  let uniqueCandidateStart = -1;
+  let uniqueLiveStart = -1;
+  for (let start = 0; start < suffixArray.length; ) {
+    let end = start;
+    while (end + 1 < suffixArray.length && lcp[end + 1] >= bestLength) end++;
+    if (end > start) {
+      const candidateStarts = [];
+      const liveStarts = [];
+      for (let index = start; index <= end; index++) {
+        const suffix = suffixArray[index];
+        const source = sourceOf(suffix);
+        if (source === 0) candidateStarts.push(suffix);
+        else if (source === 1) liveStarts.push(suffix - liveOffset);
+      }
+      const groupPairs = candidateStarts.length * liveStarts.length;
+      pairCount += groupPairs;
+      if (groupPairs === 1) {
+        uniqueCandidateStart = candidateStarts[0];
+        uniqueLiveStart = liveStarts[0];
+      }
+      if (pairCount > 1) return void 0;
+    }
+    start = end + 1;
+  }
+  return pairCount === 1 ? { candidateStart: uniqueCandidateStart, liveStart: uniqueLiveStart, length: bestLength } : void 0;
+}
+function buildSuffixArray(sequence) {
+  const suffixArray = sequence.map((_, index) => index);
+  let ranks = [...sequence];
+  for (let width = 1; width < sequence.length; width *= 2) {
+    suffixArray.sort((left, right) => ranks[left] - ranks[right] || (ranks[left + width] ?? -1) - (ranks[right + width] ?? -1));
+    const nextRanks = Array(sequence.length);
+    nextRanks[suffixArray[0]] = 0;
+    for (let index = 1; index < suffixArray.length; index++) {
+      const previous = suffixArray[index - 1];
+      const current = suffixArray[index];
+      const differs = ranks[previous] !== ranks[current] || (ranks[previous + width] ?? -1) !== (ranks[current + width] ?? -1);
+      nextRanks[current] = nextRanks[previous] + (differs ? 1 : 0);
+    }
+    ranks = nextRanks;
+    if (ranks[suffixArray.at(-1)] === sequence.length - 1) break;
+  }
+  return suffixArray;
+}
+function buildLcp(sequence, suffixArray) {
+  const positions = Array(sequence.length);
+  for (let index = 0; index < suffixArray.length; index++) positions[suffixArray[index]] = index;
+  const lcp = Array(sequence.length).fill(0);
+  let length = 0;
+  for (let start = 0; start < sequence.length; start++) {
+    const position = positions[start];
+    if (position === 0) continue;
+    const previous = suffixArray[position - 1];
+    while (start + length < sequence.length && previous + length < sequence.length && sequence[start + length] === sequence[previous + length]) length++;
+    lcp[position] = length;
+    if (length > 0) length--;
+  }
+  return lcp;
+}
+
 // src/runtime.ts
 function readContextEntries(sm) {
   const source = sm;
@@ -2993,15 +3249,17 @@ function isPiHost(sm) {
 }
 function mergeLiveEntries(entries, live, state, origins) {
   const persisted = entries.filter((e) => e.type === "message");
-  const matched = matchPersistedSuffix(persisted, live);
-  const prior = matchOrigins(origins, live);
+  const liveIdentities = live.map(messageIdentity);
+  const persistedIdentities = persisted.map((entry) => messageIdentity(entry.message));
+  const persistedRange = findUniqueLongestRun(persistedIdentities, normalizePersistedMatchKeys(persisted, persistedIdentities, live, liveIdentities));
+  const originRange = findUniqueLongestRun(origins.map((origin) => origin.identity), liveIdentities);
   const out = [];
   const nextOrigins = [];
   const usedIds = /* @__PURE__ */ new Set();
   for (let i = 0; i < live.length; i++) {
     const msg = live[i];
-    const entry = matched[i];
-    const origin = prior[i];
+    const entry = valueInRange(persisted, persistedRange, i);
+    const origin = valueInRange(origins, originRange, i);
     if (entry) {
       if (origin) migrateLiveRefs(state, origin.rawId, entry.id);
       else migrateTaggedRef(state, msg, entry.id);
@@ -3011,23 +3269,13 @@ function mergeLiveEntries(entries, live, state, origins) {
     const id = origin?.rawId ?? nextLiveId(state, usedIds, i);
     usedIds.add(id);
     out.push({ type: "message", id, parentId: null, timestamp: String(msg.timestamp ?? Date.now()), message: msg });
-    nextOrigins.push({ rawId: id, identity: messageIdentity(msg) });
+    nextOrigins.push({ rawId: id, identity: liveIdentities[i] });
   }
   origins.splice(0, origins.length, ...nextOrigins);
-  const unmatched = live.length - matched.length;
+  const unmatched = live.length - (persistedRange?.length ?? 0);
   if (unmatched > 0) logInfo("runtime", { event: "merge-live-entries", live: live.length, unmatched });
   return out;
 }
-function matchOrigins(origins, live) {
-  for (let start = 0; start < origins.length; start++) {
-    const count = origins.length - start;
-    if (count > live.length) continue;
-    if (origins.slice(start).every((origin, index) => origin.identity === messageIdentity(live[index]))) {
-      return [...origins.slice(start), ...Array(live.length - count)];
-    }
-  }
-  return Array(live.length);
-}
 function nextLiveId(state, used, index) {
   let id = `live-${index}`;
   let suffix = index;
@@ -3054,31 +3302,39 @@ function migrateLiveRefs(state, liveId, stableId) {
     delete state.messageRefs.byRaw[rawId];
   }
 }
-function matchPersistedSuffix(persisted, live) {
-  for (let start = 0; start < persisted.length; start++) {
-    const count = persisted.length - start;
-    if (count > live.length) continue;
-    const suffix = persisted.slice(start);
-    if (suffix.every((entry, index) => sameMessage(entry.message, live[index]))) return suffix;
-  }
-  return [];
+var NO_PERSISTED_MATCH = /* @__PURE__ */ Symbol("no-persisted-match");
+function normalizePersistedMatchKeys(persisted, persistedIdentities, live, liveIdentities) {
+  const persistedByStructure = /* @__PURE__ */ new Map();
+  for (let index = 0; index < persisted.length; index++) {
+    const key = toolResultStructureKey(persisted[index].message);
+    if (key === void 0) continue;
+    persistedByStructure.set(key, persistedByStructure.has(key) ? -1 : index);
+  }
+  return live.map((message, liveIndex) => {
+    const key = toolResultStructureKey(message);
+    const candidateIndex = key === void 0 ? void 0 : persistedByStructure.get(key);
+    if (candidateIndex === void 0) return liveIdentities[liveIndex];
+    if (candidateIndex < 0) return NO_PERSISTED_MATCH;
+    return sameToolResult(persisted[candidateIndex].message, message) ? persistedIdentities[candidateIndex] : liveIdentities[liveIndex];
+  });
 }
-function sameMessage(a, b) {
-  try {
-    if (messageIdentity(a) === messageIdentity(b)) return true;
-    const ra = a.role;
-    const rb = b.role;
-    if (ra !== rb || ra !== "toolResult") return false;
-    const ca = a.content;
-    const cb = b.content;
-    return sameNonTextBlocks(ca, cb) && matchesStoredText(extractText(ca), extractText(cb));
-  } catch (e) {
-    logWarn("runtime", { event: "message-compare-failed", error: e instanceof Error ? e.message : String(e) });
-    return a === b;
-  }
+function toolResultStructureKey(message) {
+  if (message.role !== "toolResult") return void 0;
+  return `${message.toolName}\0${message.toolCallId}`;
+}
+function valueInRange(values, range, liveIndex) {
+  if (!range || liveIndex < range.liveStart || liveIndex >= range.liveStart + range.length) return void 0;
+  return values[range.candidateStart + liveIndex - range.liveStart];
+}
+function sameToolResult(stored, visible) {
+  if (stored.role !== "toolResult" || visible.role !== "toolResult") return false;
+  return sameNonTextBlocks(stored.content, visible.content) && matchesStoredText(extractText(stored.content), extractText(visible.content));
 }
 function sameNonTextBlocks(a, b) {
-  const nonText = (blocks) => blocks.filter((block) => block.type !== "text");
+  const nonText = (blocks) => blocks.filter((block) => {
+    if (!block || typeof block !== "object" || !("type" in block)) return true;
+    return block.type !== "text";
+  });
   try {
     const na = Array.isArray(a) ? nonText(a) : [];
     const nb = Array.isArray(b) ? nonText(b) : [];
@@ -3106,6 +3362,7 @@ function createRuntime(adapter) {
   const store = new SessionStateStore();
   const locks = /* @__PURE__ */ new Map();
   let adapterRef = adapter;
+  let promptsRef = defaultPrompts;
   const nudgeShownTurns = /* @__PURE__ */ new Set();
   async function acquireLock(sid) {
     const prev = locks.get(sid) ?? Promise.resolve();
@@ -3154,6 +3411,10 @@ function createRuntime(adapter) {
     return adapterRef;
   }, setAdapter: (a) => {
     adapterRef = a;
+  }, get prompts() {
+    return promptsRef;
+  }, setPrompts: (p) => {
+    promptsRef = p;
   }, markNudgeShown: (k) => {
     nudgeShownTurns.add(k);
   }, nudgeShownFor: (k) => nudgeShownTurns.has(k), clearNudgeTracking: () => {
@@ -7768,6 +8029,18 @@ function findMessageContent(ref, ctx) {
   }
   return null;
 }
+function resolveBlockMessages(block, coreMessages, ctx) {
+  const neededBaseIds = new Set(block.effectiveMessageIds.map((id) => id.split("#")[0]));
+  const presentBaseIds = new Set(coreMessages.map((m) => m.id.split("#")[0]));
+  const missingBaseIds = [...neededBaseIds].filter((id) => !presentBaseIds.has(id));
+  if (missingBaseIds.length === 0) return coreMessages;
+  const extra = [];
+  for (const baseId of missingBaseIds) {
+    const entry = ctx.sessionManager.getEntry(baseId);
+    if (entry) extra.push(...entriesToCoreMessages([entry]));
+  }
+  return [...coreMessages, ...extra];
+}
 async function handleMessageRef(ref, ownerBlockId, args, ctx) {
   const found = findMessageContent(ref, ctx);
   if (!found || !found.text) {
@@ -7815,7 +8088,8 @@ async function handleDecompress(args, runtime, ctx) {
     return `Block ${blockId} not found. Active blocks: ${active || "(none)"}.`;
   }
   const full = args.full ?? false;
-  const { text, count } = collectBlockContent(state, block, coreMessages, { full });
+  const resolved = resolveBlockMessages(block, coreMessages, ctx);
+  const { text, count } = collectBlockContent(state, block, resolved, { full });
   if (count === 0) return `Block ${blockId} has no restorable message content.`;
   if (args.inline === true && !args.toFile) {
     debug.event("decompress", { blockId, full, count, mode: "inline" });
@@ -7977,10 +8251,10 @@ function formatSize(tokens) {
 import {
   spawn
 } from "child_process";
-import { createWriteStream } from "fs";
+import { createWriteStream, existsSync as existsSync2 } from "fs";
 import { mkdir as mkdir2, mkdtemp, writeFile as writeFile2, rm, appendFile } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join4 } from "path";
+import { dirname as dirname3, join as join4, resolve as resolvePath } from "path";
 
 // src/footer-status.ts
 var FOOTER_STATUS_KEY = "billion-context-pi";
@@ -8393,6 +8667,44 @@ function delegateSpawnOptions(cwd, env) {
     shell: false
   };
 }
+var PI_CLI_ENTRY_RE = /[\\/]pi-coding-agent[\\/]dist[\\/]cli\.js$/;
+var PI_PACKAGE_REL = join4("@earendil-works", "pi-coding-agent", "dist", "cli.js");
+function probeUpFromArgv(argv1) {
+  let dir = resolvePath(dirname3(argv1) || process.cwd());
+  for (; ; ) {
+    const candidate = join4(dir, "node_modules", PI_PACKAGE_REL);
+    if (existsSync2(candidate)) return candidate;
+    const parent = dirname3(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function piCliGlobalCandidates(env) {
+  const candidates = [];
+  if (process.platform === "win32") {
+    if (env.APPDATA) candidates.push(join4(env.APPDATA, "npm", "node_modules", PI_PACKAGE_REL));
+  } else {
+    const home = env.HOME ?? env.USERPROFILE;
+    if (home) candidates.push(join4(home, ".local", "lib", "node_modules", PI_PACKAGE_REL));
+    candidates.push(join4("/usr/local", "lib", "node_modules", PI_PACKAGE_REL));
+    candidates.push(join4("/usr", "lib", "node_modules", PI_PACKAGE_REL));
+  }
+  return candidates;
+}
+function resolvePiCliEntry(argv1, env = process.env, piHost = true) {
+  const explicit = env.PI_CLI_PATH;
+  if (explicit) return explicit;
+  if (argv1 && PI_CLI_ENTRY_RE.test(argv1)) return argv1;
+  if (piHost) {
+    const probed = probeUpFromArgv(argv1);
+    if (probed) return probed;
+    for (const candidate of piCliGlobalCandidates(env)) {
+      if (existsSync2(candidate)) return candidate;
+    }
+    logWarn("delegate", { event: "cli-entry-unresolved", argv1, fallback: "argv[1]" });
+  }
+  return argv1;
+}
 var ACP_TOOLS = ["compress", "decompress", "search_context", "acp_status"];
 var RESTRICTED_TOOLS = "read,bash,grep,find,ls";
 var AGENTS = {
@@ -8814,7 +9126,7 @@ async function runDelegate(pi, args, ctx, signal) {
   logInfo("delegate", { event: "spawn", agent: args.agent, runId, cwd, async: isAsync, useJsonStream, mode: ctx.mode, parentDepth });
   const child = spawn(
     process.execPath,
-    [process.argv[1], ...cliArgs],
+    [resolvePiCliEntry(process.argv[1] ?? "", process.env, isPiHost(ctx.sessionManager)), ...cliArgs],
     delegateSpawnOptions(cwd, childEnv)
   );
   child.stdin?.once("error", (e) => {
@@ -9346,7 +9658,7 @@ async function statusReport(runtime, ctx) {
   const activeBlocksList = state.blocks.filter((b) => b.active);
   const totalBlocksList = state.blocks;
   const lines = [];
-  const versionStr = "0.1.36" ? `billion-context-pi@${"0.1.36"}` : "";
+  const versionStr = "0.1.37" ? `billion-context-pi@${"0.1.37"}` : "";
   lines.push("\u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E");
   lines.push("\u2502           ACP Context Analysis              \u2502");
   lines.push("\u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F");
@@ -9423,7 +9735,8 @@ async function statusReport(runtime, ctx) {
 }
 
 // src/system-prompt.ts
-var ACP_SYSTEM_PROMPT = `
+function buildAcpSystemPrompt(prompts) {
+  return `
 ACP context management
 
 ACP TAGS
@@ -9447,7 +9760,7 @@ You have four context-management tools:
 - search_context \u2014 Search compressed block summaries (and optionally visible messages) by keyword. Use BEFORE decompressing to find the right block. Example: search_context({ query: "auth token refresh" }).
 - acp_status \u2014 Context status with compressible ranges. No args = overview + totals. scope:"uncompressed" for range view; add view:"messages" for per-message listing. scope:"compressed" for block details.
 
-${COMPRESS_PHILOSOPHY}
+${prompts.compressPhilosophy}
 
 WHEN TO COMPRESS
 
@@ -9465,7 +9778,7 @@ WHEN NOT TO COMPRESS
 - Important user messages \u2014 preserve their exact intent, constraints, and acceptance criteria. If a message in the range must stay verbatim, exclude it from the compress range instead of compressing it.
 - Protected tool outputs \u2014 hard-excluded from compression ranges, survive intact in visible context.
 
-${HOW_TO_COMPRESS_RULES}
+${prompts.howToCompressRules}
 
 MULTI-TIER COMPRESSION
 
@@ -9473,9 +9786,9 @@ Summaries accumulate as the session grows. When tier-1 summaries pile up, the sy
 
 To compress blocks: use block IDs as boundaries: compress({ content: [{ startId: "b3", endId: "b15", summary: "..." }] }). This deactivates the consumed blocks and creates a new higher-tier block.
 
-${TIER2_DISTILL_RULES}
+${prompts.tier2DistillRules}
 
-${TIER3_CONDENSE_RULES}
+${prompts.tier3CondenseRules}
 
 THE PHILOSOPHY OF DECOMPRESS
 
@@ -9485,6 +9798,7 @@ CONTEXT BREAKDOWN
 
 When context usage passes a threshold, the system appends a breakdown showing where tokens are spent. Compress the largest ranges first when the current step no longer needs them.
 `;
+}
 var ACP_DELEGATE_PROMPT = `
 ACP_DELEGATE NOTIFICATIONS
 
@@ -9613,7 +9927,7 @@ function wireToolGuardrails(pi, runtime) {
 
 // src/update.ts
 import { readFile, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import { join as join5, dirname as dirname3 } from "path";
+import { join as join5, dirname as dirname4 } from "path";
 import { fileURLToPath } from "url";
 import { execFile } from "child_process";
 import { homedir as homedir3 } from "os";
@@ -9646,7 +9960,7 @@ async function readLastCheck() {
 }
 async function writeLastCheck(timestamp) {
   try {
-    await mkdir3(dirname3(THROTTLE_FILE), { recursive: true });
+    await mkdir3(dirname4(THROTTLE_FILE), { recursive: true });
     await writeFile3(THROTTLE_FILE, String(timestamp), "utf-8");
   } catch {
   }
@@ -9660,20 +9974,20 @@ async function readPackageJson(path4) {
   }
 }
 function findNpmRoot(extDir) {
-  let dir = dirname3(extDir);
+  let dir = dirname4(extDir);
   for (; ; ) {
-    if (dir.endsWith("node_modules")) return dirname3(dir);
-    const parent = dirname3(dir);
+    if (dir.endsWith("node_modules")) return dirname4(dir);
+    const parent = dirname4(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
 }
 async function findExtensionDir() {
-  let dir = dirname3(fileURLToPath(import.meta.url));
+  let dir = dirname4(fileURLToPath(import.meta.url));
   for (; ; ) {
     const pkg = await readPackageJson(join5(dir, "package.json"));
     if (pkg?.name === PACKAGE_NAME) return dir;
-    const parent = dirname3(dir);
+    const parent = dirname4(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -9722,7 +10036,7 @@ async function checkForUpdate(autoUpdate, notify) {
     const data = await res.json();
     const latest = data.version;
     if (!latest) return;
-    const current = runtimeVersion ?? "0.1.36";
+    const current = runtimeVersion ?? "0.1.37";
     const hasUpdate = isNewer(latest, current);
     debug.event("update-check", {
       current,
@@ -9758,7 +10072,7 @@ async function getRuntimeVersion() {
 
 // src/setup-subagent-tools.ts
 import { readFile as readFile2, writeFile as writeFile4, stat, copyFile, rename } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join6 } from "path";
 import { CONFIG_DIR_NAME as CONFIG_DIR_NAME3 } from "@earendil-works/pi-coding-agent";
@@ -9823,7 +10137,7 @@ async function ensureSubagentAcpTools(settingsPath) {
     return { path: path4, action: "skipped", reason: "all builtin agents already have ACP tools" };
   }
   const backupPath = `${path4}.acp-bak`;
-  if (!existsSync2(backupPath)) {
+  if (!existsSync3(backupPath)) {
     try {
       await copyFile(path4, backupPath);
     } catch {
@@ -9923,7 +10237,9 @@ var KNOWN = /* @__PURE__ */ new Set([
   "toolOutputMaxBytes",
   "delegate",
   "compress",
-  "displayUsage"
+  "displayUsage",
+  "prompts",
+  "acknowledgePromptsRisk"
 ]);
 function pickKnown(parsed) {
   const out = {};
@@ -9971,7 +10287,7 @@ function wireSessionLifecycle(pi, runtime) {
     resetDelegateUsage();
     setDelegateDisplayUsage("separate");
     const sid = ctx.sessionManager.getSessionId();
-    logInfo("session", { event: "start", sid, cwd: ctx.cwd, debug: runtime.adapter.debug ?? null, version: true ? "0.1.36" : null });
+    logInfo("session", { event: "start", sid, cwd: ctx.cwd, debug: runtime.adapter.debug ?? null, version: true ? "0.1.37" : null });
     try {
       const user = await loadUserConfig(ctx.cwd);
       runtime.setAdapter(applyUserConfig(runtime.adapter, user));
@@ -9980,6 +10296,12 @@ function wireSessionLifecycle(pi, runtime) {
     } catch (e) {
       logThrow("config", e, { sid, phase: "session_start" });
     }
+    try {
+      runtime.setPrompts(resolvePrompts(runtime.adapter.prompts, { acknowledgeRisk: runtime.adapter.acknowledgePromptsRisk === true }));
+    } catch (e) {
+      logWarn("config", { event: "prompts-resolve-failed", error: e instanceof Error ? e.message : String(e) });
+      runtime.setPrompts(defaultPrompts);
+    }
     if (resolveDelegate(runtime.adapter).enabled) {
       pi.registerTool(makeDelegateTool(pi));
       pi.registerTool(makeDelegateWaitTool(pi));
@@ -10040,7 +10362,7 @@ function wireContextTransform(pi, runtime) {
         prunedMsgs: coreMessages.length - turn.messages.length + turn.messages.filter((m) => m.id.startsWith("acp_summary")).length,
         nudgeShouldInject: turn.nudge?.shouldInject ?? false,
         nudgeReason: turn.nudge?.reason ?? null,
-        nudgeVoice: turn.nudge ? renderNudgeText(turn.nudge).voice : null,
+        nudgeVoice: turn.nudge ? renderNudgeText(turn.nudge, runtime.prompts).voice : null,
         nudgePct: turn.nudge ? Math.round(turn.nudge.contextUsage * 100) : null,
         nudgeTier: turn.nudge?.tier ?? null,
         nudgeCompressibleCount: turn.nudge?.compressibleRanges.length ?? 0,
@@ -10057,8 +10379,8 @@ function wireContextTransform(pi, runtime) {
         const turnKey = lastUserMessageId(entries) ?? sid;
         const alreadyShown = !emergency && runtime.nudgeShownFor(turnKey);
         if (!alreadyShown) {
-          rebuilt.push(nudgeMessage(turn.nudge, turn.state.blocks.filter((b) => b.active)));
-          const rendered = renderNudgeText(turn.nudge);
+          rebuilt.push(nudgeMessage(turn.nudge, turn.state.blocks.filter((b) => b.active), runtime.prompts));
+          const rendered = renderNudgeText(turn.nudge, runtime.prompts);
           const top = [...turn.nudge.compressibleRanges].sort((a, b) => b.tokens - a.tokens)[0];
           const example = top ? `
 
@@ -10092,8 +10414,9 @@ ${rendered.text}${example}`);
 function wireSystemPrompt(pi, runtime) {
   pi.on("before_agent_start", (event) => {
     const delegate = runtime.adapter.delegate !== false;
-    const prompt = delegate ? `${ACP_SYSTEM_PROMPT}
-${ACP_DELEGATE_PROMPT}` : ACP_SYSTEM_PROMPT;
+    const acp = buildAcpSystemPrompt(runtime.prompts);
+    const prompt = delegate ? `${acp}
+${ACP_DELEGATE_PROMPT}` : acp;
     return { systemPrompt: formatSystemPromptForEvent(event.systemPrompt, prompt) };
   });
 }
@@ -10109,8 +10432,8 @@ function collectOriginals(entries) {
   }
   return map;
 }
-function nudgeMessage(nudge, blocks) {
-  const rendered = renderNudgeText(nudge);
+function nudgeMessage(nudge, blocks, prompts) {
+  const rendered = renderNudgeText(nudge, prompts);
   const lines = [rendered.text];
   if (blocks.length > 0) {
     const totalSummary = blocks.reduce((s, b) => s + Math.ceil((b.summary || "").length / 4), 0);