@remnic/core 9.69.46 → 9.69.47

package/dist/chunk-LI4APB6M.js

@@ -0,0 +1,218 @@
+import {
+  coerceBooleanLike,
+  coerceNumber
+} from "./chunk-PQVCH2AE.js";
+
+// src/standing-memory-block.ts
+var DEFAULT_RECALL_STANDING_BLOCK = false;
+var DEFAULT_STANDING_BLOCK_FRESH_DAYS = 14;
+var DEFAULT_STANDING_BLOCK_MAX_CHARS = 2048;
+var DEFAULT_STANDING_BLOCK_HOOK_CHARS = 96;
+var STANDING_BLOCK_HEADER = "## Standing Memory (Remnic)";
+var STANDING_BLOCK_INSTRUCTION = "Use this standing index for orientation. It changes only when the memory store changes.";
+var STANDING_BLOCK_TRIMMED_MARKER = "- ...(older lines trimmed)";
+function standingHookLedgerKey(description, hookMaxChars) {
+  return `${description}\0${hookMaxChars}`;
+}
+var ISO_DATE_RE = /\b\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2})?/;
+var CLOCK_TIME_RE = /\b\d{1,2}:\d{2}(?::\d{2})?\b/;
+var RELATIVE_DATE_RE = /\b(?:today|tonight|tomorrow|yesterday|this\s+(?:morning|afternoon|evening|week|month|year))\b/i;
+var COUNTER_RE = /\b(?:count|total|entries|memories|items)\s*[:=]\s*\d+\b/i;
+function lintStandingBlockVolatility(text) {
+  const matches = [];
+  for (const [kind, re] of [
+    ["iso-date", ISO_DATE_RE],
+    ["clock-time", CLOCK_TIME_RE],
+    ["relative-date", RELATIVE_DATE_RE],
+    ["counter", COUNTER_RE]
+  ]) {
+    const hit = text.match(re);
+    if (hit) matches.push({ kind, token: hit[0] });
+  }
+  return matches;
+}
+var StandingBlockError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "StandingBlockError";
+  }
+};
+var StandingBlockVolatilityError = class extends StandingBlockError {
+  matches;
+  constructor(matches) {
+    super(
+      `standing memory block refused: volatile content busts the prefix cache (${matches.map((m) => `${m.kind}:${JSON.stringify(m.token)}`).join(", ")})`
+    );
+    this.name = "StandingBlockVolatilityError";
+    this.matches = matches;
+  }
+};
+var StandingBlockBudgetError = class extends StandingBlockError {
+  constructor(maxChars) {
+    super(
+      `standing memory block does not fit: pinned lines alone exceed maxChars=${maxChars}; raise standingBlockMaxChars or unpin entries`
+    );
+    this.name = "StandingBlockBudgetError";
+  }
+};
+function parseRecallStandingBlock(raw) {
+  return coerceBooleanLike(raw, "recallStandingBlock") === true;
+}
+function parseStandingBlockFreshDays(raw) {
+  if (raw === void 0 || raw === null) return DEFAULT_STANDING_BLOCK_FRESH_DAYS;
+  const n = coerceNumber(raw, "standingBlockFreshDays");
+  if (n === void 0 || !Number.isFinite(n) || n < 0) {
+    throw new Error(`Invalid standingBlockFreshDays: expected a number >= 0, got ${JSON.stringify(raw)}`);
+  }
+  return n;
+}
+function parseStandingBlockMaxChars(raw) {
+  if (raw === void 0 || raw === null) return DEFAULT_STANDING_BLOCK_MAX_CHARS;
+  const n = coerceNumber(raw, "standingBlockMaxChars");
+  if (n === void 0 || !Number.isFinite(n) || n < 1) {
+    throw new Error(`Invalid standingBlockMaxChars: expected an integer >= 1, got ${JSON.stringify(raw)}`);
+  }
+  return Math.floor(n);
+}
+function mechanicalHook(description, budget) {
+  if (description.length <= budget) return description;
+  const cut = description.slice(0, budget);
+  const lastSpace = cut.lastIndexOf(" ");
+  const base = lastSpace > Math.floor(budget * 0.6) ? cut.slice(0, lastSpace) : cut;
+  return `${base.replace(/[\s,;:]+$/, "")}...`;
+}
+var BAND_RANK = { pinned: 0, fresh: 1, compressed: 2 };
+function validateEntries(entries) {
+  if (!Array.isArray(entries)) {
+    throw new StandingBlockError("standing memory block entries must be an array");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const validated = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (typeof entry !== "object" || entry === null) {
+      throw new StandingBlockError(`standing memory block entry must be an object, got ${JSON.stringify(entry)}`);
+    }
+    const id = typeof entry.id === "string" ? entry.id.trim() : "";
+    const description = typeof entry.description === "string" ? entry.description.trim() : "";
+    if (id.length === 0) {
+      throw new StandingBlockError("standing memory block entry requires a non-empty id");
+    }
+    if (description.length === 0) {
+      throw new StandingBlockError(`standing memory block entry ${id} requires a non-empty description`);
+    }
+    if (seen.has(id)) {
+      throw new StandingBlockError(`standing memory block entry ids must be unique; duplicate: ${id}`);
+    }
+    if (entry.lastChangedAt !== void 0 && Number.isNaN(Date.parse(entry.lastChangedAt))) {
+      throw new StandingBlockError(
+        `standing memory block entry ${id} has an unparseable lastChangedAt: ${JSON.stringify(entry.lastChangedAt)}`
+      );
+    }
+    seen.add(id);
+    validated.set(id, { ...entry, id, description });
+  }
+  return validated;
+}
+function buildStandingMemoryBlock(input) {
+  const freshDays = input.freshDays ?? DEFAULT_STANDING_BLOCK_FRESH_DAYS;
+  const maxChars = input.maxChars ?? DEFAULT_STANDING_BLOCK_MAX_CHARS;
+  const hookMaxChars = input.hookMaxChars ?? DEFAULT_STANDING_BLOCK_HOOK_CHARS;
+  if (!Number.isFinite(input.nowMs)) {
+    throw new StandingBlockError("standing memory block requires a finite nowMs");
+  }
+  if (!(freshDays >= 0) || !Number.isFinite(freshDays)) {
+    throw new StandingBlockError("standing memory block requires freshDays >= 0");
+  }
+  if (!(maxChars >= 1) || !Number.isFinite(maxChars)) {
+    throw new StandingBlockError("standing memory block requires maxChars >= 1");
+  }
+  if (!(hookMaxChars >= 1) || !Number.isFinite(hookMaxChars)) {
+    throw new StandingBlockError("standing memory block requires hookMaxChars >= 1");
+  }
+  const entries = validateEntries(input.entries);
+  const ledger = new Map(input.ledger ?? []);
+  if (entries.size === 0) {
+    return {
+      text: "",
+      lines: [],
+      ledger,
+      bandCounts: { pinned: 0, fresh: 0, compressed: 0, dropped: 0 }
+    };
+  }
+  const freshCutoff = input.nowMs - freshDays * 864e5;
+  const layered = [];
+  for (const entry of entries.values()) {
+    let band;
+    if (entry.pinned === true) {
+      band = "pinned";
+    } else if (typeof entry.lastChangedAt === "string" && Date.parse(entry.lastChangedAt) >= freshCutoff && Date.parse(entry.lastChangedAt) <= input.nowMs) {
+      band = "fresh";
+    } else {
+      band = "compressed";
+    }
+    if (band !== "compressed") {
+      layered.push({ id: entry.id, band, line: `- ${entry.description}` });
+      continue;
+    }
+    const key = standingHookLedgerKey(entry.description, hookMaxChars);
+    const cached = ledger.get(key);
+    const hook = cached ?? mechanicalHook(entry.description, hookMaxChars);
+    if (cached === void 0) ledger.set(key, hook);
+    layered.push({ id: entry.id, band, line: `- ${hook}` });
+  }
+  layered.sort(
+    (a, b) => BAND_RANK[a.band] - BAND_RANK[b.band] || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)
+  );
+  const render = (keep2, withMarker) => {
+    const body = layered.slice(0, keep2).map((item) => item.line);
+    if (withMarker) body.push(STANDING_BLOCK_TRIMMED_MARKER);
+    const lines = [STANDING_BLOCK_HEADER, "", ...body, "", STANDING_BLOCK_INSTRUCTION];
+    return { text: lines.join("\n"), lines };
+  };
+  const pinnedCount = layered.filter((item) => item.band === "pinned").length;
+  let keep = layered.length;
+  let rendered = render(keep, false);
+  while (rendered.text.length > maxChars && keep > pinnedCount) {
+    keep -= 1;
+    rendered = render(keep, true);
+  }
+  if (rendered.text.length > maxChars) {
+    throw new StandingBlockBudgetError(maxChars);
+  }
+  const volatility = lintStandingBlockVolatility(rendered.text);
+  if (volatility.length > 0) {
+    throw new StandingBlockVolatilityError(volatility);
+  }
+  const kept = layered.slice(0, keep);
+  return {
+    text: rendered.text,
+    lines: rendered.lines,
+    ledger,
+    bandCounts: {
+      pinned: kept.filter((item) => item.band === "pinned").length,
+      fresh: kept.filter((item) => item.band === "fresh").length,
+      compressed: kept.filter((item) => item.band === "compressed").length,
+      dropped: layered.length - keep
+    }
+  };
+}
+
+export {
+  DEFAULT_RECALL_STANDING_BLOCK,
+  DEFAULT_STANDING_BLOCK_FRESH_DAYS,
+  DEFAULT_STANDING_BLOCK_MAX_CHARS,
+  DEFAULT_STANDING_BLOCK_HOOK_CHARS,
+  STANDING_BLOCK_HEADER,
+  STANDING_BLOCK_INSTRUCTION,
+  STANDING_BLOCK_TRIMMED_MARKER,
+  standingHookLedgerKey,
+  lintStandingBlockVolatility,
+  StandingBlockError,
+  StandingBlockVolatilityError,
+  StandingBlockBudgetError,
+  parseRecallStandingBlock,
+  parseStandingBlockFreshDays,
+  parseStandingBlockMaxChars,
+  buildStandingMemoryBlock
+};
+//# sourceMappingURL=chunk-LI4APB6M.js.map

package/dist/chunk-LI4APB6M.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/standing-memory-block.ts"],"sourcesContent":["/**\n * Prefix-cache-stable standing memory block (issue #2971, foundation slice).\n *\n * A standing block is a compact, byte-stable index over pinned/high-value\n * memories that a host injects as the FIRST part of the system prompt, so\n * the LLM prefix cache survives across turns. Measured motivation\n * (distill-kura, local OpenAI-compatible server): an identical 4k-token\n * prefix reprices at 0.14 s vs 0.68 s cold, and one changed word at the\n * front costs the whole cache. So the block contains no clock, no date,\n * and no counter — and the builder REFUSES, at build time, any block that\n * carries one instead of discovering slow turns weeks later.\n *\n * Determinism rules (byte-identical between rebuilds):\n *  - line order is band rank, then id codepoint order — never wall clock,\n *    never insertion order, never locale collation;\n *  - `nowMs` classifies bands but never renders into the text;\n *  - the trimmed-tail marker is a constant string (no count of dropped\n *    lines, which would itself be a counter).\n *\n * Host contract for the full feature (later wiring slices):\n *  - rebuild only when the underlying store changes (store version), not\n *    per turn and not on a timer — band edges must not drift mid-session;\n *  - inject the standing block BEFORE per-turn dynamic recall and any\n *    ticking content (persona with a clock), see docs/config-reference.md;\n *  - selection of which memories qualify (pinned/high-value) happens\n *    before this builder — it only layers and renders what it is given;\n *  - on build failure (volatility, budget) skip injection and log — the\n *    dynamic recall surface must not go blank.\n *\n * Pure: no I/O, inputs never mutated, the returned ledger is a fresh Map.\n */\nimport { coerceBooleanLike, coerceNumber } from \"./connectors/coerce.js\";\n\nexport const DEFAULT_RECALL_STANDING_BLOCK = false;\nexport const DEFAULT_STANDING_BLOCK_FRESH_DAYS = 14;\nexport const DEFAULT_STANDING_BLOCK_MAX_CHARS = 2048;\n/** ~24-token recognition hook at the repo's 4-chars-per-token Latin headroom. */\nexport const DEFAULT_STANDING_BLOCK_HOOK_CHARS = 96;\n\nexport const STANDING_BLOCK_HEADER = \"## Standing Memory (Remnic)\";\nexport const STANDING_BLOCK_INSTRUCTION =\n  \"Use this standing index for orientation. It changes only when the memory store changes.\";\nexport const STANDING_BLOCK_TRIMMED_MARKER = \"- ...(older lines trimmed)\";\n\nexport type StandingBand = \"pinned\" | \"fresh\" | \"compressed\";\n\nexport interface StandingMemoryEntry {\n  /** Stable document id. Total order within a band is id codepoint order. */\n  id: string;\n  /** The one-line description to stand in the index. */\n  description: string;\n  /** Pinned entries render in full, first band, never trimmed away. */\n  pinned?: boolean;\n  /** ISO timestamp of the last content change; drives the fresh band. */\n  lastChangedAt?: string;\n}\n\n/** Cache of compressed hooks keyed on `${description}\\u0000${hookMaxChars}`. */\nexport type StandingHookLedger = ReadonlyMap<string, string>;\n\nexport function standingHookLedgerKey(description: string, hookMaxChars: number): string {\n  return `${description}\\u0000${hookMaxChars}`;\n}\n\nexport interface StandingBlockBandCounts {\n  pinned: number;\n  fresh: number;\n  compressed: number;\n  dropped: number;\n}\n\nexport interface StandingMemoryBlock {\n  /** Full block text (header + lines + instruction). Empty string for no entries. */\n  text: string;\n  /** Lines without a trailing newline; empty for no entries. */\n  lines: string[];\n  /** Ledger including hooks generated this build. Fresh Map; input never mutated. */\n  ledger: StandingHookLedger;\n  bandCounts: StandingBlockBandCounts;\n}\n\nexport type StandingVolatilityKind = \"iso-date\" | \"clock-time\" | \"relative-date\" | \"counter\";\n\nexport interface StandingVolatilityMatch {\n  kind: StandingVolatilityKind;\n  token: string;\n}\n\nconst ISO_DATE_RE = /\\b\\d{4}-\\d{2}-\\d{2}(?:[T ]\\d{2}:\\d{2})?/;\nconst CLOCK_TIME_RE = /\\b\\d{1,2}:\\d{2}(?::\\d{2})?\\b/;\nconst RELATIVE_DATE_RE =\n  /\\b(?:today|tonight|tomorrow|yesterday|this\\s+(?:morning|afternoon|evening|week|month|year))\\b/i;\nconst COUNTER_RE = /\\b(?:count|total|entries|memories|items)\\s*[:=]\\s*\\d+\\b/i;\n\n/**\n * Build-time volatility lint. Returns every cache-busting token class found:\n * ISO dates/datetimes, clock times, relative date words, and index counters.\n * Refusal is the designed behavior (a memory surface skips the block and\n * logs) — a silently repricing prefix is the failure this catches.\n */\nexport function lintStandingBlockVolatility(text: string): StandingVolatilityMatch[] {\n  const matches: StandingVolatilityMatch[] = [];\n  for (const [kind, re] of [\n    [\"iso-date\", ISO_DATE_RE],\n    [\"clock-time\", CLOCK_TIME_RE],\n    [\"relative-date\", RELATIVE_DATE_RE],\n    [\"counter\", COUNTER_RE],\n  ] as const) {\n    const hit = text.match(re);\n    if (hit) matches.push({ kind, token: hit[0] });\n  }\n  return matches;\n}\n\nexport class StandingBlockError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"StandingBlockError\";\n  }\n}\n\nexport class StandingBlockVolatilityError extends StandingBlockError {\n  readonly matches: readonly StandingVolatilityMatch[];\n  constructor(matches: readonly StandingVolatilityMatch[]) {\n    super(\n      `standing memory block refused: volatile content busts the prefix cache (${matches\n        .map((m) => `${m.kind}:${JSON.stringify(m.token)}`)\n        .join(\", \")})`,\n    );\n    this.name = \"StandingBlockVolatilityError\";\n    this.matches = matches;\n  }\n}\n\nexport class StandingBlockBudgetError extends StandingBlockError {\n  constructor(maxChars: number) {\n    super(\n      `standing memory block does not fit: pinned lines alone exceed maxChars=${maxChars}; raise standingBlockMaxChars or unpin entries`,\n    );\n    this.name = \"StandingBlockBudgetError\";\n  }\n}\n\nexport function parseRecallStandingBlock(raw: unknown): boolean {\n  return coerceBooleanLike(raw, \"recallStandingBlock\") === true;\n}\n\nexport function parseStandingBlockFreshDays(raw: unknown): number {\n  if (raw === undefined || raw === null) return DEFAULT_STANDING_BLOCK_FRESH_DAYS;\n  const n = coerceNumber(raw, \"standingBlockFreshDays\");\n  if (n === undefined || !Number.isFinite(n) || n < 0) {\n    throw new Error(`Invalid standingBlockFreshDays: expected a number >= 0, got ${JSON.stringify(raw)}`);\n  }\n  return n;\n}\n\nexport function parseStandingBlockMaxChars(raw: unknown): number {\n  if (raw === undefined || raw === null) return DEFAULT_STANDING_BLOCK_MAX_CHARS;\n  const n = coerceNumber(raw, \"standingBlockMaxChars\");\n  if (n === undefined || !Number.isFinite(n) || n < 1) {\n    throw new Error(`Invalid standingBlockMaxChars: expected an integer >= 1, got ${JSON.stringify(raw)}`);\n  }\n  return Math.floor(n);\n}\n\n/**\n * Mechanical hook: deterministic first-cut of the description to the char\n * budget at a word boundary. This is also the fallback when no model is\n * reachable for compression — the standing surface never goes blank because\n * a model is down. Model-generated hooks arrive pre-seeded in the ledger.\n */\nfunction mechanicalHook(description: string, budget: number): string {\n  if (description.length <= budget) return description;\n  const cut = description.slice(0, budget);\n  const lastSpace = cut.lastIndexOf(\" \");\n  const base = lastSpace > Math.floor(budget * 0.6) ? cut.slice(0, lastSpace) : cut;\n  return `${base.replace(/[\\s,;:]+$/, \"\")}...`;\n}\n\ninterface LayeredEntry {\n  id: string;\n  band: StandingBand;\n  line: string;\n}\n\nconst BAND_RANK: Record<StandingBand, number> = { pinned: 0, fresh: 1, compressed: 2 };\n\nfunction validateEntries(entries: readonly StandingMemoryEntry[]): Map<string, StandingMemoryEntry> {\n  if (!Array.isArray(entries)) {\n    throw new StandingBlockError(\"standing memory block entries must be an array\");\n  }\n  const seen = new Set<string>();\n  const validated = new Map<string, StandingMemoryEntry>();\n  for (const entry of entries) {\n    if (typeof entry !== \"object\" || entry === null) {\n      throw new StandingBlockError(`standing memory block entry must be an object, got ${JSON.stringify(entry)}`);\n    }\n    const id = typeof entry.id === \"string\" ? entry.id.trim() : \"\";\n    const description = typeof entry.description === \"string\" ? entry.description.trim() : \"\";\n    if (id.length === 0) {\n      throw new StandingBlockError(\"standing memory block entry requires a non-empty id\");\n    }\n    if (description.length === 0) {\n      throw new StandingBlockError(`standing memory block entry ${id} requires a non-empty description`);\n    }\n    if (seen.has(id)) {\n      throw new StandingBlockError(`standing memory block entry ids must be unique; duplicate: ${id}`);\n    }\n    if (entry.lastChangedAt !== undefined && Number.isNaN(Date.parse(entry.lastChangedAt))) {\n      throw new StandingBlockError(\n        `standing memory block entry ${id} has an unparseable lastChangedAt: ${JSON.stringify(entry.lastChangedAt)}`,\n      );\n    }\n    seen.add(id);\n    validated.set(id, { ...entry, id, description });\n  }\n  return validated;\n}\n\nexport interface StandingMemoryBlockInput {\n  entries: readonly StandingMemoryEntry[];\n  /**\n   * Evaluation instant for the fresh band. Hosts must key rebuilds on the\n   * store version, not on this clock, or band edges drift per turn.\n   */\n  nowMs: number;\n  freshDays?: number;\n  maxChars?: number;\n  hookMaxChars?: number;\n  ledger?: StandingHookLedger;\n}\n\nexport function buildStandingMemoryBlock(input: StandingMemoryBlockInput): StandingMemoryBlock {\n  const freshDays = input.freshDays ?? DEFAULT_STANDING_BLOCK_FRESH_DAYS;\n  const maxChars = input.maxChars ?? DEFAULT_STANDING_BLOCK_MAX_CHARS;\n  const hookMaxChars = input.hookMaxChars ?? DEFAULT_STANDING_BLOCK_HOOK_CHARS;\n  if (!Number.isFinite(input.nowMs)) {\n    throw new StandingBlockError(\"standing memory block requires a finite nowMs\");\n  }\n  if (!(freshDays >= 0) || !Number.isFinite(freshDays)) {\n    throw new StandingBlockError(\"standing memory block requires freshDays >= 0\");\n  }\n  if (!(maxChars >= 1) || !Number.isFinite(maxChars)) {\n    throw new StandingBlockError(\"standing memory block requires maxChars >= 1\");\n  }\n  if (!(hookMaxChars >= 1) || !Number.isFinite(hookMaxChars)) {\n    throw new StandingBlockError(\"standing memory block requires hookMaxChars >= 1\");\n  }\n\n  const entries = validateEntries(input.entries);\n  const ledger = new Map(input.ledger ?? []);\n  if (entries.size === 0) {\n    return {\n      text: \"\",\n      lines: [],\n      ledger,\n      bandCounts: { pinned: 0, fresh: 0, compressed: 0, dropped: 0 },\n    };\n  }\n\n  const freshCutoff = input.nowMs - freshDays * 86_400_000;\n  const layered: LayeredEntry[] = [];\n  for (const entry of entries.values()) {\n    let band: StandingBand;\n    if (entry.pinned === true) {\n      band = \"pinned\";\n    } else if (\n      typeof entry.lastChangedAt === \"string\" &&\n      Date.parse(entry.lastChangedAt) >= freshCutoff &&\n      Date.parse(entry.lastChangedAt) <= input.nowMs\n    ) {\n      band = \"fresh\";\n    } else {\n      band = \"compressed\";\n    }\n    if (band !== \"compressed\") {\n      layered.push({ id: entry.id, band, line: `- ${entry.description}` });\n      continue;\n    }\n    const key = standingHookLedgerKey(entry.description, hookMaxChars);\n    const cached = ledger.get(key);\n    const hook = cached ?? mechanicalHook(entry.description, hookMaxChars);\n    if (cached === undefined) ledger.set(key, hook);\n    layered.push({ id: entry.id, band, line: `- ${hook}` });\n  }\n\n  // Band rank, then id codepoint order. Never localeCompare: collation is\n  // ICU-dependent and this text must be byte-identical across rebuilds.\n  layered.sort(\n    (a, b) =>\n      BAND_RANK[a.band] - BAND_RANK[b.band] || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0),\n  );\n\n  const render = (keep: number, withMarker: boolean): { text: string; lines: string[] } => {\n    const body = layered.slice(0, keep).map((item) => item.line);\n    if (withMarker) body.push(STANDING_BLOCK_TRIMMED_MARKER);\n    const lines = [STANDING_BLOCK_HEADER, \"\", ...body, \"\", STANDING_BLOCK_INSTRUCTION];\n    return { text: lines.join(\"\\n\"), lines };\n  };\n\n  const pinnedCount = layered.filter((item) => item.band === \"pinned\").length;\n  let keep = layered.length;\n  let rendered = render(keep, false);\n  // Mechanical trim: drop from the tail. The sort puts compressed lines\n  // last, so oldest-band hooks go first and pinned lines are never reached.\n  while (rendered.text.length > maxChars && keep > pinnedCount) {\n    keep -= 1;\n    rendered = render(keep, true);\n  }\n  if (rendered.text.length > maxChars) {\n    throw new StandingBlockBudgetError(maxChars);\n  }\n\n  const volatility = lintStandingBlockVolatility(rendered.text);\n  if (volatility.length > 0) {\n    throw new StandingBlockVolatilityError(volatility);\n  }\n\n  const kept = layered.slice(0, keep);\n  return {\n    text: rendered.text,\n    lines: rendered.lines,\n    ledger,\n    bandCounts: {\n      pinned: kept.filter((item) => item.band === \"pinned\").length,\n      fresh: kept.filter((item) => item.band === \"fresh\").length,\n      compressed: kept.filter((item) => item.band === \"compressed\").length,\n      dropped: layered.length - keep,\n    },\n  };\n}\n"],"mappings":"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","names":["keep"]}

package/dist/{chunk-VGRVJ6Z6.js → chunk-LIAM7U2J.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-QUFJ3NJE.js";
+} from "./chunk-MNG536IS.js";
 import {
   getCachedRuleMemories,
   setCachedRuleMemories
@@ -119,4 +119,4 @@ export {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
 };
-//# sourceMappingURL=chunk-VGRVJ6Z6.js.map
+//# sourceMappingURL=chunk-LIAM7U2J.js.map

package/dist/{chunk-S3SND7SO.js → chunk-LIDJWAQV.js}

@@ -4,7 +4,7 @@ import {
 import {
   computeCorpusWatermarks,
   resolveCorpusNamespaceRoots
-} from "./chunk-SW42MMAH.js";
+} from "./chunk-MQT3WP3F.js";
 
 // src/operator-doctor-corpus.ts
 var DIGEST_PREFIX_LENGTH = 12;
@@ -78,4 +78,4 @@ export {
   corpusWatermarksFromCheck,
   summarizeCorpusAndReplica
 };
-//# sourceMappingURL=chunk-S3SND7SO.js.map
+//# sourceMappingURL=chunk-LIDJWAQV.js.map

package/dist/{chunk-T5NI5K46.js → chunk-LYMJ36UI.js}

@@ -1,6 +1,6 @@
 import {
   rebuildMemoryProjection
-} from "./chunk-CWMMKFO7.js";
+} from "./chunk-XEHLYA5Z.js";
 
 // src/convergence-refresh.ts
 async function refreshConvergedNamespaces(namespaces, namespaceSearchRouter, getStorage, searchEnabled) {
@@ -32,4 +32,4 @@ async function refreshConvergedNamespaces(namespaces, namespaceSearchRouter, get
 export {
   refreshConvergedNamespaces
 };
-//# sourceMappingURL=chunk-T5NI5K46.js.map
+//# sourceMappingURL=chunk-LYMJ36UI.js.map

package/dist/{chunk-KF57IQFX.js → chunk-MMQVWKFY.js}

@@ -3,25 +3,28 @@ import {
 } from "./chunk-V7IZKJI3.js";
 import {
   AdapterRegistry
-} from "./chunk-Q4AUIFUA.js";
+} from "./chunk-QMWKENNK.js";
 import {
   WriteRateLimiter
 } from "./chunk-TB6CBZ5V.js";
 import {
   maybeRespondRecallNavigation
 } from "./chunk-QZ4U67KO.js";
+import {
+  maybeRespondMemoryBrowse
+} from "./chunk-HMDYSGY6.js";
 import {
   serializeInlineScriptValue
 } from "./chunk-3HSRWJTC.js";
 import {
   respondDeepRecall
-} from "./chunk-3UQIS2GC.js";
+} from "./chunk-WNMVUWI7.js";
 import {
   handleSupportPassportOwnerHttp
-} from "./chunk-UEJY6ZTQ.js";
+} from "./chunk-NE45P3OF.js";
 import {
   buildSupportPassportPublicRequestHandler
-} from "./chunk-OV7GJ4KW.js";
+} from "./chunk-V2XNMIAM.js";
 import {
   handleMcpGetSse
 } from "./chunk-SRT6SHVZ.js";
@@ -34,10 +37,10 @@ import {
   processChatMessage,
   sessionBelongsToPrincipal,
   subscribeChatTranscript
-} from "./chunk-GYYLZOSO.js";
+} from "./chunk-R4JTUTU6.js";
 import {
   RelayMissionStoreError
-} from "./chunk-D5DTZBTV.js";
+} from "./chunk-2JFSQWFH.js";
 import {
   executeResolution,
   isValidResolutionVerb
@@ -59,10 +62,10 @@ import {
   optionalNamespaceKindQueryParam,
   optionalQueryString,
   positiveIntQueryParam
-} from "./chunk-YFVIA5A6.js";
+} from "./chunk-DRLZB3CN.js";
 import {
   respondBriefingHttp
-} from "./chunk-5EHPB6RL.js";
+} from "./chunk-2QX65IEC.js";
 import {
   maybeHandleLifecycleFlush
 } from "./chunk-TIDEL77O.js";
@@ -73,14 +76,14 @@ import {
   authorizationProbeNamespaces,
   authorizationProbeRequiresPrincipalNamespace,
   probeOperationAuthorization
-} from "./chunk-AYZHHMTK.js";
+} from "./chunk-QKFYJVDG.js";
 import {
   getOperation,
   resolveQueryNamespaceWritablePreflight
-} from "./chunk-HXDXR2FH.js";
+} from "./chunk-AS4YKT75.js";
 import {
   handleWhoKnowsHttpQuery
-} from "./chunk-FSH6KRKO.js";
+} from "./chunk-PPJLJD2D.js";
 import {
   isTrustZoneName
 } from "./chunk-ROBHL3GL.js";
@@ -89,16 +92,16 @@ import {
 } from "./chunk-DEUNUKTD.js";
 import {
   isRecallDisclosure
-} from "./chunk-66YUOI53.js";
+} from "./chunk-WQW6KPVC.js";
 import {
   CorrectionContractError
 } from "./chunk-QLK3SL7Q.js";
 import {
   validateRequest
-} from "./chunk-AYP2FZFA.js";
+} from "./chunk-JUOJGZPV.js";
 import {
   peerManifestRevision
-} from "./chunk-TNQR7N52.js";
+} from "./chunk-S3YM4SZQ.js";
 import {
   assertOperationAllowed,
   capabilityAllowsOp,
@@ -1826,6 +1829,7 @@ var EngramAccessHttpServer = class extends ReviewDeckAccessHttpBase {
       return;
     }
     if (await maybeRespondRecallNavigation(req, res, pathname, req.method, (op) => this.enforceTokenOp(op), this.respondJson.bind(this), this.readJsonBody.bind(this), this.service, (ns, sk) => this.wearablesScope(req, ns ?? parsed.searchParams.get("namespace") ?? void 0, sk ?? parsed.searchParams.get("sessionKey") ?? void 0))) return;
+    if (await maybeRespondMemoryBrowse(req, res, pathname, req.method, (op) => this.enforceTokenOp(op), this.respondJson.bind(this), this.readJsonBody.bind(this), this.service, (ns) => this.wearablesScope(req, ns ?? parsed.searchParams.get("namespace") ?? void 0))) return;
     if (req.method === "GET" && (pathname === "/engram/v1/location/status" || pathname === "/remnic/v1/location/status")) {
       this.enforceTokenOp("location_status");
       await respondLocationStatus(res, this.respondJson.bind(this), this.service);
@@ -3595,4 +3599,4 @@ export {
   resolveDefaultAdminConsolePublicDir,
   EngramAccessHttpServer
 };
-//# sourceMappingURL=chunk-KF57IQFX.js.map
+//# sourceMappingURL=chunk-MMQVWKFY.js.map