acp-kernel 0.0.41 → 0.0.42-pr.136.3

package/dist/wire/compress-detect.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Compress-call detection and replay-guard on the wire/core stream
+ * (Phase K2, moved from billion-context-omp `src/wire-fold.ts`).
+ *
+ * Two layers:
+ *  - Detection: `compressToolArgs` accepts the two call shapes that exist in
+ *    the wild (direct `compress`; legacy `write` to `xd://compress`, args
+ *    JSON-encoded one or two levels deep), `findCompressCalls` /
+ *    `findCompressCallsCore` turn a stream tool-call into validated ranges.
+ *  - Guard: when compression state is REPLAYED against a rebuilt stream
+ *    (restart, mirror divergence, host re-serialization), every recorded
+ *    range must prove it still covers the same content — fingerprint match
+ *    (first/last piece content key), position fallback for drifted
+ *    boundaries, remap for dangling m-refs.
+ *
+ * Pure functions over BiliMessage/CoreMessage — no host types, no I/O.
+ */
+import type { CoreMessage } from "../types.js";
+import type { BiliMessage } from "./bili-message.js";
+/** A compress call carried by a stream tool-call, normalized to validated
+ *  ranges. `id` is the tool-call id (replay dedup key). */
+export interface StreamCompressCall {
+    id: string;
+    ranges: {
+        startRef: string;
+        endRef: string;
+        summary: string;
+        topic?: string;
+        summaryMaxChars?: number;
+        compressCallId: string;
+    }[];
+}
+/** Extract a compress tool's arguments from a stream toolCall. Two call
+ *  shapes exist: (1) top-level — the tools are registered with
+ *  loadMode:"essential" so hosts do NOT mount them as xd:// devices; the
+ *  stream shows name:"compress" directly. (2) legacy xd:// — sessions
+ *  recorded before that change (or hosts forcing discoverable mounting)
+ *  invoked compress through the write tool with path "xd://compress" and
+ *  the tool args JSON-encoded in the content field. Both shapes must replay
+ *  from the stream. Returns normalized compress args (content array plus
+ *  optional topic / summaryMaxChars from wherever they live). */
+export declare function compressToolArgs(call: {
+    name: string;
+    arguments?: unknown;
+}): {
+    content: unknown[];
+    topic?: unknown;
+    summaryMaxChars?: unknown;
+} | null;
+/** toolCallId → toolName for every tool-call piece (protected-piece
+ *  detection: compress + configured tools are never folded). */
+export declare function toolCallNames(msgs: BiliMessage[]): Map<string, string>;
+/** toolCallId → result text for every tool-result piece (compress result
+ *  rendering inside rebuilt payloads). */
+export declare function toolResultTextsCore(msgs: BiliMessage[]): Map<string, string>;
+/** Compress calls carried by a core tool-call piece. Same two shapes as the
+ *  AgentMessage stream (direct compress; legacy xd://compress via write),
+ *  with the arguments JSON-encoded in the piece's text. */
+export declare function findCompressCallsCore(msg: BiliMessage): StreamCompressCall[];
+/** Content key of a core piece for span fingerprints (issue #91): role,
+ *  contentType, toolName and the FIRST 4096 chars of text. The 4096 cap is
+ *  deliberate: a host re-serialization that drifts only the tail (beyond
+ *  char 4096, e.g. truncation of a long tool output) keeps the key intact,
+ *  so the replay guard tells a benign tail drift from a genuine rewrite. */
+export declare function corePieceKey(cm: CoreMessage): string;
+/** Span fingerprint in content-hash space: hash the content keys of the
+ *  exact first/last covered pieces. Boundary ids are pre-resolved (byRef /
+ *  block lookup) — unlike the pN-space spanFingerprint there is no position
+ *  parsing, ids are unique per piece. */
+export declare function spanFingerprintCore(coreMessages: CoreMessage[], startId: string, endId: string): string;
+/** Index-based span fingerprint (issue #91 replay fallback): hash the content
+ *  keys of the pieces AT the given stream positions. The stored fp still
+ *  decides keep/drop — the position is only a recovery hint for a drifted
+ *  boundary whose content-hash id no longer matches, so a benign tail drift
+ *  (first-4096 intact) is kept while a real rewrite mismatches. */
+export declare function spanFingerprintCoreIdx(coreMessages: CoreMessage[], startIdx: number, endIdx: number): string;
+/** Structural subset the boundary resolvers need from a compression block
+ *  (kernel CompressionBlock satisfies this; keeps the guard usable from
+ *  downstreams that carry lighter block records). */
+export interface BlockLike {
+    blockId: string;
+    effectiveMessageIds: string[];
+}
+/** Resolve a range boundary to the exact id of the piece it names, in
+ *  content-hash space. Message refs go through byRef; block refs resolve to
+ *  the earliest (min) or latest (max) covered piece by STREAM ORDER
+ *  (index in coreMessages — the hash ids carry no position). */
+export declare function boundaryRawCore(ref: string, byRef: Record<string, string>, blocks: BlockLike[], coreMessages: CoreMessage[], pick: "min" | "max"): string;
+/** Resolve a range boundary to its STREAM INDEX in content-hash space. byRef /
+ *  block lookup first (the exact piece it names, by array order); on a missed
+ *  id (a drift re-hashed the piece so its carried ref dangles) fall back to
+ *  the compress-time recorded index — the position hint, issue #91. -1 =
+ *  unresolvable. */
+export declare function boundaryIndexCore(ref: string, byRef: Record<string, string>, blocks: BlockLike[], coreMessages: CoreMessage[], pick: "min" | "max", fallbackIdx?: number): number;
+/** Structured replay-guard verdict (issue #91, rework): the position
+ *  fallback recovers the STREAM INDEX of a drifted boundary, but the kernel
+ *  resolves ranges by REF — so when a recorded m-ref dangles, the replay
+ *  must re-apply that boundary under the CURRENT ref of the recovered piece.
+ *  `remap` carries exactly that (only dangling m-refs are remapped; block
+ *  refs resolve themselves inside the kernel and are never touched). */
+export type ReplayRangeVerdict = {
+    /** Stale: the range must be dropped (master semantics, unchanged). */
+    reject?: string;
+    /** Dangling m-refs recovered by position, remapped to current refs. */
+    remap?: {
+        startRef?: string;
+        endRef?: string;
+    };
+    /** True when the result text carried a [pos=] pair for this range —
+     *  with `reject` set it marks a RECOVERY FAILURE (always logged). */
+    hint?: boolean;
+    /** Diagnostics — always logged when a recovery happens. */
+    recovered?: {
+        pos: string;
+        startIdx: number;
+        endIdx: number;
+    };
+};
+/** Current m-ref of the piece at stream index idx (inverse byRef scan).
+ *  "" when the piece has no ref (protected) — the replay must fail closed
+ *  rather than hand the kernel a ref it does not know. Replay-time only
+ *  (replayed compress calls), so the O(refs) scan stays off the hot path. */
+export declare function refOfPieceCore(coreMessages: BiliMessage[], idx: number, byRef: Record<string, string>): string;
+export declare function staleRangeCore(r: {
+    startRef: string;
+    endRef: string;
+}, rangeIndex: number, resultText: string, coreMessages: BiliMessage[], callIndex: number, byRef: Record<string, string>, blocks: BlockLike[]): ReplayRangeVerdict;
+/** One fingerprint per range for the replay guard, content-hash space
+ *  (mirrors rangeFingerprints for the pN space). */
+export declare function rangeFingerprintsCore(ranges: Array<{
+    startRef: string;
+    endRef: string;
+}>, coreMessages: BiliMessage[], byRef: Record<string, string>, blocks: BlockLike[]): string[];
+/** One boundary-index pair per range for the replay fallback (issue #91),
+ *  aligned with rangeFingerprintsCore: the stream index of each range's exact
+ *  first/last covered piece at record time ("-1" pair when a boundary can't
+ *  be positioned), so the replay can recover a drifted boundary by position. */
+export declare function rangePositionsCore(ranges: Array<{
+    startRef: string;
+    endRef: string;
+}>, coreMessages: CoreMessage[], byRef: Record<string, string>, blocks: BlockLike[]): string[];
+//# sourceMappingURL=compress-detect.d.ts.map

package/dist/wire/compress-detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compress-detect.d.ts","sourceRoot":"","sources":["../../src/wire/compress-detect.ts"],"names":[],"mappings":"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"}

package/dist/wire/index.d.ts

@@ -7,4 +7,5 @@ export * from "./message-id.js";
 export * from "./demoted-thinking.js";
 export * from "./mirror.js";
 export * from "./util.js";
+export * from "./compress-detect.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/wire/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/wire/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/wire/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,sBAAsB,CAAC"}

package/dist/wire/index.js

@@ -919,15 +919,194 @@ function mirrorResponsesToCore(view, systemText) {
   });
   return msgs;
 }
+
+// src/wire/compress-detect.ts
+import { createHash as createHash2 } from "crypto";
+function compressToolArgs(call) {
+  let args = call.arguments;
+  if (typeof args === "string") {
+    try {
+      args = JSON.parse(args);
+    } catch {
+      return null;
+    }
+  }
+  if (!args || typeof args !== "object" || Array.isArray(args)) return null;
+  const a = args;
+  if (call.name === "compress") {
+    return Array.isArray(a.content) ? { content: a.content, topic: a.topic, summaryMaxChars: a.summaryMaxChars } : null;
+  }
+  if (call.name !== "write") return null;
+  const path = typeof a.path === "string" ? a.path.split("?")[0].replace(/\/+$/, "") : "";
+  if (path !== "xd://compress") return null;
+  let inner = a.content;
+  if (typeof inner === "string") {
+    try {
+      inner = JSON.parse(inner);
+    } catch {
+      return null;
+    }
+  }
+  if (!inner || typeof inner !== "object") return null;
+  if (Array.isArray(inner)) return { content: inner };
+  const ia = inner;
+  return Array.isArray(ia.content) ? { content: ia.content, topic: ia.topic, summaryMaxChars: ia.summaryMaxChars } : { content: [ia] };
+}
+function toolCallNames(msgs) {
+  const names = /* @__PURE__ */ new Map();
+  for (const m of msgs) {
+    if (m.contentType === "tool-call" && m.toolCallId && m.toolName) names.set(m.toolCallId, m.toolName);
+  }
+  return names;
+}
+function toolResultTextsCore(msgs) {
+  const results = /* @__PURE__ */ new Map();
+  for (const m of msgs) {
+    if (m.contentType !== "tool-result" || !m.toolCallId) continue;
+    results.set(m.toolCallId, m.text ?? "");
+  }
+  return results;
+}
+function findCompressCallsCore(msg) {
+  if (msg.contentType !== "tool-call" || !msg.toolName) return [];
+  const args = compressToolArgs({ name: msg.toolName, arguments: msg.text });
+  if (!args) return [];
+  const content = args.content;
+  if (!Array.isArray(content)) return [];
+  const ranges = [];
+  const callTopic = typeof args.topic === "string" ? args.topic : void 0;
+  for (const item of content) {
+    const r = item;
+    if (typeof r.startId !== "string" || typeof r.endId !== "string" || typeof r.summary !== "string" || r.summary.length === 0) continue;
+    ranges.push({
+      startRef: r.startId,
+      endRef: r.endId,
+      summary: r.summary,
+      topic: typeof r.topic === "string" ? r.topic : callTopic,
+      summaryMaxChars: typeof args.summaryMaxChars === "number" ? args.summaryMaxChars : void 0,
+      compressCallId: msg.toolCallId ?? ""
+    });
+  }
+  return ranges.length > 0 ? [{ id: msg.toolCallId ?? "", ranges }] : [];
+}
+function corePieceKey(cm) {
+  return `${cm.role}|${cm.contentType}|${cm.toolName ?? ""}|${(cm.text ?? "").slice(0, 4096)}`;
+}
+function spanFingerprintCore(coreMessages, startId, endId) {
+  const find = (id) => coreMessages.find((cm) => cm.id === id);
+  const first = find(startId);
+  const last = find(endId);
+  if (!first || !last) return "";
+  return createHash2("sha1").update(`${corePieceKey(first)}\0${corePieceKey(last)}`).digest("hex").slice(0, 8);
+}
+function spanFingerprintCoreIdx(coreMessages, startIdx, endIdx) {
+  const first = coreMessages[startIdx];
+  const last = coreMessages[endIdx];
+  if (!first || !last) return "";
+  return createHash2("sha1").update(`${corePieceKey(first)}\0${corePieceKey(last)}`).digest("hex").slice(0, 8);
+}
+function boundaryRawCore(ref, byRef, blocks, coreMessages, pick) {
+  const raw = byRef[ref];
+  if (raw) return raw;
+  const m = /^b(\d+)$/i.exec(ref.trim());
+  if (!m) return "";
+  const block = blocks.find((b) => b.blockId.toLowerCase() === `b${m[1]}`);
+  if (!block) return "";
+  const idx = (id) => coreMessages.findIndex((cm) => cm.id === (byRef[id] ?? id));
+  let best = -1;
+  for (const id of block.effectiveMessageIds) {
+    const i = idx(id);
+    if (i < 0) continue;
+    if (best < 0 || (pick === "min" ? i < best : i > best)) best = i;
+  }
+  return best < 0 ? "" : coreMessages[best]?.id ?? "";
+}
+function boundaryIndexCore(ref, byRef, blocks, coreMessages, pick, fallbackIdx = -1) {
+  const id = boundaryRawCore(ref, byRef, blocks, coreMessages, pick);
+  if (id) {
+    const i = coreMessages.findIndex((cm) => cm.id === id);
+    if (i >= 0) return i;
+  }
+  return fallbackIdx >= 0 && fallbackIdx < coreMessages.length ? fallbackIdx : -1;
+}
+function refOfPieceCore(coreMessages, idx, byRef) {
+  const id = coreMessages[idx]?.id;
+  if (!id) return "";
+  for (const [ref, mapped] of Object.entries(byRef)) if (mapped === id) return ref;
+  return "";
+}
+function staleRangeCore(r, rangeIndex, resultText, coreMessages, callIndex, byRef, blocks) {
+  const pm = resultText.match(/\[pos=([0-9,-]+)\]/);
+  const pair = pm ? pm[1].split(",")[rangeIndex] ?? "-" : "-";
+  const hinted = pair !== "-";
+  const [ps, pe] = pair === "-" ? ["", ""] : pair.split("-");
+  const fbStart = ps && ps !== "" ? Number.parseInt(ps, 10) : -1;
+  const fbEnd = pe && pe !== "" ? Number.parseInt(pe, 10) : -1;
+  const startRaw = boundaryRawCore(r.startRef, byRef, blocks, coreMessages, "min");
+  const endRaw = boundaryRawCore(r.endRef, byRef, blocks, coreMessages, "max");
+  const rawStartIdx = startRaw ? coreMessages.findIndex((cm) => cm.id === startRaw) : -1;
+  const rawEndIdx = endRaw ? coreMessages.findIndex((cm) => cm.id === endRaw) : -1;
+  const startIdx = rawStartIdx >= 0 ? rawStartIdx : fbStart >= 0 && fbStart < coreMessages.length ? fbStart : -1;
+  const endIdx = rawEndIdx >= 0 ? rawEndIdx : fbEnd >= 0 && fbEnd < coreMessages.length ? fbEnd : -1;
+  if (startIdx < 0 || endIdx < 0) {
+    if (!/^b\d+$/i.test(r.startRef.trim()) && !/^b\d+$/i.test(r.endRef.trim()))
+      return { reject: `unresolved ${r.startRef}..${r.endRef} -> ${startIdx}..${endIdx}`, ...hinted ? { hint: true } : {} };
+    return {};
+  }
+  if (endIdx > callIndex) return { reject: `end idx ${endIdx} > callIndex ${callIndex}`, ...hinted ? { hint: true } : {} };
+  const m = resultText.match(/\[fp=([0-9a-f,-]+)\]/);
+  if (m) {
+    const want = m[1].split(",")[rangeIndex];
+    if (want !== void 0 && want !== "-") {
+      const got = spanFingerprintCoreIdx(coreMessages, startIdx, endIdx);
+      if (want !== got) return { reject: `fp ${r.startRef}..${r.endRef} want ${want} got ${got} @${startIdx}..${endIdx}`, ...hinted ? { hint: true } : {} };
+    }
+  }
+  const remap = {};
+  if (/^m\d+$/i.test(r.startRef.trim()) && rawStartIdx < 0) {
+    const ref = refOfPieceCore(coreMessages, startIdx, byRef);
+    if (!ref) return { reject: `recovered ${r.startRef} @${startIdx} has no ref (protected piece)`, ...hinted ? { hint: true } : {} };
+    remap.startRef = ref;
+  }
+  if (/^m\d+$/i.test(r.endRef.trim()) && rawEndIdx < 0) {
+    const ref = refOfPieceCore(coreMessages, endIdx, byRef);
+    if (!ref) return { reject: `recovered ${r.endRef} @${endIdx} has no ref (protected piece)`, ...hinted ? { hint: true } : {} };
+    remap.endRef = ref;
+  }
+  if (!remap.startRef && !remap.endRef) return {};
+  return { remap, recovered: { pos: pair, startIdx, endIdx } };
+}
+function rangeFingerprintsCore(ranges, coreMessages, byRef, blocks) {
+  return ranges.map((r) => {
+    const start = boundaryRawCore(r.startRef, byRef, blocks, coreMessages, "min");
+    const end = start ? boundaryRawCore(r.endRef, byRef, blocks, coreMessages, "max") : "";
+    if (start && end) {
+      const fp = spanFingerprintCore(coreMessages, start, end);
+      if (fp.length > 0) return fp;
+    }
+    return "-";
+  });
+}
+function rangePositionsCore(ranges, coreMessages, byRef, blocks) {
+  return ranges.map((r) => {
+    const s = boundaryIndexCore(r.startRef, byRef, blocks, coreMessages, "min");
+    const e = s >= 0 ? boundaryIndexCore(r.endRef, byRef, blocks, coreMessages, "max") : -1;
+    return s >= 0 && e >= 0 ? `${s}-${e}` : "-";
+  });
+}
 export {
   ClusterCounter,
   WIRE_FORMATS,
   anthropicToCore,
+  boundaryIndexCore,
+  boundaryRawCore,
   buildSystem,
+  compressToolArgs,
   conversationIdentityResponses,
   conversationSignalAnthropic,
   conversationSignalOpenai,
   conversationSignalResponses,
+  corePieceKey,
   coreToAnthropic,
   coreToOpenai,
   coreToResponses,
@@ -935,6 +1114,7 @@ export {
   deriveMessageId,
   detectWireFormat,
   extractSystem,
+  findCompressCallsCore,
   hashId,
   injectOpenaiSystem,
   injectResponsesDeveloperMessage,
@@ -948,9 +1128,17 @@ export {
   openaiToCore,
   parseDataUrl,
   patchResponsesInput,
+  rangeFingerprintsCore,
+  rangePositionsCore,
+  refOfPieceCore,
   responsesToCore,
+  spanFingerprintCore,
+  spanFingerprintCoreIdx,
   splitDemotedThinking,
+  staleRangeCore,
   subagentNamespace,
-  toCoreMessages
+  toCoreMessages,
+  toolCallNames,
+  toolResultTextsCore
 };
 //# sourceMappingURL=index.js.map