acp-kernel 0.0.100 → 0.0.101

package/dist/index.js

@@ -180,11 +180,8 @@ function collectSummaryAnchors(state, baseIndexById, summaryIndexById) {
   anchors.sort((left, right) => left.insertAt - right.insertAt);
   return anchors;
 }
-function pairSafeAnchorIndex(messages, index) {
-  let safe = index;
-  while (safe > 0 && safe < messages.length && messages[safe - 1].role === "assistant" && messages[safe].role === "assistant") {
-    safe--;
-  }
+function buildAnchorPairingIndex(messages) {
+  const n = messages.length;
   const resultIndexByCallId = /* @__PURE__ */ new Map();
   messages.forEach((message, at) => {
     if (message.contentType !== "tool-result") return;
@@ -193,27 +190,51 @@ function pairSafeAnchorIndex(messages, index) {
       resultIndexByCallId.set(message.toolCallId, at);
     }
   });
-  for (let guard = 0; guard < messages.length; guard++) {
-    let moved = safe;
-    for (let at = 0; at < safe && at < messages.length; at++) {
-      const message = messages[at];
-      if (message.role !== "assistant") continue;
-      if (message.contentType !== "tool-call") continue;
-      if (typeof message.toolCallId !== "string") continue;
+  const runStart = new Int32Array(n).fill(-1);
+  for (let i = 0; i < n; ) {
+    if (messages[i].role !== "assistant") {
+      i++;
+      continue;
+    }
+    let j = i;
+    while (j + 1 < n && messages[j + 1].role === "assistant") j++;
+    for (let k = i; k <= j; k++) runStart[k] = i;
+    i = j + 1;
+  }
+  const prefixEnd = new Int32Array(n + 1);
+  for (let i = 0; i < n; i++) {
+    const message = messages[i];
+    let end = 0;
+    if (message.role === "assistant" && message.contentType === "tool-call" && typeof message.toolCallId === "string") {
       const resultIndex = resultIndexByCallId.get(message.toolCallId);
-      if (resultIndex !== void 0 && resultIndex >= safe && resultIndex + 1 > moved) {
-        moved = resultIndex + 1;
-      }
+      if (resultIndex !== void 0) end = resultIndex + 1;
+    }
+    prefixEnd[i + 1] = Math.max(prefixEnd[i], end);
+  }
+  return { runStart, prefixEnd };
+}
+function pairSafeAnchorIndex(messages, index, ix) {
+  const n = messages.length;
+  let safe = index;
+  if (safe > 0 && safe < n) {
+    const start = ix.runStart[safe];
+    if (start >= 0 && messages[safe - 1].role === "assistant") {
+      safe = start;
     }
-    if (moved === safe) break;
-    safe = moved;
+  }
+  if (safe < 0 || safe > n) return safe;
+  for (let guard = 0; guard < n; guard++) {
+    const next = Math.max(safe, ix.prefixEnd[safe]);
+    if (next === safe) break;
+    safe = next;
   }
   return safe;
 }
 function rebuildMessages(messages, coveredBases, firstUserIndex, anchors) {
+  const ix = anchors.length > 0 ? buildAnchorPairingIndex(messages) : null;
   const safeAnchors = anchors.map((anchor) => ({
     ...anchor,
-    insertAt: pairSafeAnchorIndex(messages, anchor.insertAt)
+    insertAt: ix ? pairSafeAnchorIndex(messages, anchor.insertAt, ix) : anchor.insertAt
   })).sort((left, right) => left.insertAt - right.insertAt);
   const result = [];
   const pending = [...safeAnchors];
@@ -4408,22 +4429,18 @@ function segmentGroups(items) {
 function estimateTextTokens(text) {
   return Math.ceil(text.length / 4);
 }
-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 isSyntheticOrPruned(message, covered) {
+  if (message.text?.startsWith(SUMMARY_HEADER)) return true;
+  return covered.has(message.id);
 }
 function computeProtectedRefs(messages, state, config, countTokens = estimateTextTokens) {
   const preserveN = config.preserveRecentMessages;
   const preserveTokens = config.preserveRecentTokens;
+  const covered = coveredMessageIds(state);
   const result = /* @__PURE__ */ new Set();
   const visible = [];
   for (const msg of messages) {
-    if (isSyntheticOrPruned(msg, state)) continue;
+    if (isSyntheticOrPruned(msg, covered)) continue;
     if (isNeverPreserveRecent(
       msg,
       config.neverPreserveRecentTools,
@@ -4449,7 +4466,7 @@ function computeProtectedRefs(messages, state, config, countTokens = estimateTex
   if (preserveN > 0) {
     for (let i = messages.length - 1; i >= 0; i--) {
       const msg = messages[i];
-      if (msg.role !== "user" || isSyntheticOrPruned(msg, state)) continue;
+      if (msg.role !== "user" || isSyntheticOrPruned(msg, covered)) continue;
       const ref = state.messageRefs.byRaw[msg.id];
       if (ref && ref !== "BLOCKED") result.add(ref);
       break;
@@ -4460,6 +4477,7 @@ function computeProtectedRefs(messages, state, config, countTokens = estimateTex
 function buildCompressibleRanges(messages, state, config, protectedZoneRefs, countTokens = estimateTextTokens) {
   let compressibleMsgs = [];
   const protectedMsgs = [];
+  const covered = coveredMessageIds(state);
   const protectedCallIds = collectProtectedToolCallIds(messages, config);
   const latest = collectLatestProtected(messages, config);
   for (const id of latest.callIds) protectedCallIds.add(id);
@@ -4470,7 +4488,7 @@ function buildCompressibleRanges(messages, state, config, protectedZoneRefs, cou
     msgIndex++;
     const ref = state.messageRefs.byRaw[msg.id];
     if (!ref || ref === "BLOCKED") continue;
-    if (isSyntheticOrPruned(msg, state)) {
+    if (isSyntheticOrPruned(msg, covered)) {
       skipSinceCompressible = true;
       skipSinceProtected = true;
       continue;