@remnic/core 9.62.1 → 9.62.2

package/src/orchestration/episodic-context-section.ts

@@ -0,0 +1,255 @@
+/**
+ * Episodic-context recall section (issue #2331, harmonic-memory P3).
+ *
+ * Extracted sibling of `recallInternal`'s final assembly phase: resolves the
+ * structured `sources` provenance of the top recalled facts to LCM archive
+ * turn ranges, groups overlapping ranges into episodes, and appends the raw
+ * turns as a `## Source Episodes` section — pure lookup + formatting, no LLM
+ * calls, read-only archive access, inside the enrichment deadline.
+ *
+ * Opt-in: the registry entry is gated on `episodicContextEnabled === true`
+ * (default off), so flag-off returns before touching the archive and recall
+ * output stays byte-identical.
+ */
+
+import { lcmSessionKeyForNamespace } from "../coding/coding-namespace.js";
+import { type EpisodicFactInput, planEpisodeWindowsWithFallback } from "../episodic-context.js";
+import type { LcmMessage } from "../lcm/archive.js";
+import { log } from "../logger.js";
+import {
+  type RecallSectionMetric,
+  resolveRecallCoreSectionDeadlineMs,
+  runRecallSectionWithinDeadline,
+} from "../recall-qos.js";
+import { cleanArchivedUserMessage } from "../user-message-cleaning.js";
+import type { RecallSectionBuckets } from "./recall-section-coordinator.js";
+import type { RecallInternalDeps } from "./recall-internal-deps.js";
+import type { ScopePlan } from "../scopes/scope-plan.js";
+
+/** Cap on recalled facts whose provenance is read per recall. */
+const EPISODIC_FACT_SCAN_LIMIT = 8;
+/** Per-turn character cap inside a Source Episodes block. */
+const EPISODIC_TURN_CHAR_LIMIT = 300;
+
+export async function appendEpisodicContextSection(
+  deps: RecallInternalDeps,
+  options: {
+    sectionBuckets: RecallSectionBuckets;
+    recalledMemoryPaths: string[];
+    recalledMemoryNamespaces: Array<string | undefined>;
+    scopePlan: ScopePlan;
+    namespacesEnabled: boolean;
+    enrichmentSectionDeadlineMs: number;
+    recallOuterTimeoutMs: number;
+    recallStart: number;
+    abortSignal?: AbortSignal;
+    recordMetric: (metric: RecallSectionMetric) => void;
+  },
+): Promise<void> {
+  const engine = deps.lcmEngine;
+  if (!engine?.enabled) return;
+  if (!deps.isRecallSectionEnabled("episodic-context", false)) return;
+  const maxEpisodes =
+    deps.getRecallSectionNumber("episodic-context", "maxResults") ?? 2;
+  const maxTurns = deps.getRecallSectionNumber("episodic-context", "maxTurns") ?? 8;
+  const skip = (timing: string) =>
+    options.recordMetric({
+      section: "episodicContext",
+      priority: "enrichment",
+      durationMs: 0,
+      deadlineMs: options.enrichmentSectionDeadlineMs,
+      source: "skip",
+      success: true,
+      timing,
+    });
+  if (maxEpisodes <= 0 || maxTurns <= 0) {
+    // Zero semantics (checklist item 33): disable before any archive query.
+    skip("skip(limit=0)");
+    return;
+  }
+  if (options.recalledMemoryPaths.length === 0) {
+    skip("skip(no-memories)");
+    return;
+  }
+
+  const outerDeadlineAtMs =
+    options.recallOuterTimeoutMs > 0
+      ? options.recallStart + options.recallOuterTimeoutMs
+      : null;
+  const remainingOuterMs =
+    outerDeadlineAtMs === null ? null : outerDeadlineAtMs - deps.recallAssemblyClockMs();
+  const deadlineMs = resolveRecallCoreSectionDeadlineMs({
+    configuredCoreDeadlineMs: options.enrichmentSectionDeadlineMs,
+    remainingOuterMs,
+  });
+
+  const outcome = await runRecallSectionWithinDeadline<string | null>({
+    deadlineMs,
+    fallback: null,
+    parentSignal: options.abortSignal,
+    run: async (signal) => {
+      // 1. Structured provenance from the top recalled facts. Facts whose
+      // frontmatter carries no `sources` array are silently skipped (no
+      // legacy scalar `source` parsing — issue non-goal).
+      const facts: EpisodicFactInput[] = [];
+      const scanLimit = Math.min(
+        options.recalledMemoryPaths.length,
+        EPISODIC_FACT_SCAN_LIMIT,
+      );
+      for (let index = 0; index < scanLimit; index += 1) {
+        const memoryPath = options.recalledMemoryPaths[index]!;
+        const namespace = options.recalledMemoryNamespaces[index];
+        try {
+          const storage = await deps.storageRouter.storageFor(
+            namespace ?? deps.config.defaultNamespace,
+          );
+          const memory = await storage.readMemoryByPath(memoryPath);
+          const sources = memory?.frontmatter?.sources;
+          if (memory && Array.isArray(sources) && sources.length > 0) {
+            facts.push({
+              memoryId: memory.frontmatter.id,
+              rank: index,
+              sources,
+            });
+          }
+        } catch (err) {
+          log.debug(
+            `episodic-context: provenance read failed for ${memoryPath}`,
+            err,
+          );
+        }
+      }
+      if (facts.length === 0) return null;
+
+      // 2. Authoritative LCM session ids for a provenance sessionKey
+      // (checklist item 30): only keys framed under the caller's authorized read
+      // namespaces. A foreign session's rows live under a foreign namespace
+      // frame and are unreachable through this mapping.
+      const readNamespaces = options.namespacesEnabled
+        ? options.scopePlan.lcmReadNamespaces
+        : [deps.config.defaultNamespace];
+      const candidateSessionIds = (sessionKey: string): string[] => {
+        const seen = new Set<string>();
+        const out: string[] = [];
+        for (const namespace of readNamespaces) {
+          const key =
+            lcmSessionKeyForNamespace(
+              namespace,
+              sessionKey,
+              deps.config.defaultNamespace,
+            ) ?? sessionKey;
+          if (!seen.has(key)) {
+            seen.add(key);
+            out.push(key);
+          }
+        }
+        return out;
+      };
+
+      // 3. Plan windows (pure) with the single documented quote fallback.
+      const windows = await planEpisodeWindowsWithFallback({
+        recalledFacts: facts,
+        maxEpisodes,
+        maxTurnsPerEpisode: maxTurns,
+        locateQuote: async (quote, sessionKey) => {
+          for (const sessionId of candidateSessionIds(sessionKey)) {
+            try {
+              const hits = await engine.searchContextFull(quote, 1, sessionId);
+              if (hits.length > 0) return hits[0]!.turn_index;
+            } catch (err) {
+              // One failing session read must not sink the fallback; try the
+              // next candidate (fail-open per candidate).
+              log.debug(
+                `episodic-context: quote search failed for session ${sessionId}`,
+                err,
+              );
+            }
+          }
+          return null;
+        },
+      });
+      if (windows.length === 0) return null;
+
+      // 4. Fetch + clean raw turns. `getMessages` bounds are inclusive, so
+      // the exclusive `toTurn` passes as `toTurn - 1`.
+      const episodes: Array<{
+        sessionKey: string;
+        fromTurn: number;
+        toTurn: number;
+        memoryIds: readonly string[];
+        turns: ReadonlyArray<{ role: string; content: string }>;
+      }> = [];
+      for (const window of windows) {
+        if (signal.aborted) break;
+        let rows: LcmMessage[] = [];
+        for (const sessionId of candidateSessionIds(window.sessionKey)) {
+          try {
+            const fetched = await engine.getTurnRange(
+              sessionId,
+              window.fromTurn,
+              window.toTurn - 1,
+            );
+            if (fetched.length > 0) {
+              rows = fetched;
+              break;
+            }
+          } catch (err) {
+            // A failing session read skips that candidate only; the window
+            // is dropped when every candidate fails (fail-open).
+            log.debug(
+              `episodic-context: turn-range read failed for session ${sessionId}`,
+              err,
+            );
+          }
+        }
+        if (rows.length === 0) continue;
+        const turns = rows
+          .filter((m) => m.role === "user" || m.role === "assistant")
+          .map((m) => ({
+            role: m.role,
+            content:
+              m.role === "user"
+                ? cleanArchivedUserMessage(m.content)
+                : m.content,
+          }))
+          .map((turn) => ({
+            ...turn,
+            content:
+              turn.content.length > EPISODIC_TURN_CHAR_LIMIT
+                ? `${turn.content.slice(0, EPISODIC_TURN_CHAR_LIMIT)}…`
+                : turn.content,
+          }));
+        if (turns.length === 0) continue;
+        episodes.push({
+          sessionKey: window.sessionKey,
+          fromTurn: window.fromTurn,
+          toTurn: window.toTurn,
+          memoryIds: window.memoryIds,
+          turns,
+        });
+      }
+      return episodes.length > 0
+        ? deps.recallResultFormatter.formatEpisodicContext(episodes)
+        : null;
+    },
+  });
+
+  options.recordMetric({
+    section: "episodicContext",
+    priority: "enrichment",
+    durationMs: outcome.durationMs,
+    deadlineMs,
+    source: outcome.timedOut ? "timeout" : "fresh",
+    success: true,
+    ...(outcome.timedOut
+      ? { timing: `timeout(${Math.max(0, Math.round(outcome.durationMs))}ms)` }
+      : {}),
+  });
+  if (outcome.value === null) return;
+  const maxChars = deps.getRecallSectionMaxChars("episodic-context");
+  const body =
+    typeof maxChars === "number"
+      ? deps.truncateRecallSectionToBudget(outcome.value, maxChars)
+      : outcome.value;
+  deps.appendRecallSection(options.sectionBuckets, "episodic-context", body);
+}

package/src/orchestration/recall-internal-deps.ts

@@ -13,6 +13,7 @@ import type { EvalShadowRecallRecord } from "../evals.js";
 import type { HarmonicRetrievalResult } from "../harmonic-retrieval.js";
 import type { StorageManager } from "../index.js";
 import type { LcmEngine } from "../lcm/index.js";
+import type { RecallResultFormatter } from "./recall-result-formatter.js";
 import type { NamespaceCatalog } from "../namespaces/catalog.js";
 import type { NamespaceStorageRouter } from "../namespaces/storage.js";
 import type { ObjectiveStateSearchResult } from "../objective-state.js";
@@ -248,6 +249,7 @@ export interface RecallInternalDeps {
   formatHarmonicRetrievalResults(
     results: HarmonicRetrievalResult[],
   ): string;
+  readonly recallResultFormatter: RecallResultFormatter;
   formatObjectiveStateResults(
     results: ObjectiveStateSearchResult[],
   ): string;

package/src/orchestration/recall-internal.ts

@@ -70,9 +70,9 @@ import { isDisagreementPrompt } from "../signal.js";
 import { buildTargetedFactRecallSection, shouldRecallTargetedFactEvidence } from "../targeted-fact-recall.js";
 import { shouldFilterSupersededFromRecall } from "../temporal-supersession.js";
 import { queryTemporalTimelineAsync } from "../temporal-index.js";
-import { buildTemporalTimelineRecallSection, type TemporalTimelineRecallItem } from "../temporal-timeline-recall.js";
-import { isValidAsOf } from "../temporal-validity.js";
 import { type TrustStageResultItem, projectTrustForXray } from "../trust-score-stage.js";
+import { isValidAsOf } from "../temporal-validity.js";
+import { buildTemporalTimelineRecallSection, type TemporalTimelineRecallItem } from "../temporal-timeline-recall.js";
 import { searchTrustZoneRecords } from "../trust-zones.js";
 import type { IdentityInjectionMode, MemoryFile, QmdSearchResult, RecallPlanMode } from "../types.js";
 import { type VerifiedEpisodeResult, compareVerifiedEpisodeResults, searchVerifiedEpisodes } from "../verified-recall.js";
@@ -105,6 +105,7 @@ import {
   type RecallResultPartitionSink,
 } from "./recall-rerank-coordinator.js";
 import type { RecallInternalDeps } from "./recall-internal-deps.js";
+import { appendEpisodicContextSection } from "./episodic-context-section.js";
 import { resolveCompositeProfileStorage } from "./recall-profile-storage.js";
 
 export class RecallInternalCoordinator {
@@ -469,29 +470,16 @@ export class RecallInternalCoordinator {
       scopeProfilePlan,
       lcmReadSessionIds,
     } = scopePlan;
-    // Query an LCM-backed read across the ordered read key set and return the
-    // FIRST non-empty result (#1505 fallback-namespace unification). The primary
-    // overlay key is tried first; if a branch-scoped session has no rows under its
-    // branch key, the project / root fallback keys are tried in order.
-    //
-    // #1505 codex P2 ("Merge LCM fallback reads instead of short-circuiting"): the
-    // query-SCORED sections (explicit-cue, targeted-facts, focused-list,
-    // response-guidance, event-order, structured message-parts) no longer use this
-    // helper — they MERGE candidates across EVERY authorized key under their single
-    // budget (a weak primary-key hit must not mask stronger fallback evidence; the
-    // section builders take `sessionIds`, structured-parts merges inline below).
-    // This first-non-empty helper now serves ONLY the compressed-history section,
-    // which is a per-session HOLISTIC DAG narrative with no per-item id to merge or
-    // dedupe on — see its call site for the rationale.
-    //
-    // When the set is a single key (single-user / no-overlay / explicit-namespace),
-    // this is exactly one call — unchanged. `lcmSessionId` is `string | undefined`:
-    // a legacy SESSIONLESS recall yields the single `undefined` key so the read
-    // runs ONE archive-wide read with no `session_id` filter (pre-#1505 behavior).
-    // Hosted scope profiles are stricter: without a session key there is no
-    // namespace-scoped LCM key to query, so the key set stays empty and LCM cannot
-    // bypass the profile read stack via an archive-wide read. NEVER the literal
-    // "default" session id (codex P2).
+    // `firstNonEmptyLcmRead`: query the ordered LCM read key set, return the
+    // FIRST non-empty result (#1505). The query-SCORED sections no longer use
+    // it — they MERGE candidates across every authorized key (a weak primary
+    // hit must not mask stronger fallback evidence); this helper now serves
+    // only compressed-history, a holistic per-session DAG narrative with no
+    // per-item id to merge on. A single-key set is exactly one call. A legacy
+    // SESSIONLESS recall yields one `undefined` key: one archive-wide read,
+    // no `session_id` filter. Hosted scope profiles without a session key get
+    // an EMPTY key set, so LCM cannot bypass the profile read stack. NEVER
+    // the literal "default" session id (codex P2).
     const firstNonEmptyLcmRead = async <T>(
       read: (lcmSessionId: string | undefined) => Promise<T>,
       isEmpty: (value: T) => boolean,
@@ -4926,6 +4914,32 @@ export class RecallInternalCoordinator {
       recallPlan: timings.recallPlan,
       queryPolicy: timings.queryPolicy,
     });
+    // Episodic context (#2331): opt-in raw-turn episodes for the top recalled
+    // facts; flag off is a no-op so recall output stays byte-identical.
+    // Namespaces must be index-aligned with recalledMemoryPaths here — every
+    // recall branch populates xrayRecalledResults from the same array it
+    // mapped paths from, so per-path namespaces derive from those results
+    // (the assembly-time assignment below runs after this section).
+    const episodicNamespaceByPath = new Map<string, string | undefined>();
+    for (const result of xrayRecalledResults) {
+      if (result.path) episodicNamespaceByPath.set(result.path, result.namespace);
+    }
+    const episodicMemoryNamespaces = recalledMemoryPaths.map((memoryPath) =>
+      episodicNamespaceByPath.get(memoryPath),
+    );
+    // The section is advisory context: an archive error degrades the
+    // section, never the recall (fail-open).
+    try {
+      await appendEpisodicContextSection(this.deps, {
+        sectionBuckets, recalledMemoryPaths,
+        recalledMemoryNamespaces: episodicMemoryNamespaces,
+        scopePlan, namespacesEnabled,
+        enrichmentSectionDeadlineMs, recallOuterTimeoutMs, recallStart,
+        recordMetric: recordRecallSectionMetric, abortSignal: options.abortSignal,
+      });
+    } catch (err) {
+      log.debug("episodic-context: section degraded after error", err);
+    }
     const recallBudgetChars = this.deps.getRecallBudgetChars(options.budgetCharsOverride);
     const assembledRecall = this.deps.assembleRecallSections(
       sectionBuckets, contextBudgetForFooter(recallBudgetChars, curiosityFooter),
@@ -5326,4 +5340,5 @@ export class RecallInternalCoordinator {
       closeProfileTrace();
     }
   }
+
 }

package/src/orchestration/recall-result-formatter.ts

@@ -384,6 +384,43 @@ export class RecallResultFormatter {
     return `## Harmonic Retrieval\n\n${lines.join("\n\n")}`;
   }
 
+  /**
+   * Render grouped raw-turn episodes for the top recalled facts (issue #2331).
+   * Returns `null` for zero episodes so the section is omitted entirely —
+   * never an empty header.
+   */
+  formatEpisodicContext(
+    episodes: ReadonlyArray<{
+      sessionKey: string;
+      fromTurn: number;
+      toTurn: number;
+      memoryIds: readonly string[];
+      turns: ReadonlyArray<{ role: string; content: string }>;
+    }>,
+  ): string | null {
+    if (episodes.length === 0) return null;
+    const blocks = episodes.map((episode) => {
+      const shortKey =
+        episode.sessionKey.length > 8
+          ? `${episode.sessionKey.slice(0, 8)}…`
+          : episode.sessionKey;
+      const header =
+        `### Episode: ${shortKey} turns ${episode.fromTurn}-${episode.toTurn - 1} ` +
+        `(supports [${episode.memoryIds.join(", ")}])`;
+      const lines = episode.turns.map((turn) => {
+        // Archived conversation turns carry no origin: least-privilege
+        // fencing applies when origin authority is enabled (issue #2331).
+        const content = renderAuthorityBoundContent(turn.content, undefined, {
+          enabled: this.originAuthorityEnabled,
+          untrustedOrigins: this.config.untrustedOrigins,
+        });
+        return `${turn.role}: ${content}`;
+      });
+      return [header, ...lines].join("\n");
+    });
+    return `## Source Episodes\n\n${blocks.join("\n\n")}`;
+  }
+
   formatWorkProductResults(
     results: WorkProductLedgerSearchResult[],
   ): string {

package/src/recall-tokenization.ts

@@ -4,7 +4,7 @@ export interface NormalizeRecallTokenOptions {
 
 const DEFAULT_RECALL_STOP_WORDS = ["the", "and", "for", "with", "from", "into", "that", "this", "why", "did"];
 
-function isUnsegmentableRecallChar(char: string): boolean {
+export function isUnsegmentableRecallChar(char: string): boolean {
   if (char === "ー" || char === "ｰ") return true;
   return /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]/u.test(char);
 }
@@ -24,21 +24,27 @@ function shouldKeepRecallToken(token: string, minTokenLength: number, stopWords:
   return token.length >= 2 && hasNonAsciiCodepoint && /\p{L}/u.test(token);
 }
 
-function addUnsegmentableRecallSegment(tokens: Set<string>, segment: string, stopWords: Set<string>): void {
+export function expandUnsegmentableRecallNGrams(segment: string): string[] {
   const chars = [...segment].filter((ch) => /[\p{L}\p{N}\p{M}]/u.test(ch) || isUnsegmentableRecallChar(ch));
+  const tokens: string[] = [];
   for (const ch of chars) {
-    if (!stopWords.has(ch)) tokens.add(ch);
+    tokens.push(ch);
   }
   for (const size of [2, 3, 4]) {
     if (chars.length < size) continue;
     for (let index = 0; index <= chars.length - size; index += 1) {
-      const token = chars.slice(index, index + size).join("");
-      if (!stopWords.has(token)) tokens.add(token);
+      tokens.push(chars.slice(index, index + size).join(""));
     }
   }
-  const whole = chars.join("");
-  if (whole.length > 3 && !stopWords.has(whole)) {
-    tokens.add(whole);
+  if (chars.length > 3) {
+    tokens.push(chars.join(""));
+  }
+  return tokens;
+}
+
+function addUnsegmentableRecallSegment(tokens: Set<string>, segment: string, stopWords: Set<string>): void {
+  for (const token of expandUnsegmentableRecallNGrams(segment)) {
+    if (!stopWords.has(token)) tokens.add(token);
   }
 }
 

package/src/reconcile/manifest.test.ts

@@ -50,6 +50,7 @@ test("reconcile manifest keeps file identity separate from canonical semantic id
     category: "fact",
     contentHash: semanticHash,
     normalizerVersion: 4,
+    identityResolutionVersion: 2,
     status: "active",
   });
 });
@@ -100,11 +101,52 @@ test("reconcile manifest reparses cached pre-version identities after Unicode mi
   });
 
   assert.equal(reads, 1);
+  // The café body is lossy under the legacy normalizer, so the persisted
+  // legacy hash stays primary and the recovered current identity rides along
+  // as an alias (issue #2367).
   assert.equal(
     manifest.files[0]?.memory?.contentHash,
-    ContentHashIndex.computeHash(content),
+    legacyHash,
   );
-  assert.equal("contentHashAliases" in (manifest.files[0]?.memory ?? {}), false);
+  assert.deepEqual(manifest.files[0]?.memory?.contentHashAliases, [
+    ContentHashIndex.computeHash(content),
+  ]);
+});
+
+test("reconcile manifest reparses cached identities lacking the identity-resolution version", async () => {
+  const content = "The user prefers café.";
+  const legacyHash = computeLegacyContentHash(content);
+  const serialized = memoryFile({ id: "legacy-identity-version", content, contentHash: legacyHash });
+  const file = { path: "facts/legacy-identity-version.md", sha256: fileHash(serialized) };
+  let reads = 0;
+
+  const manifest = await buildReconcileManifest({
+    files: [file],
+    parseMemory: parseFrontmatter,
+    readFile: async () => {
+      reads += 1;
+      return serialized;
+    },
+    // Same normalizerVersion, but written before identity-resolution
+    // versioning existed: the entry carries no aliases and must NOT be
+    // reused (issue #2367 review round 2).
+    cachedFiles: [{
+      ...file,
+      memory: {
+        id: "legacy-identity-version",
+        category: "fact",
+        contentHash: legacyHash,
+        normalizerVersion: 4,
+        status: "active",
+      },
+    }],
+  });
+
+  assert.equal(reads, 1);
+  assert.equal(manifest.files[0]?.memory?.identityResolutionVersion, 2);
+  assert.deepEqual(manifest.files[0]?.memory?.contentHashAliases, [
+    ContentHashIndex.computeHash(content),
+  ]);
 });
 
 test("reconcile manifest replaces a pure-CJK legacy identity with its current hash", async () => {
@@ -146,7 +188,10 @@ test("reconcile manifest recovers a raw hash source beneath citation and attribu
     readFile: async () => serialized,
   });
 
-  assert.equal(manifest.files[0]?.memory?.contentHash, ContentHashIndex.computeHash(content));
+  assert.equal(manifest.files[0]?.memory?.contentHash, computeLegacyContentHash(content));
+  assert.deepEqual(manifest.files[0]?.memory?.contentHashAliases, [
+    ContentHashIndex.computeHash(content),
+  ]);
 });
 
 test("reconcile manifest recovers raw identity beneath a configured citation", async () => {
@@ -169,7 +214,91 @@ test("reconcile manifest recovers raw identity beneath a configured citation", a
     citationTemplate,
   });
 
-  assert.equal(manifest.files[0]?.memory?.contentHash, ContentHashIndex.computeHash(content));
+  assert.equal(manifest.files[0]?.memory?.contentHash, computeLegacyContentHash(content));
+  assert.deepEqual(manifest.files[0]?.memory?.contentHashAliases, [
+    ContentHashIndex.computeHash(content),
+  ]);
+});
+
+test("reconcile manifest prefers a persisted explicit hash over a colliding legacy body hash (issue #2367)", async () => {
+  // Source `caf` with body `café`: hash("caf") numerically equals the legacy
+  // hash of the stored body, but it is the fact's explicit contentHashSource
+  // identity written by the current normalizer. The legacy candidate match
+  // must not replace it.
+  const source = "caf";
+  const body = "café";
+  const persistedHash = ContentHashIndex.computeHash(source);
+  assert.equal(persistedHash, computeLegacyContentHash(body));
+  const serialized = memoryFile({ id: "explicit-source", content: body, contentHash: persistedHash });
+  const manifest = await buildReconcileManifest({
+    files: [{ path: "facts/explicit-source.md", sha256: fileHash(serialized) }],
+    parseMemory: parseFrontmatter,
+    readFile: async () => serialized,
+  });
+
+  assert.equal(manifest.files[0]?.memory?.contentHash, persistedHash);
+  assert.notEqual(manifest.files[0]?.memory?.contentHash, ContentHashIndex.computeHash(body));
+  assert.deepEqual(manifest.files[0]?.memory?.contentHashAliases, [
+    ContentHashIndex.computeHash(body),
+  ]);
+});
+
+test("reconcile collapse matches an explicit-source replica through the persisted hash (issue #2367)", async () => {
+  const source = "caf";
+  const persistedHash = ContentHashIndex.computeHash(source);
+  const localSerialized = memoryFile({ id: "explicit-local", content: "café", contentHash: persistedHash });
+  const peerSerialized = memoryFile({ id: "explicit-peer", content: source, contentHash: persistedHash });
+  const localFile = { path: "facts/explicit-local.md", sha256: fileHash(localSerialized) };
+  const peerFile = { path: "facts/explicit-peer.md", sha256: fileHash(peerSerialized) };
+  const build = async (file: typeof localFile, raw: string) =>
+    await buildReconcileManifest({
+      files: [file],
+      parseMemory: parseFrontmatter,
+      readFile: async () => raw,
+    });
+  const local = await build(localFile, localSerialized);
+  const peer = await build(peerFile, peerSerialized);
+  const plan = planReconciliation([{ namespace: "default", local: [localFile], peer: [peerFile] }]);
+
+  const collapsed = collapseActiveFactDuplicates(
+    plan,
+    new Map([["default", local]]),
+    new Map([["default", peer]]),
+  );
+
+  assert.equal(collapsed.converged, true);
+  assert.equal(collapsed.entries.length, 1);
+  assert.equal(collapsed.entries[0]?.reason, "semantic_duplicate");
+});
+
+test("reconcile manifest does not collapse distinct pure-CJK legacy facts through the empty skeleton (issue #2367)", async () => {
+  const first = "利用者は紅茶を好む。";
+  const second = "利用者は珈琲を好む。";
+  assert.equal(computeLegacyContentHash(first), computeLegacyContentHash(second));
+  const build = async (id: string, content: string) => {
+    const serialized = memoryFile({ id, content, contentHash: computeLegacyContentHash(content) });
+    const file = { path: `facts/${id}.md`, sha256: fileHash(serialized) };
+    const manifest = await buildReconcileManifest({
+      files: [file],
+      parseMemory: parseFrontmatter,
+      readFile: async () => serialized,
+    });
+    return { file, manifest };
+  };
+  const a = await build("legacy-cjk-first", first);
+  const b = await build("legacy-cjk-second", second);
+  const plan = planReconciliation([
+    { namespace: "default", local: [a.file], peer: [b.file] },
+  ]);
+
+  const collapsed = collapseActiveFactDuplicates(
+    plan,
+    new Map([["default", a.manifest]]),
+    new Map([["default", b.manifest]]),
+  );
+
+  assert.equal(collapsed.converged, false);
+  assert.equal(collapsed.entries.length, 2);
 });
 
 test("reconcile manifest does not add a legacy alias to a current Unicode identity", async () => {