@remnic/core 9.62.1 → 9.62.2

package/src/search/orama-cjk-tokenizer.test.ts

@@ -0,0 +1,108 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import * as orama from "@orama/orama";
+
+import {
+  containsNonLegacyTokenizerChars,
+  createCjkCapableTokenizer,
+  isSpaceFreeScriptChar,
+  ORAMA_CJK_TOKENIZER_LANGUAGE,
+} from "./orama-cjk-tokenizer.js";
+
+const stockTokenizer = orama.components.tokenizer.createTokenizer({ language: "english" });
+const tokenizer = createCjkCapableTokenizer(orama);
+
+test("CJK tokenizer matches the stock English tokenizer for legacy Latin input", () => {
+  for (const input of [
+    "The quick brown fox jumps over the lazy dog",
+    "Nebula-472 deploy finished; it's live (prod)!",
+    "snake_case camelCase 42.7%",
+    "",
+  ]) {
+    assert.deepEqual(tokenizer.tokenize(input), stockTokenizer.tokenize(input), input);
+  }
+});
+
+test("CJK tokenizer expands Japanese runs into n-grams", () => {
+  const tokens = tokenizer.tokenize("東京都庁の所在地");
+
+  assert.equal(tokens.includes("東京都庁"), true);
+  assert.equal(tokens.includes("所在"), true);
+  assert.equal(tokens.includes("地"), true);
+  assert.equal(tokens.includes("東京都庁の所在地"), true);
+});
+
+test("CJK tokenizer reuses the recall segmentation n-gram sizes", () => {
+  // A 5-char run yields chars + 2/3/4-grams + the whole run.
+  const tokens = tokenizer.tokenize("用户喜欢深");
+  const expected = new Set(["用", "户", "喜", "欢", "深"]);
+  for (const size of [2, 3, 4]) {
+    for (let i = 0; i <= 5 - size; i++) {
+      expected.add("用户喜欢深".slice(i, i + size));
+    }
+  }
+  expected.add("用户喜欢深");
+  for (const token of expected) {
+    assert.equal(tokens.includes(token), true, token);
+  }
+});
+
+test("CJK tokenizer keeps Latin tokens intact inside mixed-script input", () => {
+  const tokens = tokenizer.tokenize("Nebula-472 東京都庁");
+
+  assert.equal(tokens.includes("nebula-472"), true);
+  assert.equal(tokens.includes("東京都庁"), true);
+});
+
+test("CJK tokenizer n-grams Thai runs", () => {
+  const tokens = tokenizer.tokenize("กรุงเทพมหานคร");
+
+  assert.equal(tokens.includes("กรุง"), true);
+  assert.equal(tokens.includes("งเทพ"), true);
+  assert.equal(tokens.includes("กรุงเทพมหานคร"), true);
+});
+
+test("CJK tokenizer keeps Hangul and other alphabetic scripts as whole words", () => {
+  const tokens = tokenizer.tokenize("사용자 설정 Привет мир");
+
+  assert.equal(tokens.includes("사용자"), true);
+  assert.equal(tokens.includes("설정"), true);
+  assert.equal(tokens.includes("사"), false);
+  assert.equal(tokens.includes("привет"), true);
+  assert.equal(tokens.includes("мир"), true);
+});
+
+test("CJK tokenizer persists a versioned language marker", () => {
+  assert.equal(tokenizer.language, ORAMA_CJK_TOKENIZER_LANGUAGE);
+  assert.equal(typeof tokenizer.tokenize, "function");
+  assert.ok(tokenizer.normalizationCache instanceof Map);
+});
+
+test("isSpaceFreeScriptChar covers CJK and Thai only", () => {
+  assert.equal(isSpaceFreeScriptChar("東"), true);
+  assert.equal(isSpaceFreeScriptChar("あ"), true);
+  assert.equal(isSpaceFreeScriptChar("ア"), true);
+  assert.equal(isSpaceFreeScriptChar("ก"), true);
+  assert.equal(isSpaceFreeScriptChar("사"), false);
+  assert.equal(isSpaceFreeScriptChar("a"), false);
+});
+
+test("CJK tokenizer returns no tokens for non-string input", () => {
+  assert.deepEqual(tokenizer.tokenize(undefined as unknown as string), []);
+  assert.deepEqual(tokenizer.tokenize(null as unknown as string), []);
+  assert.deepEqual(tokenizer.tokenize(42 as unknown as string), []);
+});
+
+test("rebuild gate flags only tokenization-changing characters", () => {
+  // Word material outside the stock keep-set changes tokens (whole words,
+  // n-grams, attached marks) — the gate must flag it.
+  assert.equal(containsNonLegacyTokenizerChars("naïve"), true);
+  assert.equal(containsNonLegacyTokenizerChars("東京都庁"), true);
+  assert.equal(containsNonLegacyTokenizerChars("사용자"), true);
+  assert.equal(containsNonLegacyTokenizerChars("cafe\u0301"), true);
+  // Separators in BOTH tokenizers — punctuation and symbols — leave the
+  // stock token stream unchanged, so no re-index is warranted.
+  assert.equal(containsNonLegacyTokenizerChars("plain — text „quoted” · done"), false);
+  assert.equal(containsNonLegacyTokenizerChars("Nebula-472 deploy (prod)"), false);
+});

package/src/search/orama-cjk-tokenizer.ts

@@ -0,0 +1,143 @@
+import { expandUnsegmentableRecallNGrams, isUnsegmentableRecallChar } from "../recall-tokenization.js";
+
+/**
+ * Language marker persisted inside Orama index files (`.msp`). Orama persists
+ * `tokenizer.language` with the index, so this doubles as the tokenization
+ * version: `OramaBackend` detects any other marker on restore and rebuilds
+ * the full-text index (issue #2187). Bump the suffix whenever tokenization
+ * changes.
+ */
+export const ORAMA_CJK_TOKENIZER_LANGUAGE = "english+cjk-v1";
+
+/** Minimal structural surface of `@orama/orama` this module consumes. */
+export interface OramaTokenizerComponents {
+  components: {
+    tokenizer: {
+      createTokenizer: (config: { language: string }) => OramaTokenizer;
+    };
+  };
+}
+
+export interface OramaTokenizer {
+  language: string;
+  normalizationCache: Map<string, string>;
+  tokenize: (raw: string, language?: string, prop?: string, withCache?: boolean) => string[];
+}
+
+const THAI_SCRIPT_CHAR = /[\p{Script=Thai}]/u;
+const WORD_CHAR = /[\p{L}\p{N}\p{M}]/u;
+const COMBINING_MARK = /\p{M}/u;
+const WHITESPACE_CHAR = /\s/u;
+/**
+ * Chars the stock English tokenizer keeps inside a token. Input made only of
+ * these (plus whitespace) is delegated to the stock tokenizer byte-for-byte so
+ * existing English indexes stay term-compatible.
+ */
+const LEGACY_TOKENIZER_CHAR = /[A-Za-zàèéìòóù0-9_'-]/u;
+
+/**
+ * Space-free scripts: CJK per the shared recall segmentation strategy, plus
+ * Thai. Runs in these scripts are indexed as character n-grams so phrase
+ * queries match without word boundaries.
+ */
+export function isSpaceFreeScriptChar(char: string): boolean {
+  return isUnsegmentableRecallChar(char) || THAI_SCRIPT_CHAR.test(char);
+}
+
+/**
+ * True when tokenizing the value differs from the stock English tokenizer —
+ * i.e. the value contains characters outside the stock keep-set that this
+ * tokenizer still indexes as token material: word characters (whole-word
+ * non-ASCII scripts), combining marks (attached to runs), and space-free
+ * scripts (CJK/Thai n-grams). Symbols and punctuation that are separators in
+ * BOTH tokenizers do not count. `OramaBackend` uses this to decide whether a
+ * stale pre-CJK index needs re-indexing on upgrade.
+ */
+export function containsNonLegacyTokenizerChars(value: string): boolean {
+  for (const ch of value) {
+    if (LEGACY_TOKENIZER_CHAR.test(ch) || WHITESPACE_CHAR.test(ch)) continue;
+    if (WORD_CHAR.test(ch) || COMBINING_MARK.test(ch) || isSpaceFreeScriptChar(ch)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Orama tokenizer component that segments space-free scripts (CJK, Thai).
+ *
+ * - CJK/Thai runs expand to the same n-gram set the recall query-side
+ *   tokenizer (`recall-tokenization.ts`) produces, so index-side and
+ *   query-side tokens agree.
+ * - Other non-Latin scripts (Hangul, Cyrillic, Greek, Arabic, ...) are kept
+ *   as whole words instead of being dropped by the English splitter.
+ * - Legacy Latin content tokenizes exactly like the stock English tokenizer;
+ *   content with other characters keeps every stock token and additionally
+ *   indexes non-ASCII words whole (e.g. "über" adds "über" beside "ber").
+ */
+export function createCjkCapableTokenizer(oramaModule: OramaTokenizerComponents): OramaTokenizer {
+  const base = oramaModule.components.tokenizer.createTokenizer({ language: "english" });
+
+  const tokenize = (raw: string, _language?: string, prop?: string, withCache?: boolean): string[] => {
+    if (typeof raw !== "string") return [];
+    const normalized = raw.normalize("NFC");
+
+    if (!containsNonLegacyTokenizerChars(normalized)) {
+      return base.tokenize(normalized, "english", prop, withCache);
+    }
+
+    // The stock tokenizer treats every non-legacy char as a separator, so its
+    // output over the raw input already carries the legacy-Latin tokens
+    // (e.g. the "nebula-472" in "Nebula-472 東京都庁").
+    const tokens = base.tokenize(normalized, "english", prop, withCache);
+    const seen = new Set(tokens);
+
+    const pushToken = (token: string) => {
+      if (token && !seen.has(token)) {
+        seen.add(token);
+        tokens.push(token);
+      }
+    };
+
+    let spaceFreeRun = "";
+    let wordRun = "";
+    const flushSpaceFreeRun = () => {
+      if (!spaceFreeRun) return;
+      for (const token of expandUnsegmentableRecallNGrams(spaceFreeRun)) {
+        pushToken(token);
+      }
+      spaceFreeRun = "";
+    };
+    const flushWordRun = () => {
+      if (!wordRun) return;
+      pushToken(wordRun.toLowerCase());
+      wordRun = "";
+    };
+
+    for (const ch of normalized) {
+      if (isSpaceFreeScriptChar(ch)) {
+        flushWordRun();
+        spaceFreeRun += ch;
+      } else if (COMBINING_MARK.test(ch)) {
+        if (spaceFreeRun) spaceFreeRun += ch;
+        else if (wordRun) wordRun += ch;
+      } else if (WORD_CHAR.test(ch) && !LEGACY_TOKENIZER_CHAR.test(ch)) {
+        flushSpaceFreeRun();
+        wordRun += ch;
+      } else {
+        flushSpaceFreeRun();
+        flushWordRun();
+      }
+    }
+    flushSpaceFreeRun();
+    flushWordRun();
+
+    return tokens;
+  };
+
+  return {
+    language: ORAMA_CJK_TOKENIZER_LANGUAGE,
+    normalizationCache: base.normalizationCache,
+    tokenize,
+  };
+}

package/src/storage/tombstone-migration-sources.test.ts

@@ -0,0 +1,116 @@
+import * as assert from "node:assert/strict";
+import { mkdtemp, rm, utimes, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { createTombstoneMigrationSourceContents } from "./tombstone-migration-sources.js";
+import type { MemoryFile } from "../types.js";
+
+function memory(id: string, content: string): MemoryFile {
+  return {
+    path: `facts/${id}.md`,
+    rawContent: content,
+    frontmatter: { id, category: "fact", status: "active" },
+  } as unknown as MemoryFile;
+}
+
+interface Harness {
+  dir: string;
+  ledgerPath: string;
+  collectCalls: number;
+  readsByPaths: string[][];
+  gateCollect: Promise<void>;
+  releaseCollect: () => void;
+}
+
+async function makeHarness(): Promise<Harness> {
+  const dir = await mkdtemp(path.join(tmpdir(), "tomb-migration-race-"));
+  const ledgerPath = path.join(dir, "tombstones.jsonl");
+  await writeFile(ledgerPath, "", "utf8");
+  let gateCollect: (() => void) | undefined;
+  const gate = new Promise<void>((resolve) => {
+    gateCollect = resolve;
+  });
+  const harness: Harness = {
+    dir,
+    ledgerPath,
+    collectCalls: 0,
+    readsByPaths: [],
+    gateCollect: gate,
+    releaseCollect: () => gateCollect?.(),
+  };
+  return harness;
+}
+
+test("an in-flight fill does not publish a stale cache after the ledger advances", async () => {
+  const h = await makeHarness();
+  try {
+    const generations: string[][] = [["facts/old-a.md"], ["facts/new-a.md", "facts/old-a.md"]];
+    const contents = new Map<string, string>([
+      ["facts/old-a.md", "old body"],
+      ["facts/new-a.md", "new body"],
+    ]);
+    const sourceContents = createTombstoneMigrationSourceContents({
+      tombstonesPath: () => h.ledgerPath,
+      collectTombstoneMigrationPaths: async () => {
+        const callIndex = h.collectCalls + 1;
+        h.collectCalls = callIndex;
+        if (callIndex === 1) {
+          // First fill stalls while a peer retires a legacy memory; the
+          // generation is bound at call entry so the stall cannot upgrade
+          // it to the fresh revision.
+          await h.gateCollect;
+        }
+        return generations[Math.min(callIndex - 1, generations.length - 1)]!;
+      },
+      readParsedMemoriesFromPaths: async (filePaths: string[]) => {
+        h.readsByPaths.push([...filePaths]);
+        return filePaths
+          .filter((filePath) => contents.has(filePath))
+          .map((filePath) => memory(path.basename(filePath, ".md"), contents.get(filePath)!));
+      },
+      storedContentIdentityCandidates: (content: string) => [content],
+    });
+
+    // The first callback requests an id whose path exists only in the new
+    // ledger revision, so a stale snapshot would miss it entirely.
+    const first = sourceContents(["new-a"]);
+    // Advance the ledger mtime so a later callback drops both caches while
+    // the first fill is still awaiting its (stale) path snapshot.
+    await utimes(h.ledgerPath, new Date(), new Date(Date.now() + 5000));
+    const second = sourceContents(["old-a"]);
+    h.releaseCollect();
+
+    // Without the revision guard, the first callback would miss on the
+    // stale snapshot, publish a full map built from it, and resolve empty.
+    const firstResult = await first;
+    assert.deepEqual([...firstResult.keys()], ["new-a"]);
+    const secondResult = await second;
+    assert.deepEqual([...secondResult.keys()], ["old-a"]);
+    assert.equal(h.collectCalls >= 2, true, "restart re-collects paths against the fresh revision");
+  } finally {
+    await rm(h.dir, { recursive: true, force: true });
+  }
+});
+
+test("a stable ledger revision reuses the collected paths across callbacks", async () => {
+  const h = await makeHarness();
+  try {
+    const sourceContents = createTombstoneMigrationSourceContents({
+      tombstonesPath: () => h.ledgerPath,
+      collectTombstoneMigrationPaths: async () => {
+        h.collectCalls += 1;
+        return ["facts/a.md"];
+      },
+      readParsedMemoriesFromPaths: async (filePaths: string[]) =>
+        filePaths.map((filePath) => memory(path.basename(filePath, ".md"), "body")),
+      storedContentIdentityCandidates: (content: string) => [content],
+    });
+    await sourceContents(["a"]);
+    await sourceContents(["a"]);
+    assert.equal(h.collectCalls, 1, "unchanged ledger mtime reuses the path snapshot");
+  } finally {
+    await rm(h.dir, { recursive: true, force: true });
+  }
+});

package/src/storage/tombstone-migration-sources.ts

@@ -0,0 +1,90 @@
+import { statSync } from "node:fs";
+import path from "node:path";
+import type { TombstoneStoreOptions } from "../lifecycle/tombstones.js";
+import type { MemoryFile } from "../types.js";
+
+/**
+ * Deps injected by `StorageManager.buildTombstoneStore` so this module owns no
+ * storage-god-file imports (issue #1533 ratchet).
+ */
+export interface TombstoneMigrationSourceDeps {
+  /** On-disk tombstone ledger path; its mtime scopes both caches below. */
+  tombstonesPath: () => string;
+  collectTombstoneMigrationPaths: () => Promise<string[]>;
+  readParsedMemoriesFromPaths: (filePaths: string[], batchSize?: number) => Promise<MemoryFile[]>;
+  storedContentIdentityCandidates: (content: string) => string[];
+}
+
+/**
+ * Build the `sourceContentsForMemoryIds` callback `TombstoneStore` uses to
+ * verify pre-Unicode rows against their retired source memories. The corpus
+ * path snapshot and the resolved source-content map are memoized for one
+ * ledger revision only (issue #2367): a peer process can create and retire a
+ * legacy-format memory after this snapshot, and the staleness reload must
+ * resolve the new row against a FRESH path list — otherwise the row stays
+ * unverified (withheld from the lookup tiers) until restart.
+ */
+export function createTombstoneMigrationSourceContents(
+  deps: TombstoneMigrationSourceDeps,
+): NonNullable<TombstoneStoreOptions["sourceContentsForMemoryIds"]> {
+  let sourcePathsPromise: Promise<string[]> | undefined;
+  let sourceContentsByIdPromise: Promise<Map<string, readonly string[]>> | undefined;
+  let ledgerMtimeMs: number | null = null;
+  const dropCachesIfLedgerChanged = (): void => {
+    let mtimeMs: number | null;
+    try {
+      mtimeMs = Math.floor(statSync(deps.tombstonesPath()).mtimeMs);
+    } catch {
+      return; // ENOENT / stat failure — keep whatever is cached.
+    }
+    if (mtimeMs === ledgerMtimeMs) return;
+    ledgerMtimeMs = mtimeMs;
+    sourcePathsPromise = undefined;
+    sourceContentsByIdPromise = undefined;
+  };
+  return async (sourceMemoryIds) => {
+    for (;;) {
+      dropCachesIfLedgerChanged();
+      // In-flight fills are bound to the ledger revision they started
+      // against: if the ledger advances while a fill awaits, restart
+      // against the fresh revision instead of publishing a cache built
+      // from a stale path snapshot (issue #2367 review round 2).
+      const revision = ledgerMtimeMs;
+      const requested = new Set(sourceMemoryIds);
+      const sourcePaths = await (sourcePathsPromise ??= deps.collectTombstoneMigrationPaths());
+      if (ledgerMtimeMs !== revision) continue;
+      const directPaths = sourcePaths.filter((filePath) =>
+        requested.has(path.basename(filePath, ".md"))
+      );
+      const contents = new Map<string, readonly string[]>();
+      for (const memory of await deps.readParsedMemoriesFromPaths(directPaths, 50)) {
+        const id = memory.frontmatter.id;
+        if (requested.has(id) && !contents.has(id)) {
+          contents.set(id, deps.storedContentIdentityCandidates(memory.content));
+        }
+      }
+      // Re-check after the direct-path read too: a concurrent drop during
+      // that await must not let this call publish a fill built from the
+      // stale snapshot into the freshly cleared slot (issue #2367 round 3).
+      if (ledgerMtimeMs !== revision) continue;
+      if (contents.size === requested.size) return contents;
+      const fill = (sourceContentsByIdPromise ??= (async () => {
+        const allContents = new Map<string, readonly string[]>();
+        for (const memory of await deps.readParsedMemoriesFromPaths(sourcePaths, 50)) {
+          const id = memory.frontmatter.id;
+          if (!allContents.has(id)) {
+            allContents.set(id, deps.storedContentIdentityCandidates(memory.content));
+          }
+        }
+        return allContents;
+      })());
+      const allContents = await fill;
+      if (ledgerMtimeMs !== revision) continue;
+      for (const id of requested) {
+        const content = allContents.get(id);
+        if (content !== undefined) contents.set(id, content);
+      }
+      return contents;
+    }
+  };
+}

package/src/storage.ts

@@ -26,6 +26,7 @@ import { resolveSafeStoragePath } from "./storage-paths.js";
 import { log } from "./logger.js";
 import { createMemorySnapshot } from "./memory-snapshot.js";
 import { assertMemoryFrontmatterId, warnProjectionFallback } from "./storage-guards.js";
+import { createTombstoneMigrationSourceContents } from "./storage/tombstone-migration-sources.js";
 import { MemoryReadStore, readWindowedMemories, type WindowedMemoryReadOptions, type WindowedMemoryReadResult } from "./storage/memory-read-store.js";
 import { hasSupersessionAudit } from "./storage/supersession-audit.js";
 import { runCommittedInvalidation } from "./storage/committed-invalidation.js";
@@ -3016,46 +3017,24 @@ export class StorageManager extends TombstoneBlockedCaptureIndexHost {
   }
 
   private buildTombstoneStore(): TombstoneStore {
-    let sourcePathsPromise: Promise<string[]> | undefined;
-    let sourceContentsByIdPromise: Promise<Map<string, readonly string[]>> | undefined;
     const options: TombstoneStoreOptions = {
       enabled: this.tombstonesConfig.enabled,
       semanticMatch: this.tombstonesConfig.semanticMatch,
       semanticThreshold: this.tombstonesConfig.semanticThreshold,
       hashContent: ContentHashIndex.computeHash,
       normalizeText: ContentHashIndex.normalizeContent,
-      sourceContentsForMemoryIds: async (sourceMemoryIds) => {
-        const requested = new Set(sourceMemoryIds);
-        const sourcePaths = await (sourcePathsPromise ??=
-          this.memoryReadStore.collectTombstoneMigrationPaths());
-        const directPaths = sourcePaths.filter((filePath) =>
-          requested.has(path.basename(filePath, ".md"))
-        );
-        const contents = new Map<string, readonly string[]>();
-        for (const memory of await this.readParsedMemoriesFromPaths(directPaths, 50)) {
-          const id = memory.frontmatter.id;
-          if (requested.has(id) && !contents.has(id)) {
-            contents.set(id, this.storedContentIdentityCandidates(memory.content));
-          }
-        }
-        if (contents.size === requested.size) return contents;
-        sourceContentsByIdPromise ??= (async () => {
-          const allContents = new Map<string, readonly string[]>();
-          for (const memory of await this.readParsedMemoriesFromPaths(sourcePaths, 50)) {
-            const id = memory.frontmatter.id;
-            if (!allContents.has(id)) {
-              allContents.set(id, this.storedContentIdentityCandidates(memory.content));
-            }
-          }
-          return allContents;
-        })();
-        const allContents = await sourceContentsByIdPromise;
-        for (const id of requested) {
-          const content = allContents.get(id);
-          if (content !== undefined) contents.set(id, content);
-        }
-        return contents;
-      },
+      // Corpus-path + source-content caches are scoped to one ledger revision
+      // so a peer-appended legacy row is verified on the next staleness reload
+      // (issue #2367). Implementation lives in storage/tombstone-migration-sources.ts.
+      sourceContentsForMemoryIds: createTombstoneMigrationSourceContents({
+        tombstonesPath: () => this.tombstonesPath,
+        collectTombstoneMigrationPaths: () =>
+          this.memoryReadStore.collectTombstoneMigrationPaths(),
+        readParsedMemoriesFromPaths: (filePaths, batchSize) =>
+          this.readParsedMemoriesFromPaths(filePaths, batchSize),
+        storedContentIdentityCandidates: (content) =>
+          this.storedContentIdentityCandidates(content),
+      }),
     };
     const io: TombstoneFileIo = {
       read: (filePath) => this.readStorageSecureFile(filePath),

package/src/types.ts

@@ -631,7 +631,6 @@ export interface DependencyPropagationConfig {
   dryRun: boolean;
 }
 
-
 export interface HeartbeatConfig {
   enabled: boolean;
   journalPath: string;
@@ -1408,6 +1407,7 @@ export interface PluginConfig extends BoundedJsonlStateConfig, SecurityConfig {
   harmonicRetrievalEnabled: boolean;
   abstractionAnchorsEnabled: boolean;
   abstractionNodeStoreDir: string;
+  episodicContextEnabled: boolean;
   // Episodic/semantic split foundation
   verifiedRecallEnabled: boolean;
   semanticRulePromotionEnabled: boolean;
@@ -1870,6 +1870,8 @@ export interface PluginConfig extends BoundedJsonlStateConfig, SecurityConfig {
   oramaEnabled: boolean;
   oramaDbPath?: string;
   oramaEmbeddingDimension?: number;
+  /** Segment space-free scripts (CJK/Thai) in the Orama lexical index (issue #2187). Default `true`. */
+  oramaCjkSegmentation?: boolean;
 
   // QMD daemon mode
   qmdDaemonEnabled: boolean;
@@ -2908,12 +2910,10 @@ export interface MemoryFrontmatter extends SourceConnectorProvenance, OriginMeta
   /** Last time this memory was accessed (ISO 8601) */
   lastAccessed?: string;
   // Memory Worth counters (issue #560)
-  //
   // Per-fact outcome counters used to derive a dynamic utility score —
   // `p(success | retrieved)` — as a complement to the static `importance`
   // field. Absent on legacy memories written before #560; readers must treat
   // `undefined` as zero observations (uniform Beta(1,1) prior).
-  //
   // Both values must be non-negative integers on write. PR 1 wires only the
   // schema + storage round-trip — no increments, scoring, or filtering yet.
   /** Number of sessions where this memory was retrieved and the outcome was judged a success. */