acp-kernel 0.0.96 → 0.0.97-pr.466.328

package/dist/instance-reid.d.ts

@@ -1,30 +1,52 @@
 import type { CompressionState, CoreMessage } from "./types.js";
 /**
- * Re-mint live messages whose id collides with an already-FOLDED copy of the same
- * content (billion-context #1476). Runs as the FIRST pipeline node, before
- * assign-refs and prune, so the re-minted id is what gets ref'd and what prune sees.
+ * Re-mint live messages whose content identity collides with an already-FOLDED
+ * copy (#1476) — unless the collision is the host positionally replaying the
+ * very originals the block was folded from (#461). Runs as the FIRST pipeline
+ * node, before assign-refs and sync-blocks, so the id that survives this node
+ * is what gets ref'd, what sync sees, and what prune sees.
  *
- * Root cause: deriveMessageId's cluster counter restarts every conversion pass, so
- * text re-sent after its earlier copy was folded re-derives the SAME bare `h_…` id.
- * From that single collision: assignRefs is first-wins (`if (map.byRaw[id]) continue`)
- * and the folded original already owns `byRaw[h_…]`, so the fresh instance gets NO
- * ref; and prune drops any covered id that isn't the pinned first user message, so
- * the fresh user turn silently vanishes upstream.
+ * Two distinct situations produce a live message carrying a covered id:
  *
- * Why "covered base" is the discriminator: a base is covered iff an active block
- * lists it in effectiveMessageIds, i.e. its original is off the wire (replaced by a
- * summary). So any LIVE message carrying a covered id is a new instance, not the
- * original — and must get a distinct instance id. A NON-covered base keeps the
- * converter's numbering untouched: that is the shape where the old copy is still on
- * the wire and un-folded, where the in-pass occurrence count already keeps the pair
- * distinct, and touching the ids would only churn the prefix cache. Do not broaden
- * this to all bases.
+ *   1. POSITIONAL REPLAY (#461). Hosts that compress server-side resend their
+ *      FULL raw history each request; after a fold the next request carries the
+ *      folded originals verbatim and their deterministic ids re-derive
+ *      identically (the cluster counter restarts per pass). Those resends ARE
+ *      the originals: they must keep their ids so prune drops them and the
+ *      rendered summary takes their place at the anchor (the pre-0.0.96
+ *      contract). Re-minting them lets the folded content back onto the wire
+ *      every turn, deactivates the block, and starves the summary of its
+ *      carrier.
+ *   2. GENUINELY NEW INSTANCE (#1476). A fresh message matching folded content
+ *      re-derives the SAME bare id in a pass where the original is not
+ *      positionally resent (pruned view carrying the rendered summary, trimmed
+ *      history, …). It must get a distinct instance id or assignRefs
+ *      (first-wins on byRaw) starves it of a ref and prune silently deletes it.
  *
- * For each conflicting root, live instances are renumbered in arrival order to
- * root_1, root_2, … skipping any number a folded copy already claims. Deterministic
- * for a fixed (state, body): a live message whose root stays covered keeps the same
- * _k every turn (prefix-cache stable) and shifts only when a newer identical
- * instance joins the pass.
+ * The kernel cannot ask the host which case applies (no Ports surface), so the
+ * positional fingerprint distinguishes them deterministically: a block is
+ * REPLAYING when its rendered summary is absent AND every one of its covered
+ * bases is present — only a full resend of the folded population produces that
+ * shape. An occurrence under exclusively-replaying coverage keeps its id —
+ * note the single-base shape (its one covered base present, summary absent)
+ * IS replaying: the proxy-mode echo of a one-message fold. Only the other
+ * shapes (summary present, or a covered base missing while another
+ * representation keeps the block present) are treated as new instances and
+ * re-minted — erring toward shipping a duplicate rather than deleting a user
+ * turn.
+ *
+ * Coverage is judged per sync's own activation predicate (isBlockStillPresent,
+ * recomputed against THIS input) rather than the stored `active` flag: a block
+ * deactivated last turn (view lacked both raws and summary) reactivates this
+ * turn when the summary returns, and its coverage must already be visible here
+ * or a colliding new instance slips through un-minted and gets pruned.
+ * Consumed (tier-folded) and expanded blocks never cover.
+ *
+ * For each conflicting root, only the classified new instances are renumbered,
+ * in arrival order, to root_1, root_2, … skipping any number a folded copy
+ * claims and any number retained by a group member that keeps its id. Non-
+ * conflicting members are never touched (their refs must not churn).
+ * Deterministic for a fixed (state, body).
  */
 export declare function remintCoveredLiveIds(messages: CoreMessage[], state: CompressionState): CoreMessage[];
 //# sourceMappingURL=instance-reid.d.ts.map

package/dist/instance-reid.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instance-reid.d.ts","sourceRoot":"","sources":["../src/instance-reid.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAahE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,WAAW,EAAE,EACvB,KAAK,EAAE,gBAAgB,GACtB,WAAW,EAAE,CAiCf"}
+{"version":3,"file":"instance-reid.d.ts","sourceRoot":"","sources":["../src/instance-reid.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAmBhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,WAAW,EAAE,EACvB,KAAK,EAAE,gBAAgB,GACtB,WAAW,EAAE,CAwFf"}

package/dist/sync.d.ts

@@ -1,7 +1,16 @@
-import type { CompressionState, CoreMessage } from "./types.js";
+import type { CompressionBlock, CompressionState, CoreMessage } from "./types.js";
 export interface SyncResult {
     state: CompressionState;
     deactivated: string[];
 }
+/**
+ * Whether a block still has any visible representation in a message pass: at
+ * least one of its covered raws is present (matched by base id, so sub-id
+ * projections count), or its rendered summary is. A block whose raw messages
+ * were replaced by its rendered summary (pruned view) is still present — the
+ * summary IS the block's visible representation. Without this, hosts passing
+ * pruned views would lose block activity every turn.
+ */
+export declare function isBlockStillPresent(block: CompressionBlock, presentBases: ReadonlySet<string>, presentIds: ReadonlySet<string>): boolean;
 export declare function syncBlocks(messages: CoreMessage[], state: CompressionState): SyncResult;
 //# sourceMappingURL=sync.d.ts.map

package/dist/sync.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../src/sync.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEhE,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,gBAAgB,CAAC;IACxB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAED,wBAAgB,UAAU,CACxB,QAAQ,EAAE,WAAW,EAAE,EACvB,KAAK,EAAE,gBAAgB,GACtB,UAAU,CAyFZ"}
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../src/sync.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,gBAAgB,EAChB,gBAAgB,EAChB,WAAW,EACZ,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,gBAAgB,CAAC;IACxB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,gBAAgB,EACvB,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,EACjC,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC,GAC9B,OAAO,CAKT;AAED,wBAAgB,UAAU,CACxB,QAAQ,EAAE,WAAW,EAAE,EACvB,KAAK,EAAE,gBAAgB,GACtB,UAAU,CAkFZ"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "acp-kernel",
-  "version": "0.0.96",
+  "version": "0.0.97-pr.466.328",
   "description": "Framework-agnostic context-compression engine (model-driven, 3-tier LSM). Pure core: no host dependency.",
   "license": "MIT",
   "author": "ranxianglei",