@fgv/ts-agent-memory 5.1.0-39 → 5.1.0-41

package/src/test/unit/ingest/cycleGuard.test.ts

@@ -4,12 +4,29 @@
  */
 
 import '@fgv/ts-utils-jest';
-import { ICycleGuardEdge, LinkType, MemoryId, assertNoCycles, buildCycleKey } from '../../../index';
+import {
+  ICycleGuardEdge,
+  IEdgeTarget,
+  LinkType,
+  MemoryId,
+  MemoryScopeKey,
+  assertNoCycles,
+  buildCycleKey
+} from '../../../index';
 
 const rel: LinkType = 'rel' as LinkType;
+const DEFAULT_SCOPE: string = 'exp';
+
+/** A scope-qualified node, `scope#id` or a bare id defaulting to {@link DEFAULT_SCOPE}. */
+function node(spec: string): IEdgeTarget {
+  const hash: number = spec.indexOf('#');
+  const scope: string = hash >= 0 ? spec.slice(0, hash) : DEFAULT_SCOPE;
+  const id: string = hash >= 0 ? spec.slice(hash + 1) : spec;
+  return { scope: scope as MemoryScopeKey, id: id as MemoryId };
+}
 
 function edge(source: string, target: string, type: LinkType = rel): ICycleGuardEdge {
-  return { source: source as MemoryId, target: target as MemoryId, type };
+  return { source: node(source), target: node(target), type };
 }
 
 describe('buildCycleKey', () => {
@@ -65,4 +82,29 @@ describe('assertNoCycles', () => {
     // visited-node skip in the traversal.
     expect(assertNoCycles([edge('a', 'c'), edge('a', 'b'), edge('b', 'c')], [edge('z', 'a')])).toSucceed();
   });
+
+  describe('scope-qualified nodes', () => {
+    test('does NOT conflate a stem shared across scopes into one node', () => {
+      // ca#x -> cb#y and cb#x -> ca#z reuse the stem `x` across scopes ca/cb.
+      // If the guard keyed on bare id, the two `x` nodes would merge and a false
+      // cycle could appear; with scoped keys they are distinct and the graph is acyclic.
+      expect(assertNoCycles([], [edge('ca#x', 'cb#y'), edge('cb#x', 'ca#z')])).toSucceed();
+    });
+
+    test('still rejects a genuine within-scope cycle across the same stems', () => {
+      expect(assertNoCycles([], [edge('ca#x', 'ca#y'), edge('ca#y', 'ca#x')])).toFailWith(
+        /would create a cycle/
+      );
+    });
+
+    test('a self-loop is detected on the full scoped identity', () => {
+      expect(assertNoCycles([], [edge('ca#x', 'ca#x')])).toFailWith(/self-loop/);
+      // Same stem, different scope is NOT a self-loop.
+      expect(assertNoCycles([], [edge('ca#x', 'cb#x')])).toSucceed();
+    });
+
+    test('names the scope in the diagnostic', () => {
+      expect(assertNoCycles([], [edge('ca#x', 'ca#x')])).toFailWith(/ca\/x/);
+    });
+  });
 });

package/src/test/unit/ingest/orchestrator.test.ts

@@ -17,6 +17,7 @@ import {
   IBodyConverterRegistry,
   ICandidateEdge,
   ICandidateRecord,
+  IEdgeTarget,
   IEntityResolutionCandidate,
   IEntityResolver,
   IFactExtractor,
@@ -28,8 +29,10 @@ import {
   IMemoryClassifier,
   IMemoryEnvelope,
   IMemoryRecord,
+  IMemoryRecordSource,
   IMemoryStore,
   IProvenance,
+  IScopedMemoryRecord,
   IRelationContext,
   IRelationExtractor,
   IVectorIndex,
@@ -40,6 +43,7 @@ import {
   LinkType,
   LtmIdentityCodec,
   MemoryEmbedder,
+  MtmIdentityCodec,
   MemoryId,
   MemoryIngestOrchestrator,
   MemoryScopeKey,
@@ -168,12 +172,36 @@ function candidate(
   };
 }
 
+/**
+ * A scope-qualified target, authored as `scope#id` or a bare id defaulting to the
+ * knowledge scope (where the note/num fixtures live). `kt` is the assertion-side
+ * spelling of the same helper.
+ */
+function scopedTarget(spec: string): IEdgeTarget {
+  const hash: number = spec.indexOf('#');
+  const scope: string = hash >= 0 ? spec.slice(0, hash) : 'knowledge';
+  const id: string = hash >= 0 ? spec.slice(hash + 1) : spec;
+  return { scope: scope as MemoryScopeKey, id: id as MemoryId };
+}
+function kt(id: string, scope: string = 'knowledge'): IEdgeTarget {
+  return { scope: scope as MemoryScopeKey, id: id as MemoryId };
+}
+
+/** The scope-qualified reference of a candidate about to be written, by its entityId. */
+function srcOf(ctx: IRelationContext, entityId: string): IEdgeTarget {
+  const found = ctx.candidates.find((rc) => rc.candidate.envelope.entityId === (entityId as EntityId));
+  if (found === undefined) {
+    throw new Error(`test relater: no candidate with entityId '${entityId}'`);
+  }
+  return found.id;
+}
+
 function candEdge(source: string, type: string, target: string, confidence?: number): ICandidateEdge {
   return {
-    source: source as MemoryId,
+    source: scopedTarget(source),
     edge: {
       type: type as LinkType,
-      target: target as MemoryId,
+      target: scopedTarget(target),
       ...(confidence !== undefined ? { confidence } : {})
     }
   };
@@ -280,7 +308,10 @@ describe('MemoryIngestOrchestrator', () => {
     test('classifies, extracts, and writes one record end-to-end with host-ingest provenance + derivedFrom', async () => {
       const store = buildStore();
       const orch = buildOrchestrator({ store });
-      const sourceId: MemoryId = 'turn-3' as MemoryId;
+      const sourceId: IEdgeTarget = {
+        scope: 'conversations/c1' as MemoryScopeKey,
+        id: 'turn-3' as MemoryId
+      };
       const result = await orch.ingestItem({ id: 'doc-1', content: 'the sky is blue', sourceId });
       expect(result).toSucceedAndSatisfy((r: IIngestItemResult) => {
         expect(r.item.id).toBe('doc-1');
@@ -290,7 +321,7 @@ describe('MemoryIngestOrchestrator', () => {
         expect(rec.resolution.verdict).toBe('new');
         expect(rec.id).toBe('doc-1');
         expect(rec.record?.envelope.provenance.source).toBe(HOST_INGEST_PROVENANCE_SOURCE);
-        expect(rec.record?.envelope.provenance.derivedFrom).toBe('turn-3');
+        expect(rec.record?.envelope.provenance.derivedFrom).toEqual(sourceId);
         expect(rec.record?.body).toBe('the sky is blue');
         expect(rec.interlock).toBeUndefined();
       });
@@ -381,6 +412,28 @@ describe('MemoryIngestOrchestrator', () => {
       });
       expect(await orch.ingestItem({ id: 'o-1', content: 'x' })).toFailWith(/no identity codec/);
     });
+
+    test('fails loudly when a pre-existing snapshot record cannot be scoped (no codec for its kind)', async () => {
+      // The store can persist a note (it has the note codec), but the orchestrator
+      // below is wired WITHOUT a note codec — so when it snapshots the store to run
+      // the edge path, it cannot resolve the seeded note's scope and fails loudly
+      // (never silently drops it from the cycle graph). This is the branch the
+      // scope-qualified edge change added.
+      const store = buildStore();
+      await putNote(store, 'legacy', 'anchor');
+      const orch = MemoryIngestOrchestrator.create({
+        store,
+        registry: registry(),
+        // Deliberately omit the note codec (and any default) that the seeded record needs.
+        codecs: new Map<Kind, IIdentityCodec>([[numKind, new KnowledgeIdentityCodec()]]),
+        classifier: classifier(() => succeed({ kind: numKind })),
+        extractor: extractor(() => succeed([candidate(numKind, 'n-1', 7)])),
+        relationExtractor: noEdges
+      }).orThrow();
+      expect(await orch.ingestItem({ id: 'i', content: 'x' })).toFailWith(
+        /cannot resolve scope for stored record 'legacy'.*no identity codec registered for kind 'note'/i
+      );
+    });
   });
 
   describe('stage 4 — exact dedup (layer 1)', () => {
@@ -392,7 +445,7 @@ describe('MemoryIngestOrchestrator', () => {
       });
       expect(await orch.ingestItem({ id: 'i', content: 'x' })).toSucceedAndSatisfy((r: IIngestItemResult) => {
         expect(r.records[0].disposition).toBe('deduped');
-        expect(r.records[0].resolution).toEqual({ verdict: 'duplicate-of', target: 'doc-a' });
+        expect(r.records[0].resolution).toEqual({ verdict: 'duplicate-of', target: kt('doc-a') });
         expect(r.records[0].id).toBe('doc-a');
       });
       // doc-b was never written.
@@ -464,6 +517,14 @@ function mockStore(overrides: Partial<IMemoryStore>): IMemoryStore {
     list:
       overrides.list ??
       ((): Promise<Result<ReadonlyArray<IMemoryRecord<unknown>>>> => Promise.resolve(succeed([]))),
+    listScoped:
+      overrides.listScoped ??
+      ((): Promise<Result<ReadonlyArray<IScopedMemoryRecord>>> => Promise.resolve(succeed([]))),
+    asRecordSource:
+      overrides.asRecordSource ??
+      ((): IMemoryRecordSource => ({
+        list: (): Promise<Result<ReadonlyArray<IScopedMemoryRecord>>> => Promise.resolve(succeed([]))
+      })),
     put: overrides.put ?? ((r): Promise<Result<IMemoryRecord<unknown>>> => Promise.resolve(succeed(r))),
     delete: overrides.delete ?? ((): Promise<Result<MemoryId>> => Promise.resolve(fail('n/a')))
   };
@@ -495,7 +556,9 @@ describe('MemoryIngestOrchestrator — stage 4 similarity (layer 2)', () => {
       store,
       vectorIndex,
       embed,
-      entityResolver: resolver((__c, similar) => succeed({ verdict: 'duplicate-of', target: similar[0].id })),
+      entityResolver: resolver((__c, similar) =>
+        succeed({ verdict: 'duplicate-of', target: similar[0].target })
+      ),
       extractor: extractor(() => succeed([candidate(noteKind, 'doc-b', 'apple tart')]))
     });
     expect(await orch.ingestItem({ id: 'i', content: 'x' })).toSucceedAndSatisfy((r: IIngestItemResult) => {
@@ -513,12 +576,14 @@ describe('MemoryIngestOrchestrator — stage 4 similarity (layer 2)', () => {
       store,
       vectorIndex,
       embed,
-      entityResolver: resolver((__c, similar) => succeed({ verdict: 'supersede', target: similar[0].id })),
+      entityResolver: resolver((__c, similar) =>
+        succeed({ verdict: 'supersede', target: similar[0].target })
+      ),
       extractor: extractor(() => succeed([candidate(noteKind, 'doc-b', 'apple tart')]))
     });
     expect(await orch.ingestItem({ id: 'i', content: 'x' })).toSucceedAndSatisfy((r: IIngestItemResult) => {
       expect(r.records[0].disposition).toBe('written');
-      expect(r.records[0].resolution).toEqual({ verdict: 'supersede', target: 'doc-a' });
+      expect(r.records[0].resolution).toEqual({ verdict: 'supersede', target: kt('doc-a') });
       expect(r.records[0].id).toBe('doc-b');
     });
     expect(await store.get(noteKind, 'doc-b' as EntityId)).toSucceedAndSatisfy(
@@ -534,7 +599,9 @@ describe('MemoryIngestOrchestrator — stage 4 similarity (layer 2)', () => {
       store,
       vectorIndex,
       embed,
-      entityResolver: resolver((__c, similar) => succeed({ verdict: 'merge-into', target: similar[0].id })),
+      entityResolver: resolver((__c, similar) =>
+        succeed({ verdict: 'merge-into', target: similar[0].target })
+      ),
       extractor: extractor(() => succeed([candidate(noteKind, 'doc-b', 'apple tart')]))
     });
     expect(await orch.ingestItem({ id: 'i', content: 'x' })).toSucceedAndSatisfy((r: IIngestItemResult) => {
@@ -556,11 +623,11 @@ describe('MemoryIngestOrchestrator — stage 4 similarity (layer 2)', () => {
       store,
       vectorIndex,
       embed,
-      entityResolver: resolver(() => succeed({ verdict: 'merge-into', target: 'ghost' as MemoryId })),
+      entityResolver: resolver(() => succeed({ verdict: 'merge-into', target: kt('ghost') })),
       extractor: extractor(() => succeed([candidate(noteKind, 'doc-b', 'apple tart')]))
     });
     expect(await orch.ingestItem({ id: 'i', content: 'x' })).toFailWith(
-      /merge-into target 'ghost' does not exist/
+      /merge-into target 'knowledge\/ghost' does not exist/
     );
   });
 
@@ -601,10 +668,10 @@ describe('MemoryIngestOrchestrator — stage 4 similarity (layer 2)', () => {
 
   test('a surfaced hit with no backing record is skipped', async () => {
     const ghostIndex: IVectorIndex = {
-      add: (id) => Promise.resolve(succeed(id as string)),
-      remove: (id) => Promise.resolve(succeed(id)),
+      add: (t) => Promise.resolve(succeed(t.id as string)),
+      remove: (t) => Promise.resolve(succeed(t)),
       query: (): Promise<Result<ReadonlyArray<IVectorQueryHit>>> =>
-        Promise.resolve(succeed([{ id: 'ghost' as MemoryId, score: 0.99 }]))
+        Promise.resolve(succeed([{ target: kt('ghost'), score: 0.99 }]))
     };
     const orch = buildOrchestrator({
       store: buildStore(),
@@ -632,8 +699,8 @@ describe('MemoryIngestOrchestrator — stage 4 similarity (layer 2)', () => {
 
   test('a similarity-query failure surfaces loudly', async () => {
     const failingIndex: IVectorIndex = {
-      add: (id) => Promise.resolve(succeed(id as string)),
-      remove: (id) => Promise.resolve(succeed(id)),
+      add: (t) => Promise.resolve(succeed(t.id as string)),
+      remove: (t) => Promise.resolve(succeed(t)),
       query: (): Promise<Result<ReadonlyArray<IVectorQueryHit>>> => Promise.resolve(fail('query kaput'))
     };
     const orch = buildOrchestrator({
@@ -716,7 +783,7 @@ describe('MemoryIngestOrchestrator — stage 5 relate + cycle guard', () => {
     expect(await orch.ingestItem({ id: 'i', content: 'x' })).toSucceedAndSatisfy((r: IIngestItemResult) => {
       expect(r.records[0].edges).toHaveLength(1);
       expect(r.records[0].record?.envelope.links).toEqual([
-        { type: 'mentions', target: 'doc-a', confidence: 0.7 }
+        { type: 'mentions', target: kt('doc-a'), confidence: 0.7 }
       ]);
     });
   });
@@ -731,7 +798,7 @@ describe('MemoryIngestOrchestrator — stage 5 relate + cycle guard', () => {
     });
     expect(await orch.ingestItem({ id: 'i', content: 'x' })).toSucceedAndSatisfy((r: IIngestItemResult) => {
       expect(r.records).toHaveLength(2);
-      expect(r.records[0].record?.envelope.links).toEqual([{ type: 'rel', target: 'doc-c' }]);
+      expect(r.records[0].record?.envelope.links).toEqual([{ type: 'rel', target: kt('doc-c') }]);
       expect(r.records[1].edges).toEqual([]);
     });
   });
@@ -743,7 +810,7 @@ describe('MemoryIngestOrchestrator — stage 5 relate + cycle guard', () => {
       relationExtractor: relater(() => succeed([candEdge('ghost', 'rel', 'doc-b')]))
     });
     expect(await orch.ingestItem({ id: 'i', content: 'x' })).toFailWith(
-      /edge source 'ghost' is not a candidate being written/
+      /edge source 'knowledge\/ghost' is not a candidate being written/
     );
   });
 
@@ -754,7 +821,7 @@ describe('MemoryIngestOrchestrator — stage 5 relate + cycle guard', () => {
       relationExtractor: relater(() => succeed([candEdge('doc-b', 'rel', 'ghost')]))
     });
     expect(await orch.ingestItem({ id: 'i', content: 'x' })).toFailWith(
-      /edge target 'ghost' resolves to neither/
+      /edge target 'knowledge\/ghost' resolves to neither/
     );
   });
 
@@ -783,8 +850,8 @@ describe('MemoryIngestOrchestrator — stage 5 relate + cycle guard', () => {
       )
     });
     expect(await orch.ingestItem({ id: 'i', content: 'x' })).toSucceedAndSatisfy((r: IIngestItemResult) => {
-      expect(r.records[0].record?.envelope.links).toEqual([{ type: 'rel', target: 'doc-c' }]);
-      expect(r.records[1].record?.envelope.links).toEqual([{ type: 'rel', target: 'doc-b' }]);
+      expect(r.records[0].record?.envelope.links).toEqual([{ type: 'rel', target: kt('doc-c') }]);
+      expect(r.records[1].record?.envelope.links).toEqual([{ type: 'rel', target: kt('doc-b') }]);
     });
   });
 
@@ -798,7 +865,111 @@ describe('MemoryIngestOrchestrator — stage 5 relate + cycle guard', () => {
     });
     expect(await orch.ingestItem({ id: 'i', content: 'x' })).toSucceedAndSatisfy((r: IIngestItemResult) => {
       expect(r.records[0].interlock).toBeUndefined();
-      expect(r.records[0].record?.envelope.links).toEqual([{ type: 'contradicts', target: 'doc-a' }]);
+      expect(r.records[0].record?.envelope.links).toEqual([{ type: 'contradicts', target: kt('doc-a') }]);
+    });
+  });
+
+  describe('_validateEdges cross-scope target disambiguation', () => {
+    // Two EXISTING records share the idStem 'turn-3' across two conversations
+    // (the MTM codec mints per-scope stems). A stage-5 edge target must resolve
+    // to the CORRECT (scope, id) — with bare-id keying both would alias and a
+    // wrong-scope target would silently validate. Guards the ingest-validation seam.
+    const mtmKind: Kind = 'mtm' as Kind;
+
+    function mtmRegistry(): IBodyConverterRegistry {
+      const reg = registry();
+      reg.register(mtmKind, Converters.string);
+      return reg;
+    }
+
+    const mtmCodecs: ReadonlyMap<Kind, IIdentityCodec> = new Map<Kind, IIdentityCodec>([
+      [mtmKind, new MtmIdentityCodec()]
+    ]);
+
+    async function seedTurn(store: FileTreeMemoryStore, entityId: string, body: string): Promise<void> {
+      const addr = new MtmIdentityCodec().encode(entityId as EntityId).orThrow();
+      const rec: IMemoryRecord<unknown> = {
+        envelope: {
+          id: addr.idStem as MemoryId,
+          entityId: entityId as EntityId,
+          kind: mtmKind,
+          tags: [],
+          links: [],
+          created: 0,
+          updated: 0,
+          seq: 0,
+          contentHash: '',
+          provenance: { source: 'agent' }
+        },
+        body
+      };
+      (await store.put(rec)).orThrow();
+    }
+
+    function buildMtmOrchestrator(
+      store: FileTreeMemoryStore,
+      relationExtractor: IRelationExtractor
+    ): MemoryIngestOrchestrator {
+      return MemoryIngestOrchestrator.create({
+        store,
+        registry: mtmRegistry(),
+        codecs: mtmCodecs,
+        classifier: classifier(() => succeed({ kind: mtmKind })),
+        // The candidate is a fresh turn-5 under conv-a (distinct stem from the seeds).
+        extractor: extractor(() => succeed([candidate(mtmKind, 'conv-a:5', 'a new turn')])),
+        relationExtractor
+      }).orThrow();
+    }
+
+    async function seededStore(): Promise<FileTreeMemoryStore> {
+      const store = FileTreeMemoryStore.create({
+        root: mutableRoot(),
+        registry: mtmRegistry(),
+        codecs: mtmCodecs,
+        clock
+      }).orThrow();
+      await seedTurn(store, 'conv-a:3', 'anchor in conversation a');
+      await seedTurn(store, 'conv-b:3', 'anchor in conversation b');
+      return store;
+    }
+
+    test('accepts a same-stem edge target that resolves to the correct scope', async () => {
+      const store = await seededStore();
+      const orch = buildMtmOrchestrator(
+        store,
+        relater((ctx) =>
+          succeed([
+            {
+              source: srcOf(ctx, 'conv-a:5'),
+              edge: { type: 'rel' as LinkType, target: kt('turn-3', 'conversations/conv-a') }
+            }
+          ])
+        )
+      );
+      expect(await orch.ingestItem({ id: 'i', content: 'x' })).toSucceedAndSatisfy((r: IIngestItemResult) => {
+        expect(r.records[0].record?.envelope.links).toEqual([
+          { type: 'rel', target: kt('turn-3', 'conversations/conv-a') }
+        ]);
+      });
+    });
+
+    test('rejects a same-stem edge target whose scope has no matching record', async () => {
+      const store = await seededStore();
+      const orch = buildMtmOrchestrator(
+        store,
+        relater((ctx) =>
+          succeed([
+            {
+              source: srcOf(ctx, 'conv-a:5'),
+              // turn-3 exists under conv-a and conv-b, but NOT conv-z.
+              edge: { type: 'rel' as LinkType, target: kt('turn-3', 'conversations/conv-z') }
+            }
+          ])
+        )
+      );
+      expect(await orch.ingestItem({ id: 'i', content: 'x' })).toFailWith(
+        /edge target 'conversations\/conv-z\/turn-3' resolves to neither a sibling candidate nor an existing record/
+      );
     });
   });
 });
@@ -821,13 +992,22 @@ describe('MemoryIngestOrchestrator — contradicts→temporal interlock', () =>
       store,
       classifier: classifyFact,
       extractor: extractor(() => succeed([candidate(factKind, 'fact-1', 'the sky is grey')])),
-      relationExtractor: relater(() => succeed([candEdge('fact-1', 'contradicts', v1Id)]))
+      relationExtractor: relater((ctx) =>
+        succeed([
+          {
+            source: srcOf(ctx, 'fact-1'),
+            edge: { type: CONTRADICTS_LINK_TYPE, target: kt(v1Id, 'facts/entities/fact-1') }
+          }
+        ])
+      )
     });
     expect(await secondOrch.ingestItem({ id: 'fact-1', content: 'the sky is grey' })).toSucceedAndSatisfy(
       (r: IIngestItemResult) => {
         expect(r.records[0].interlock).toBe('temporal-versioned');
         expect(r.records[0].disposition).toBe('written');
-        expect(r.records[0].record?.envelope.links).toEqual([{ type: CONTRADICTS_LINK_TYPE, target: v1Id }]);
+        expect(r.records[0].record?.envelope.links).toEqual([
+          { type: CONTRADICTS_LINK_TYPE, target: kt(v1Id, 'facts/entities/fact-1') }
+        ]);
       }
     );
 
@@ -854,7 +1034,14 @@ describe('MemoryIngestOrchestrator — contradicts→temporal interlock', () =>
       store,
       classifier: classifyFact,
       extractor: extractor(() => succeed([candidate(factKind, 'fact-1', 'grey')])),
-      relationExtractor: relater(() => succeed([candEdge('fact-1', 'contradicts', v1Id)]))
+      relationExtractor: relater((ctx) =>
+        succeed([
+          {
+            source: srcOf(ctx, 'fact-1'),
+            edge: { type: CONTRADICTS_LINK_TYPE, target: kt(v1Id, 'facts/entities/fact-1') }
+          }
+        ])
+      )
     });
     (await o2.ingestItem({ id: 'fact-1', content: 'grey' })).orThrow();
 
@@ -1012,7 +1199,7 @@ describe('MemoryIngestOrchestrator — review-punch-list fixes', () => {
       )
     });
     expect(await orch.ingestItem({ id: 'i', content: 'x' })).toSucceedAndSatisfy((r: IIngestItemResult) => {
-      expect(r.records[0].record?.envelope.links).toEqual([{ type: 'rel', target: 'doc-a' }]);
+      expect(r.records[0].record?.envelope.links).toEqual([{ type: 'rel', target: kt('doc-a') }]);
     });
   });
 
@@ -1025,7 +1212,9 @@ describe('MemoryIngestOrchestrator — review-punch-list fixes', () => {
       store,
       vectorIndex,
       embed,
-      entityResolver: resolver((__c, similar) => succeed({ verdict: 'merge-into', target: similar[0].id })),
+      entityResolver: resolver((__c, similar) =>
+        succeed({ verdict: 'merge-into', target: similar[0].target })
+      ),
       extractor: extractor(() =>
         succeed([candidate(noteKind, 'doc-b', 'apple tart'), candidate(noteKind, 'doc-c', 'apple tart')])
       ),
@@ -1034,7 +1223,7 @@ describe('MemoryIngestOrchestrator — review-punch-list fixes', () => {
     expect(await orch.ingestItem({ id: 'i', content: 'x' })).toSucceed();
     expect(await store.get(noteKind, 'doc-a' as EntityId)).toSucceedAndSatisfy(
       (rec: IMemoryRecord<unknown> | undefined) => {
-        expect(rec?.envelope.links).toEqual([{ type: 'rel', target: 'doc-x' }]);
+        expect(rec?.envelope.links).toEqual([{ type: 'rel', target: kt('doc-x') }]);
       }
     );
   });
@@ -1072,19 +1261,21 @@ describe('MemoryIngestOrchestrator — merge-into safety (second review)', () =>
     const store = buildStore({ vectorIndex, embed });
     await putFull(store, noteKind, 'doc-a', 'apple pie', {
       tags: ['old-tag'],
-      links: [{ type: 'existing' as LinkType, target: 'doc-z' as MemoryId }]
+      links: [{ type: 'existing' as LinkType, target: kt('doc-z') }]
     });
     await putFull(store, noteKind, 'doc-x', 'target of stage-5');
     const orch = buildOrchestrator({
       store,
       vectorIndex,
       embed,
-      entityResolver: resolver((__c, similar) => succeed({ verdict: 'merge-into', target: similar[0].id })),
+      entityResolver: resolver((__c, similar) =>
+        succeed({ verdict: 'merge-into', target: similar[0].target })
+      ),
       extractor: extractor(() =>
         succeed([
           candidate(noteKind, 'doc-b', 'apple tart', {
             tags: ['new-tag'],
-            links: [{ type: 'candlink' as LinkType, target: 'doc-z' as MemoryId }]
+            links: [{ type: 'candlink' as LinkType, target: kt('doc-z') }]
           })
         ])
       ),
@@ -1099,9 +1290,9 @@ describe('MemoryIngestOrchestrator — merge-into safety (second review)', () =>
         expect([...(rec?.envelope.tags ?? [])].sort()).toEqual(['new-tag', 'old-tag']);
         // Original link + candidate link + stage-5 edge, each exactly once.
         expect(rec?.envelope.links).toEqual([
-          { type: 'existing', target: 'doc-z' },
-          { type: 'candlink', target: 'doc-z' },
-          { type: 'stage5', target: 'doc-x' }
+          { type: 'existing', target: kt('doc-z') },
+          { type: 'candlink', target: kt('doc-z') },
+          { type: 'stage5', target: kt('doc-x') }
         ]);
       }
     );
@@ -1116,11 +1307,13 @@ describe('MemoryIngestOrchestrator — merge-into safety (second review)', () =>
       store,
       vectorIndex,
       embed,
-      entityResolver: resolver((__c, similar) => succeed({ verdict: 'merge-into', target: similar[0].id })),
+      entityResolver: resolver((__c, similar) =>
+        succeed({ verdict: 'merge-into', target: similar[0].target })
+      ),
       extractor: extractor(() => succeed([candidate(noteKind, 'doc-b', 'apple tart')]))
     });
     expect(await orch.ingestItem({ id: 'i', content: 'x' })).toFailWith(
-      /merge-into target 'conv-1' is kind 'ltm' but the candidate is kind 'note'/
+      /merge-into target 'conversations\/conv-1' is kind 'ltm' but the candidate is kind 'note'/
     );
   });
 
@@ -1132,11 +1325,11 @@ describe('MemoryIngestOrchestrator — merge-into safety (second review)', () =>
       store,
       vectorIndex,
       embed,
-      entityResolver: resolver(() => succeed({ verdict: 'supersede', target: 'ghost' as MemoryId })),
+      entityResolver: resolver(() => succeed({ verdict: 'supersede', target: kt('ghost') })),
       extractor: extractor(() => succeed([candidate(noteKind, 'doc-b', 'apple tart')]))
     });
     expect(await orch.ingestItem({ id: 'i', content: 'x' })).toFailWith(
-      /supersede target 'ghost' does not exist/
+      /supersede target 'knowledge\/ghost' does not exist/
     );
   });
 
@@ -1148,11 +1341,11 @@ describe('MemoryIngestOrchestrator — merge-into safety (second review)', () =>
       store,
       vectorIndex,
       embed,
-      entityResolver: resolver(() => succeed({ verdict: 'duplicate-of', target: 'ghost' as MemoryId })),
+      entityResolver: resolver(() => succeed({ verdict: 'duplicate-of', target: kt('ghost') })),
       extractor: extractor(() => succeed([candidate(noteKind, 'doc-b', 'apple tart')]))
     });
     expect(await orch.ingestItem({ id: 'i', content: 'x' })).toFailWith(
-      /duplicate-of target 'ghost' does not exist/
+      /duplicate-of target 'knowledge\/ghost' does not exist/
     );
   });
 });