acp-kernel 0.0.82-pr.342.217 → 0.0.82-pr.345.219

package/DESIGN.md

@@ -219,19 +219,3 @@ A default `countTokens` ships with the core (word-level + unicode CJK tokenizer,
 ## 7. Why the algorithm, but not the DCP-derived code, comes here
 
 Copyright protects *expression*, not ideas, methods, or algorithms (17 USC §102(b)). The compression *methods* (3-tier, growth cadence, protected filtering) are the author's. This core reimplements them in **fresh expression** — it is not a copy or refactor of DCP-derived files. See [PROVENANCE.md](./PROVENANCE.md) for the per-module origin classification (original-bring / DCP-derived-reimplement / adapter-only).
-
----
-
-## 8. Prune Semantics & Wire Invariants
-
-`prune` rebuilds the visible view every turn: messages covered by active blocks are dropped, and each active block's rendered summary (`[Compressed conversation section]`, id `acp_summary_bN`) is inserted at the block's earliest covered position (pair-safe, per `pairSafeAnchorIndex`). One behavior of the rebuilt view is a load-bearing contract for downstream consumers:
-
-### 8.1 First-user-message pin
-
-The session's **first user message survives prune unconditionally** — even when it is covered by an active block. In `rebuildMessages` (`src/prune.ts`) the pin check runs *before* the covered-by-active-block check, so after compressing a range that includes the first user message, the rebuilt wire contains **both** the rendered summary **and** the first user message verbatim; all other covered messages drop as usual. Only the *first* user message is pinned — later covered user messages are pruned normally.
-
-- **Why:** strict providers reject conversations with no user message (e.g., Anthropic requires the conversation to start from the user role). Pinning guarantees the rebuilt wire retains at least one user message whenever the input had one. Deliberate since prune's first implementation (v0.0.2) — the ordering of the two checks is part of the contract, not incidental. Regression-tested by `tests/state-prune.test.ts` ("prune preserves first user message even when covered") and `tests/orphan-fixes.test.ts` ("prune: first user message pruned when covered (no duplication)").
-- **Consequences for consumers:**
-  - Consumers cannot assert byte-level disappearance of the first user message after compression; post-compress wire assertions must expect the rendered summary **plus** the pinned message verbatim.
-  - Token-size and prefix-cache stability estimates must account for the pinned message staying verbatim (it is often the task description and can be long).
-  - Boundary resolution compensates: `blockVisibleInRange` (`src/boundaries.ts`) treats a block as present in a range via its rendered summary **or** its earliest surviving raw — required precisely because the summary anchors *before* the pinned raw.

package/dist/index.js

@@ -1,3 +1,13 @@
+import {
+  activeBlocks,
+  advanceSurvival,
+  allocateBlockId,
+  allocateRunId,
+  blockById,
+  coveredMessageIds,
+  createInitialState,
+  highestActiveTier
+} from "./chunk-5TQA7ZQM.js";
 import {
   COMPRESS_PHILOSOPHY,
   HOW_TO_COMPRESS_RULES,
@@ -17,16 +27,6 @@ import {
   thinkingTokenValue,
   viableRanges
 } from "./chunk-VPRKYTHW.js";
-import {
-  activeBlocks,
-  advanceSurvival,
-  allocateBlockId,
-  allocateRunId,
-  blockById,
-  coveredMessageIds,
-  createInitialState,
-  highestActiveTier
-} from "./chunk-5TQA7ZQM.js";
 
 // src/refs.ts
 var REF_WIDTH = 5;
@@ -2233,6 +2233,27 @@ function computeProtectedRefs(messages, state, config, countTokens = estimateTex
   }
   return result;
 }
+function computeOpenTurnMemberIds(messages) {
+  const resultCallIds = /* @__PURE__ */ new Set();
+  for (const msg of messages) {
+    if (msg.contentType === "tool-result" && typeof msg.toolCallId === "string") {
+      resultCallIds.add(msg.toolCallId);
+    }
+  }
+  const openCallIds = /* @__PURE__ */ new Set();
+  for (const msg of messages) {
+    if (msg.id && msg.role === "assistant" && msg.contentType === "tool-call" && typeof msg.toolCallId === "string" && !resultCallIds.has(msg.toolCallId)) {
+      openCallIds.add(msg.id);
+    }
+  }
+  if (openCallIds.size === 0) return /* @__PURE__ */ new Set();
+  const excluded = /* @__PURE__ */ new Set();
+  for (const group of computeTurnGroups(messages)) {
+    if (!group.some((id) => openCallIds.has(id))) continue;
+    for (const id of group) excluded.add(id);
+  }
+  return excluded;
+}
 function buildCompressibleRanges(messages, state, config, protectedZoneRefs, countTokens = estimateTextTokens) {
   let compressibleMsgs = [];
   const protectedMsgs = [];
@@ -2281,6 +2302,20 @@ function buildCompressibleRanges(messages, state, config, protectedZoneRefs, cou
     skipSinceCompressible = false;
     skipSinceProtected = true;
   }
+  const openTurnIds = computeOpenTurnMemberIds(messages);
+  if (openTurnIds.size > 0) {
+    let gapPending = false;
+    const kept = [];
+    for (const info of compressibleMsgs) {
+      if (openTurnIds.has(info.id)) {
+        gapPending = true;
+        continue;
+      }
+      kept.push(gapPending ? { ...info, gapBefore: true } : info);
+      gapPending = false;
+    }
+    compressibleMsgs = kept;
+  }
   const unfoldedIds = computeIntegrityWithdrawals(
     messages,
     new Set(compressibleMsgs.map((info) => info.id))
@@ -2298,6 +2333,13 @@ function buildCompressibleRanges(messages, state, config, protectedZoneRefs, cou
     }
     compressibleMsgs = kept;
   }
+  const gapCount = compressibleMsgs.reduce(
+    (s, info) => s + (info.gapBefore ? 1 : 0),
+    0
+  );
+  if (gapCount > 0) {
+    compressibleMsgs = refineSegmentsForFoldability(messages, compressibleMsgs);
+  }
   const compressible = [];
   let cur = null;
   for (const info of compressibleMsgs) {
@@ -2367,6 +2409,41 @@ function buildCompressibleRanges(messages, state, config, protectedZoneRefs, cou
     protected: protectedRanges
   };
 }
+var MAX_REFINEMENT_PASSES = 8;
+function refineSegmentsForFoldability(messages, infos) {
+  let current = infos;
+  for (let pass = 0; pass < MAX_REFINEMENT_PASSES; pass++) {
+    const segments = [];
+    for (const info of current) {
+      const seg = segments[segments.length - 1];
+      if (seg === void 0 || info.gapBefore) segments.push([info]);
+      else seg.push(info);
+    }
+    const removed = /* @__PURE__ */ new Set();
+    for (const seg of segments) {
+      const withdrawn = computeIntegrityWithdrawals(
+        messages,
+        new Set(seg.map((info) => info.id))
+      ).withdrawn;
+      for (const info of seg) {
+        if (withdrawn.has(info.id)) removed.add(info.id);
+      }
+    }
+    if (removed.size === 0) break;
+    let gapPending = false;
+    const kept = [];
+    for (const info of current) {
+      if (removed.has(info.id)) {
+        gapPending = true;
+        continue;
+      }
+      kept.push(gapPending ? { ...info, gapBefore: true } : info);
+      gapPending = false;
+    }
+    current = kept;
+  }
+  return current;
+}
 function mergeBatch(batch) {
   const first = batch[0];
   const last = batch[batch.length - 1];