acp-kernel 0.0.62 → 0.0.63-pr.229.94

package/dist/reasoning-pairs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reasoning-pairs.d.ts","sourceRoot":"","sources":["../src/reasoning-pairs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,iCAAiC,CAC/C,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,WAAW,EAAE,GACtB;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAwD1C"}
+{"version":3,"file":"reasoning-pairs.d.ts","sourceRoot":"","sources":["../src/reasoning-pairs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,iCAAiC,CAC/C,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,WAAW,EAAE,GACtB;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAoE1C"}

package/dist/search/algorithms/hybrid.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hybrid.d.ts","sourceRoot":"","sources":["../../../src/search/algorithms/hybrid.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAA0B,MAAM,aAAa,CAAC;AAwB3E,eAAO,MAAM,eAAe,EAAE,eAe7B,CAAC"}
+{"version":3,"file":"hybrid.d.ts","sourceRoot":"","sources":["../../../src/search/algorithms/hybrid.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAA0B,MAAM,aAAa,CAAC;AAwB3E,eAAO,MAAM,eAAe,EAAE,eAgB7B,CAAC"}

package/dist/search/doc-cache.d.ts

@@ -4,16 +4,38 @@
  * A search over the compressed history re-scores the SAME immutable docs on
  * every call — compressed block summaries and folded message text never
  * change. Without this cache, every search_context call re-tokenized the
- * entire corpus (segmenter CJK pass ≈ 0.3s/MB cold) plus re-lowercased it
- * and rebuilt the bigram set for each channel: a 5MB session cost ~3s PER
- * CALL, growing linearly with session length. With the cache the corpus is
- * processed once; later searches are O(docs × query-terms).
+ * entire corpus (segmenter pass ≈ 0.1–0.6s/MB cold, content-dependent) plus
+ * re-lowercased it and rebuilt the bigram set for each channel: a 5MB session
+ * cost seconds PER CALL, growing linearly with session length. With the cache
+ * the corpus is processed once; later searches are O(docs × query-terms).
  *
- * Keyed by doc text (immutable). Bounded by total cached source chars —
- * oldest docs are evicted when the cap is exceeded, so a long-lived
- * process serving many sessions cannot grow unboundedly. Hosts that want to
- * release the memory eagerly on session shutdown/switch can call
- * clearDocFeatures() (optional: the cap already bounds it).
+ * Keyed by doc text (immutable), bounded by total cached SOURCE CHARS. Eviction
+ * is least-recently-used: a hit re-inserts the doc at the tail, so the docs a
+ * host keeps re-touching are retained. LRU helps when access is HETEROGENEOUS
+ * (a hot subset across many queries; a long-lived multi-session process). It
+ * does NOT help when every call re-scans the ENTIRE corpus below the cap — no
+ * hot subset exists, the window slides past every doc each call, and
+ * (corpus − cap) is re-tokenized every time.
+ *
+ * Sizing consequence: if your corpus exceeds the cap and each search rescans
+ * it whole, the ONLY setting that stops re-tokenization is
+ * setDocCacheCap(≥ corpus) (or Infinity). Do NOT lower the cap to save memory
+ * there — it trades bounded memory for a full re-tokenize of the excess on
+ * EVERY call. The default (8MB) suits hosts running many sessions that cannot
+ * afford to pin one corpus.
+ *
+ * The cap is in SOURCE CHARS, a loose proxy for retained heap: feature memory
+ * scales with DISTINCT token/bigram count, content-dependent (≈ 2×–49× per
+ * source char, latin prose → high-entropy CJK). The cap bounds billed chars,
+ * not a hard memory limit.
+ *
+ * The cap is MODULE-GLOBAL — setDocCacheCap() sets process-wide state shared
+ * by every acp-kernel consumer in the process. Fine while one consumer runs
+ * per process; a per-scope cache (keyed by doc ref) would let a host scope a
+ * cap to one session instead (see #227).
+ *
+ * Hosts that want to release the memory eagerly on session shutdown/switch
+ * can call clearDocFeatures() (optional: the cap already bounds it).
  */
 export interface DocFeatures {
     /** Stemmed term frequencies (BM25 channel). */
@@ -30,7 +52,9 @@ export declare function docFeatures(text: string): DocFeatures;
 export declare function clearDocFeatures(): void;
 /**
  * Set the cache cap in source chars. Docs larger than the cap are never
- * cached. Also used by tests to exercise eviction.
+ * cached. Pass a value ≥ the corpus size (or Infinity) to cache the whole
+ * corpus — a single-session host then avoids re-tokenizing on every call.
+ * Also used by tests to exercise eviction.
  */
 export declare function setDocCacheCap(chars: number): void;
 /** Cache occupancy — for diagnostics. */

package/dist/search/doc-cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"doc-cache.d.ts","sourceRoot":"","sources":["../../src/search/doc-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,MAAM,WAAW,WAAW;IACxB,+CAA+C;IAC/C,EAAE,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxB,oDAAoD;IACpD,GAAG,EAAE,MAAM,CAAC;IACZ,qDAAqD;IACrD,KAAK,EAAE,MAAM,CAAC;IACd,sDAAsD;IACtD,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACtB;AAeD,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAcrD;AAED,kEAAkE;AAClE,wBAAgB,gBAAgB,IAAI,IAAI,CAGvC;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAOlD;AAED,yCAAyC;AACzC,wBAAgB,YAAY,IAAI;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAEjE"}
+{"version":3,"file":"doc-cache.d.ts","sourceRoot":"","sources":["../../src/search/doc-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAIH,MAAM,WAAW,WAAW;IACxB,+CAA+C;IAC/C,EAAE,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxB,oDAAoD;IACpD,GAAG,EAAE,MAAM,CAAC;IACZ,qDAAqD;IACrD,KAAK,EAAE,MAAM,CAAC;IACd,sDAAsD;IACtD,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACtB;AAeD,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAmBrD;AAED,kEAAkE;AAClE,wBAAgB,gBAAgB,IAAI,IAAI,CAGvC;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAOlD;AAED,yCAAyC;AACzC,wBAAgB,YAAY,IAAI;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAEjE"}

package/dist/turn-integrity.d.ts

@@ -0,0 +1,23 @@
+import type { CoreMessage } from "./types.js";
+/**
+ * Atomic turn groups for compression integrity (#684).
+ *
+ * A turn is a reasoning run, the assistant text/tool-call burst that follows
+ * it, and every tool-result paired (by toolCallId) to the burst's calls.
+ * Strict-echo thinking providers (DeepSeek: "The `reasoning_content` in the
+ * thinking mode must be passed back to the API") reject a rebuilt request
+ * whose assistant tool-call turn survives without its reasoning, and every
+ * OpenAI-wire provider rejects a result whose call is gone. Turns are
+ * therefore atomic for folding: all members fold together, or none do.
+ *
+ * Grouping is adjacency-based, mirroring {@link adjustBoundariesForReasoningPairs}:
+ * a reasoning run pairs with the assistant burst immediately following it.
+ * Bursts without a preceding reasoning run still group with their sibling
+ * calls and results. Messages belonging to no turn (user messages, system,
+ * orphan reasoning, summaries) get no group — they carry no pairing
+ * constraint. Groups are disjoint.
+ *
+ * @returns disjoint member-id arrays; a message appears in at most one group.
+ */
+export declare function computeTurnGroups(messages: CoreMessage[]): string[][];
+//# sourceMappingURL=turn-integrity.d.ts.map

package/dist/turn-integrity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn-integrity.d.ts","sourceRoot":"","sources":["../src/turn-integrity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAS9C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,MAAM,EAAE,EAAE,CA2ErE"}

package/package.json

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