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

package/lib/packlets/vector/inMemoryCosineIndex.d.ts

@@ -1,5 +1,5 @@
 import { Result } from '@fgv/ts-utils';
-import { MemoryId } from '../types';
+import { IEdgeTarget } from '../types';
 import { IMemoryRecordSource, IVectorIndex, IVectorQueryHit, MemoryEmbedder } from './vectorIndex';
 /**
  * The brute-force, in-memory cosine {@link IVectorIndex}. Stores one
@@ -25,6 +25,11 @@ import { IMemoryRecordSource, IVectorIndex, IVectorQueryHit, MemoryEmbedder } fr
  * @public
  */
 export declare class InMemoryCosineIndex implements IVectorIndex {
+    /**
+     * Stored embeddings keyed by the canonical {@link edgeTargetKey} of the
+     * record's scope-qualified address, so two records that share a filename stem
+     * across scopes occupy distinct entries and never overwrite each other.
+     */
     private readonly _vectors;
     /** The dimension of every stored vector; `undefined` until the first `add`. */
     private _dimension;
@@ -34,9 +39,9 @@ export declare class InMemoryCosineIndex implements IVectorIndex {
     /** Family-convention factory. */
     static create(): Result<InMemoryCosineIndex>;
     /** {@inheritDoc IVectorIndex.add} */
-    add(id: MemoryId, vector: Float32Array): Promise<Result<string>>;
+    add(target: IEdgeTarget, vector: Float32Array): Promise<Result<string>>;
     /** {@inheritDoc IVectorIndex.remove} */
-    remove(id: MemoryId): Promise<Result<MemoryId>>;
+    remove(target: IEdgeTarget): Promise<Result<IEdgeTarget>>;
     /** {@inheritDoc IVectorIndex.query} */
     query(vector: Float32Array, topK: number): Promise<Result<ReadonlyArray<IVectorQueryHit>>>;
     /**
@@ -49,8 +54,7 @@ export declare class InMemoryCosineIndex implements IVectorIndex {
      * rather than left in a partially-rebuilt state — a caller that retries a query
      * after a failed rebuild sees a clean empty index, never a half-populated one.
      *
-     * @param source - The record source to re-embed (an {@link IMemoryStore}
-     * satisfies this structurally).
+     * @param source - The scope-qualified record source to re-embed.
      * @param embed - The embedder applied to each record.
      */
     rebuild(source: IMemoryRecordSource, embed: MemoryEmbedder): Promise<Result<number>>;

package/lib/packlets/vector/inMemoryCosineIndex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inMemoryCosineIndex.d.ts","sourceRoot":"","sources":["../../../src/packlets/vector/inMemoryCosineIndex.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,MAAM,EAAiB,MAAM,eAAe,CAAC;AACtD,OAAO,EAAiB,QAAQ,EAAE,MAAM,UAAU,CAAC;AACnD,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEnG;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,mBAAoB,YAAW,YAAY;IACtD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA8B;IACvD,+EAA+E;IAC/E,OAAO,CAAC,UAAU,CAAqB;IAEvC,OAAO;IAKP,4CAA4C;IAC5C,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,iCAAiC;WACnB,MAAM,IAAI,MAAM,CAAC,mBAAmB,CAAC;IAInD,qCAAqC;IAC9B,GAAG,CAAC,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAoBvE,wCAAwC;IACjC,MAAM,CAAC,EAAE,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAKtD,uCAAuC;IAChC,KAAK,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC,CAAC;IAsBjG;;;;;;;;;;;;;OAaG;IACU,OAAO,CAAC,MAAM,EAAE,mBAAmB,EAAE,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAwBjG,4DAA4D;IAC5D,OAAO,CAAC,MAAM;IAKd,qDAAqD;IACrD,OAAO,CAAC,MAAM,CAAC,UAAU;IAQzB;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,OAAO;CAWvB"}
+{"version":3,"file":"inMemoryCosineIndex.d.ts","sourceRoot":"","sources":["../../../src/packlets/vector/inMemoryCosineIndex.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,MAAM,EAAiB,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,WAAW,EAAiB,MAAM,UAAU,CAAC;AACtD,OAAO,EACL,mBAAmB,EAEnB,YAAY,EACZ,eAAe,EACf,cAAc,EACf,MAAM,eAAe,CAAC;AAQvB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,mBAAoB,YAAW,YAAY;IACtD;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA6B;IACtD,+EAA+E;IAC/E,OAAO,CAAC,UAAU,CAAqB;IAEvC,OAAO;IAKP,4CAA4C;IAC5C,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,iCAAiC;WACnB,MAAM,IAAI,MAAM,CAAC,mBAAmB,CAAC;IAInD,qCAAqC;IAC9B,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAsB9E,wCAAwC;IACjC,MAAM,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;IAKhE,uCAAuC;IAChC,KAAK,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC,CAAC;IAyBjG;;;;;;;;;;;;OAYG;IACU,OAAO,CAAC,MAAM,EAAE,mBAAmB,EAAE,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IA0BjG,4DAA4D;IAC5D,OAAO,CAAC,MAAM;IAKd,qDAAqD;IACrD,OAAO,CAAC,MAAM,CAAC,UAAU;IAQzB;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,OAAO;CAWvB"}

package/lib/packlets/vector/inMemoryCosineIndex.js

@@ -6,6 +6,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InMemoryCosineIndex = void 0;
 const ts_utils_1 = require("@fgv/ts-utils");
+const types_1 = require("../types");
 /**
  * The brute-force, in-memory cosine {@link IVectorIndex}. Stores one
  * `Float32Array` per record and answers a query by computing cosine similarity
@@ -43,26 +44,28 @@ class InMemoryCosineIndex {
         return (0, ts_utils_1.succeed)(new InMemoryCosineIndex());
     }
     /** {@inheritDoc IVectorIndex.add} */
-    add(id, vector) {
+    add(target, vector) {
+        const key = (0, types_1.edgeTargetKey)(target);
         if (vector.length === 0) {
-            return Promise.resolve((0, ts_utils_1.fail)(`vector index: cannot add '${id}': empty vector`));
+            return Promise.resolve((0, ts_utils_1.fail)(`vector index: cannot add '${key}': empty vector`));
         }
         if (this._dimension === undefined) {
             this._dimension = vector.length;
         }
         else if (vector.length !== this._dimension) {
-            return Promise.resolve((0, ts_utils_1.fail)(`vector index: cannot add '${id}': dimension ${vector.length} does not match index dimension ${this._dimension}`));
+            return Promise.resolve((0, ts_utils_1.fail)(`vector index: cannot add '${key}': dimension ${vector.length} does not match index dimension ${this._dimension}`));
         }
         // Defensive copy: the caller may reuse or mutate the buffer after `add`, and
         // the index must keep serving the embedding it was given.
-        this._vectors.set(id, Float32Array.from(vector));
-        // The in-memory index keys entries by id, so the id IS the entry reference.
-        return Promise.resolve((0, ts_utils_1.succeed)(id));
+        this._vectors.set(key, { target, vector: Float32Array.from(vector) });
+        // The in-memory index keys entries by the canonical scoped-target string, so
+        // that key IS the entry reference.
+        return Promise.resolve((0, ts_utils_1.succeed)(key));
     }
     /** {@inheritDoc IVectorIndex.remove} */
-    remove(id) {
-        this._vectors.delete(id);
-        return Promise.resolve((0, ts_utils_1.succeed)(id));
+    remove(target) {
+        this._vectors.delete((0, types_1.edgeTargetKey)(target));
+        return Promise.resolve((0, ts_utils_1.succeed)(target));
     }
     /** {@inheritDoc IVectorIndex.query} */
     query(vector, topK) {
@@ -74,8 +77,11 @@ class InMemoryCosineIndex {
         }
         const queryMagnitude = InMemoryCosineIndex._magnitude(vector);
         const hits = [];
-        for (const [id, stored] of this._vectors) {
-            hits.push({ id, score: InMemoryCosineIndex._cosine(vector, queryMagnitude, stored) });
+        for (const stored of this._vectors.values()) {
+            hits.push({
+                target: stored.target,
+                score: InMemoryCosineIndex._cosine(vector, queryMagnitude, stored.vector)
+            });
         }
         // Descending by score; a `seq`-free tiebreak is unnecessary here because the
         // caller (SemanticRetriever) re-resolves hits against the record index.
@@ -92,8 +98,7 @@ class InMemoryCosineIndex {
      * rather than left in a partially-rebuilt state — a caller that retries a query
      * after a failed rebuild sees a clean empty index, never a half-populated one.
      *
-     * @param source - The record source to re-embed (an {@link IMemoryStore}
-     * satisfies this structurally).
+     * @param source - The scope-qualified record source to re-embed.
      * @param embed - The embedder applied to each record.
      */
     async rebuild(source, embed) {
@@ -105,13 +110,13 @@ class InMemoryCosineIndex {
         if (listed.isFailure()) {
             return (0, ts_utils_1.fail)(`vector index rebuild: failed to list records: ${listed.message}`);
         }
-        for (const record of listed.value) {
-            const embedded = await embed(record);
+        for (const scoped of listed.value) {
+            const embedded = await embed(scoped.record);
             if (embedded.isFailure()) {
                 this._reset();
-                return (0, ts_utils_1.fail)(`vector index rebuild: embedding '${record.envelope.id}' failed: ${embedded.message}`);
+                return (0, ts_utils_1.fail)(`vector index rebuild: embedding '${(0, types_1.edgeTargetKey)(scoped.target)}' failed: ${embedded.message}`);
             }
-            const added = await this.add(record.envelope.id, embedded.value);
+            const added = await this.add(scoped.target, embedded.value);
             if (added.isFailure()) {
                 this._reset();
                 return (0, ts_utils_1.fail)(`vector index rebuild: ${added.message}`);

package/lib/packlets/vector/inMemoryCosineIndex.js.map

@@ -1 +1 @@
-{"version":3,"file":"inMemoryCosineIndex.js","sourceRoot":"","sources":["../../../src/packlets/vector/inMemoryCosineIndex.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,4CAAsD;AAItD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAa,mBAAmB;IAK9B;QACE,IAAI,CAAC,QAAQ,GAAG,IAAI,GAAG,EAA0B,CAAC;QAClD,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;IAC9B,CAAC;IAED,4CAA4C;IAC5C,IAAW,IAAI;QACb,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;IAC5B,CAAC;IAED,iCAAiC;IAC1B,MAAM,CAAC,MAAM;QAClB,OAAO,IAAA,kBAAO,EAAC,IAAI,mBAAmB,EAAE,CAAC,CAAC;IAC5C,CAAC;IAED,qCAAqC;IAC9B,GAAG,CAAC,EAAY,EAAE,MAAoB;QAC3C,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACxB,OAAO,OAAO,CAAC,OAAO,CAAC,IAAA,eAAI,EAAC,6BAA6B,EAAE,iBAAiB,CAAC,CAAC,CAAC;QACjF,CAAC;QACD,IAAI,IAAI,CAAC,UAAU,KAAK,SAAS,EAAE,CAAC;YAClC,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC;QAClC,CAAC;aAAM,IAAI,MAAM,CAAC,MAAM,KAAK,IAAI,CAAC,UAAU,EAAE,CAAC;YAC7C,OAAO,OAAO,CAAC,OAAO,CACpB,IAAA,eAAI,EACF,6BAA6B,EAAE,gBAAgB,MAAM,CAAC,MAAM,mCAAmC,IAAI,CAAC,UAAU,EAAE,CACjH,CACF,CAAC;QACJ,CAAC;QACD,6EAA6E;QAC7E,0DAA0D;QAC1D,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,EAAE,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;QACjD,4EAA4E;QAC5E,OAAO,OAAO,CAAC,OAAO,CAAC,IAAA,kBAAO,EAAC,EAAY,CAAC,CAAC,CAAC;IAChD,CAAC;IAED,wCAAwC;IACjC,MAAM,CAAC,EAAY;QACxB,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QACzB,OAAO,OAAO,CAAC,OAAO,CAAC,IAAA,kBAAO,EAAC,EAAE,CAAC,CAAC,CAAC;IACtC,CAAC;IAED,uCAAuC;IAChC,KAAK,CAAC,MAAoB,EAAE,IAAY;QAC7C,IAAI,IAAI,IAAI,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC;YAC1C,OAAO,OAAO,CAAC,OAAO,CAAC,IAAA,kBAAO,EAAC,EAAE,CAAC,CAAC,CAAC;QACtC,CAAC;QACD,IAAI,MAAM,CAAC,MAAM,KAAK,IAAI,CAAC,UAAU,EAAE,CAAC;YACtC,OAAO,OAAO,CAAC,OAAO,CACpB,IAAA,eAAI,EACF,iCAAiC,MAAM,CAAC,MAAM,mCAAmC,IAAI,CAAC,UAAU,EAAE,CACnG,CACF,CAAC;QACJ,CAAC;QACD,MAAM,cAAc,GAAW,mBAAmB,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QACtE,MAAM,IAAI,GAAsB,EAAE,CAAC;QACnC,KAAK,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YACzC,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,mBAAmB,CAAC,OAAO,CAAC,MAAM,EAAE,cAAc,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;QACxF,CAAC;QACD,6EAA6E;QAC7E,wEAAwE;QACxE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC;QACvC,OAAO,OAAO,CAAC,OAAO,CAAC,IAAA,kBAAO,EAAC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;IACnF,CAAC;IAED;;;;;;;;;;;;;OAaG;IACI,KAAK,CAAC,OAAO,CAAC,MAA2B,EAAE,KAAqB;QACrE,4EAA4E;QAC5E,wEAAwE;QACxE,YAAY;QACZ,IAAI,CAAC,MAAM,EAAE,CAAC;QACd,MAAM,MAAM,GAAkD,MAAM,MAAM,CAAC,IAAI,EAAE,CAAC;QAClF,IAAI,MAAM,CAAC,SAAS,EAAE,EAAE,CAAC;YACvB,OAAO,IAAA,eAAI,EAAC,iDAAiD,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC;QACjF,CAAC;QACD,KAAK,MAAM,MAAM,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;YAClC,MAAM,QAAQ,GAAyB,MAAM,KAAK,CAAC,MAAM,CAAC,CAAC;YAC3D,IAAI,QAAQ,CAAC,SAAS,EAAE,EAAE,CAAC;gBACzB,IAAI,CAAC,MAAM,EAAE,CAAC;gBACd,OAAO,IAAA,eAAI,EAAC,oCAAoC,MAAM,CAAC,QAAQ,CAAC,EAAE,aAAa,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;YACrG,CAAC;YACD,MAAM,KAAK,GAAmB,MAAM,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC;YACjF,IAAI,KAAK,CAAC,SAAS,EAAE,EAAE,CAAC;gBACtB,IAAI,CAAC,MAAM,EAAE,CAAC;gBACd,OAAO,IAAA,eAAI,EAAC,yBAAyB,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YACxD,CAAC;QACH,CAAC;QACD,OAAO,IAAA,kBAAO,EAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IACrC,CAAC;IAED,4DAA4D;IACpD,MAAM;QACZ,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;QACtB,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;IAC9B,CAAC;IAED,qDAAqD;IAC7C,MAAM,CAAC,UAAU,CAAC,MAAoB;QAC5C,IAAI,GAAG,GAAW,CAAC,CAAC;QACpB,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC/C,GAAG,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QAC/B,CAAC;QACD,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACxB,CAAC;IAED;;;;;OAKG;IACK,MAAM,CAAC,OAAO,CAAC,KAAmB,EAAE,cAAsB,EAAE,MAAoB;QACtF,MAAM,eAAe,GAAW,mBAAmB,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QACvE,IAAI,cAAc,KAAK,CAAC,IAAI,eAAe,KAAK,CAAC,EAAE,CAAC;YAClD,OAAO,CAAC,CAAC;QACX,CAAC;QACD,IAAI,GAAG,GAAW,CAAC,CAAC;QACpB,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC9C,GAAG,IAAI,KAAK,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QAC9B,CAAC;QACD,OAAO,GAAG,GAAG,CAAC,cAAc,GAAG,eAAe,CAAC,CAAC;IAClD,CAAC;CACF;AA5ID,kDA4IC","sourcesContent":["/*\n * Copyright (c) 2026 Erik Fortune\n * SPDX-License-Identifier: MIT\n */\n\nimport { Result, fail, succeed } from '@fgv/ts-utils';\nimport { IMemoryRecord, MemoryId } from '../types';\nimport { IMemoryRecordSource, IVectorIndex, IVectorQueryHit, MemoryEmbedder } from './vectorIndex';\n\n/**\n * The brute-force, in-memory cosine {@link IVectorIndex}. Stores one\n * `Float32Array` per record and answers a query by computing cosine similarity\n * against every stored vector, returning the top-k by descending score.\n *\n * @remarks\n * This is the **complete** vector implementation for the fgv regime — large-N is\n * explicitly out of scope (the seam stays open for a consumer to swap an external\n * ANN backend once N grows beyond \"thousands of records\"). No external dependency\n * and no ANN structure: a linear scan over a few thousand vectors is well within\n * an interactive budget.\n *\n * The index has a single dimension established by the first vector added; every\n * subsequent `add` and every `query` vector must match that dimension or fail\n * loudly — a mismatched dimension is an embedder-wiring bug, never a silent\n * zero-similarity result. {@link InMemoryCosineIndex.rebuild | rebuild} clears\n * the index, so a re-embed with a different model (hence dimension) is supported.\n *\n * Persistence (a JSON sidecar) is deliberately out of scope for this layer — the\n * index is in-memory and rebuilt from the store via `rebuild`; a sidecar is a\n * future nicety.\n * @public\n */\nexport class InMemoryCosineIndex implements IVectorIndex {\n  private readonly _vectors: Map<MemoryId, Float32Array>;\n  /** The dimension of every stored vector; `undefined` until the first `add`. */\n  private _dimension: number | undefined;\n\n  private constructor() {\n    this._vectors = new Map<MemoryId, Float32Array>();\n    this._dimension = undefined;\n  }\n\n  /** The number of vectors currently held. */\n  public get size(): number {\n    return this._vectors.size;\n  }\n\n  /** Family-convention factory. */\n  public static create(): Result<InMemoryCosineIndex> {\n    return succeed(new InMemoryCosineIndex());\n  }\n\n  /** {@inheritDoc IVectorIndex.add} */\n  public add(id: MemoryId, vector: Float32Array): Promise<Result<string>> {\n    if (vector.length === 0) {\n      return Promise.resolve(fail(`vector index: cannot add '${id}': empty vector`));\n    }\n    if (this._dimension === undefined) {\n      this._dimension = vector.length;\n    } else if (vector.length !== this._dimension) {\n      return Promise.resolve(\n        fail(\n          `vector index: cannot add '${id}': dimension ${vector.length} does not match index dimension ${this._dimension}`\n        )\n      );\n    }\n    // Defensive copy: the caller may reuse or mutate the buffer after `add`, and\n    // the index must keep serving the embedding it was given.\n    this._vectors.set(id, Float32Array.from(vector));\n    // The in-memory index keys entries by id, so the id IS the entry reference.\n    return Promise.resolve(succeed(id as string));\n  }\n\n  /** {@inheritDoc IVectorIndex.remove} */\n  public remove(id: MemoryId): Promise<Result<MemoryId>> {\n    this._vectors.delete(id);\n    return Promise.resolve(succeed(id));\n  }\n\n  /** {@inheritDoc IVectorIndex.query} */\n  public query(vector: Float32Array, topK: number): Promise<Result<ReadonlyArray<IVectorQueryHit>>> {\n    if (topK <= 0 || this._vectors.size === 0) {\n      return Promise.resolve(succeed([]));\n    }\n    if (vector.length !== this._dimension) {\n      return Promise.resolve(\n        fail(\n          `vector index: query dimension ${vector.length} does not match index dimension ${this._dimension}`\n        )\n      );\n    }\n    const queryMagnitude: number = InMemoryCosineIndex._magnitude(vector);\n    const hits: IVectorQueryHit[] = [];\n    for (const [id, stored] of this._vectors) {\n      hits.push({ id, score: InMemoryCosineIndex._cosine(vector, queryMagnitude, stored) });\n    }\n    // Descending by score; a `seq`-free tiebreak is unnecessary here because the\n    // caller (SemanticRetriever) re-resolves hits against the record index.\n    hits.sort((a, b) => b.score - a.score);\n    return Promise.resolve(succeed(hits.length > topK ? hits.slice(0, topK) : hits));\n  }\n\n  /**\n   * Re-embed every record from `source` and rebuild the index from scratch.\n   * Clears the current contents (and the established dimension) first, so a\n   * re-embed with a different model is supported. Returns the number of vectors\n   * indexed.\n   *\n   * On any failure (list, embed, or add) the index is rolled back to empty\n   * rather than left in a partially-rebuilt state — a caller that retries a query\n   * after a failed rebuild sees a clean empty index, never a half-populated one.\n   *\n   * @param source - The record source to re-embed (an {@link IMemoryStore}\n   * satisfies this structurally).\n   * @param embed - The embedder applied to each record.\n   */\n  public async rebuild(source: IMemoryRecordSource, embed: MemoryEmbedder): Promise<Result<number>> {\n    // Reset up front so the \"any failure leaves the index empty\" contract holds\n    // even when the listing itself fails (no stale vectors survive a failed\n    // rebuild).\n    this._reset();\n    const listed: Result<ReadonlyArray<IMemoryRecord<unknown>>> = await source.list();\n    if (listed.isFailure()) {\n      return fail(`vector index rebuild: failed to list records: ${listed.message}`);\n    }\n    for (const record of listed.value) {\n      const embedded: Result<Float32Array> = await embed(record);\n      if (embedded.isFailure()) {\n        this._reset();\n        return fail(`vector index rebuild: embedding '${record.envelope.id}' failed: ${embedded.message}`);\n      }\n      const added: Result<string> = await this.add(record.envelope.id, embedded.value);\n      if (added.isFailure()) {\n        this._reset();\n        return fail(`vector index rebuild: ${added.message}`);\n      }\n    }\n    return succeed(this._vectors.size);\n  }\n\n  /** Empty the index and forget the established dimension. */\n  private _reset(): void {\n    this._vectors.clear();\n    this._dimension = undefined;\n  }\n\n  /** The Euclidean magnitude (L2 norm) of a vector. */\n  private static _magnitude(vector: Float32Array): number {\n    let sum: number = 0;\n    for (let i: number = 0; i < vector.length; i++) {\n      sum += vector[i] * vector[i];\n    }\n    return Math.sqrt(sum);\n  }\n\n  /**\n   * Cosine similarity between the query (whose magnitude is precomputed once and\n   * reused across the scan) and a stored vector. A zero-magnitude vector on\n   * either side yields `0` rather than `NaN` — a degenerate vector is simply\n   * maximally dissimilar, not an error.\n   */\n  private static _cosine(query: Float32Array, queryMagnitude: number, stored: Float32Array): number {\n    const storedMagnitude: number = InMemoryCosineIndex._magnitude(stored);\n    if (queryMagnitude === 0 || storedMagnitude === 0) {\n      return 0;\n    }\n    let dot: number = 0;\n    for (let i: number = 0; i < query.length; i++) {\n      dot += query[i] * stored[i];\n    }\n    return dot / (queryMagnitude * storedMagnitude);\n  }\n}\n"]}
+{"version":3,"file":"inMemoryCosineIndex.js","sourceRoot":"","sources":["../../../src/packlets/vector/inMemoryCosineIndex.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2026 Erik Fortune\n * SPDX-License-Identifier: MIT\n */\n\nimport { Result, fail, succeed } from '@fgv/ts-utils';\nimport { IEdgeTarget, edgeTargetKey } from '../types';\nimport {\n  IMemoryRecordSource,\n  IScopedMemoryRecord,\n  IVectorIndex,\n  IVectorQueryHit,\n  MemoryEmbedder\n} from './vectorIndex';\n\n/** One stored embedding: the scope-qualified address plus its vector. */\ninterface IStoredVector {\n  readonly target: IEdgeTarget;\n  readonly vector: Float32Array;\n}\n\n/**\n * The brute-force, in-memory cosine {@link IVectorIndex}. Stores one\n * `Float32Array` per record and answers a query by computing cosine similarity\n * against every stored vector, returning the top-k by descending score.\n *\n * @remarks\n * This is the **complete** vector implementation for the fgv regime — large-N is\n * explicitly out of scope (the seam stays open for a consumer to swap an external\n * ANN backend once N grows beyond \"thousands of records\"). No external dependency\n * and no ANN structure: a linear scan over a few thousand vectors is well within\n * an interactive budget.\n *\n * The index has a single dimension established by the first vector added; every\n * subsequent `add` and every `query` vector must match that dimension or fail\n * loudly — a mismatched dimension is an embedder-wiring bug, never a silent\n * zero-similarity result. {@link InMemoryCosineIndex.rebuild | rebuild} clears\n * the index, so a re-embed with a different model (hence dimension) is supported.\n *\n * Persistence (a JSON sidecar) is deliberately out of scope for this layer — the\n * index is in-memory and rebuilt from the store via `rebuild`; a sidecar is a\n * future nicety.\n * @public\n */\nexport class InMemoryCosineIndex implements IVectorIndex {\n  /**\n   * Stored embeddings keyed by the canonical {@link edgeTargetKey} of the\n   * record's scope-qualified address, so two records that share a filename stem\n   * across scopes occupy distinct entries and never overwrite each other.\n   */\n  private readonly _vectors: Map<string, IStoredVector>;\n  /** The dimension of every stored vector; `undefined` until the first `add`. */\n  private _dimension: number | undefined;\n\n  private constructor() {\n    this._vectors = new Map<string, IStoredVector>();\n    this._dimension = undefined;\n  }\n\n  /** The number of vectors currently held. */\n  public get size(): number {\n    return this._vectors.size;\n  }\n\n  /** Family-convention factory. */\n  public static create(): Result<InMemoryCosineIndex> {\n    return succeed(new InMemoryCosineIndex());\n  }\n\n  /** {@inheritDoc IVectorIndex.add} */\n  public add(target: IEdgeTarget, vector: Float32Array): Promise<Result<string>> {\n    const key: string = edgeTargetKey(target);\n    if (vector.length === 0) {\n      return Promise.resolve(fail(`vector index: cannot add '${key}': empty vector`));\n    }\n    if (this._dimension === undefined) {\n      this._dimension = vector.length;\n    } else if (vector.length !== this._dimension) {\n      return Promise.resolve(\n        fail(\n          `vector index: cannot add '${key}': dimension ${vector.length} does not match index dimension ${this._dimension}`\n        )\n      );\n    }\n    // Defensive copy: the caller may reuse or mutate the buffer after `add`, and\n    // the index must keep serving the embedding it was given.\n    this._vectors.set(key, { target, vector: Float32Array.from(vector) });\n    // The in-memory index keys entries by the canonical scoped-target string, so\n    // that key IS the entry reference.\n    return Promise.resolve(succeed(key));\n  }\n\n  /** {@inheritDoc IVectorIndex.remove} */\n  public remove(target: IEdgeTarget): Promise<Result<IEdgeTarget>> {\n    this._vectors.delete(edgeTargetKey(target));\n    return Promise.resolve(succeed(target));\n  }\n\n  /** {@inheritDoc IVectorIndex.query} */\n  public query(vector: Float32Array, topK: number): Promise<Result<ReadonlyArray<IVectorQueryHit>>> {\n    if (topK <= 0 || this._vectors.size === 0) {\n      return Promise.resolve(succeed([]));\n    }\n    if (vector.length !== this._dimension) {\n      return Promise.resolve(\n        fail(\n          `vector index: query dimension ${vector.length} does not match index dimension ${this._dimension}`\n        )\n      );\n    }\n    const queryMagnitude: number = InMemoryCosineIndex._magnitude(vector);\n    const hits: IVectorQueryHit[] = [];\n    for (const stored of this._vectors.values()) {\n      hits.push({\n        target: stored.target,\n        score: InMemoryCosineIndex._cosine(vector, queryMagnitude, stored.vector)\n      });\n    }\n    // Descending by score; a `seq`-free tiebreak is unnecessary here because the\n    // caller (SemanticRetriever) re-resolves hits against the record index.\n    hits.sort((a, b) => b.score - a.score);\n    return Promise.resolve(succeed(hits.length > topK ? hits.slice(0, topK) : hits));\n  }\n\n  /**\n   * Re-embed every record from `source` and rebuild the index from scratch.\n   * Clears the current contents (and the established dimension) first, so a\n   * re-embed with a different model is supported. Returns the number of vectors\n   * indexed.\n   *\n   * On any failure (list, embed, or add) the index is rolled back to empty\n   * rather than left in a partially-rebuilt state — a caller that retries a query\n   * after a failed rebuild sees a clean empty index, never a half-populated one.\n   *\n   * @param source - The scope-qualified record source to re-embed.\n   * @param embed - The embedder applied to each record.\n   */\n  public async rebuild(source: IMemoryRecordSource, embed: MemoryEmbedder): Promise<Result<number>> {\n    // Reset up front so the \"any failure leaves the index empty\" contract holds\n    // even when the listing itself fails (no stale vectors survive a failed\n    // rebuild).\n    this._reset();\n    const listed: Result<ReadonlyArray<IScopedMemoryRecord>> = await source.list();\n    if (listed.isFailure()) {\n      return fail(`vector index rebuild: failed to list records: ${listed.message}`);\n    }\n    for (const scoped of listed.value) {\n      const embedded: Result<Float32Array> = await embed(scoped.record);\n      if (embedded.isFailure()) {\n        this._reset();\n        return fail(\n          `vector index rebuild: embedding '${edgeTargetKey(scoped.target)}' failed: ${embedded.message}`\n        );\n      }\n      const added: Result<string> = await this.add(scoped.target, embedded.value);\n      if (added.isFailure()) {\n        this._reset();\n        return fail(`vector index rebuild: ${added.message}`);\n      }\n    }\n    return succeed(this._vectors.size);\n  }\n\n  /** Empty the index and forget the established dimension. */\n  private _reset(): void {\n    this._vectors.clear();\n    this._dimension = undefined;\n  }\n\n  /** The Euclidean magnitude (L2 norm) of a vector. */\n  private static _magnitude(vector: Float32Array): number {\n    let sum: number = 0;\n    for (let i: number = 0; i < vector.length; i++) {\n      sum += vector[i] * vector[i];\n    }\n    return Math.sqrt(sum);\n  }\n\n  /**\n   * Cosine similarity between the query (whose magnitude is precomputed once and\n   * reused across the scan) and a stored vector. A zero-magnitude vector on\n   * either side yields `0` rather than `NaN` — a degenerate vector is simply\n   * maximally dissimilar, not an error.\n   */\n  private static _cosine(query: Float32Array, queryMagnitude: number, stored: Float32Array): number {\n    const storedMagnitude: number = InMemoryCosineIndex._magnitude(stored);\n    if (queryMagnitude === 0 || storedMagnitude === 0) {\n      return 0;\n    }\n    let dot: number = 0;\n    for (let i: number = 0; i < query.length; i++) {\n      dot += query[i] * stored[i];\n    }\n    return dot / (queryMagnitude * storedMagnitude);\n  }\n}\n"]}

package/lib/packlets/vector/vectorIndex.d.ts

@@ -1,14 +1,22 @@
 import { Result } from '@fgv/ts-utils';
-import { IMemoryRecord, MemoryId } from '../types';
+import { IEdgeTarget, IMemoryRecord } from '../types';
 /**
- * A single hit returned by {@link IVectorIndex.query}: the matched record id and
- * the backend's similarity score (higher = more similar; the exact scale is
- * backend-defined). Hits are returned in descending score order.
+ * A single hit returned by {@link IVectorIndex.query}: the matched record's
+ * scope-qualified {@link IEdgeTarget | address} and the backend's similarity
+ * score (higher = more similar; the exact scale is backend-defined). Hits are
+ * returned in descending score order.
+ *
+ * @remarks
+ * The address is a `(scope, id)` pair, NOT a bare {@link MemoryId} — per-scope
+ * codecs (e.g. the medium-term codec's `turn-<n>` stems) legally mint the same
+ * stem under different scopes, so a bare id could not disambiguate two records
+ * that share a stem. The caller re-resolves the hit against the record index by
+ * the same scoped address.
  * @public
  */
 export interface IVectorQueryHit {
-    /** The id of the matched record. */
-    readonly id: MemoryId;
+    /** The scope-qualified address of the matched record. */
+    readonly target: IEdgeTarget;
     /** Backend similarity score; higher is more similar. */
     readonly score: number;
 }
@@ -29,16 +37,19 @@ export interface IVectorQueryHit {
  */
 export interface IVectorIndex {
     /**
-     * Add (or replace) the embedding for `id`. Returns the opaque
-     * {@link IMemoryEnvelope.embeddingRef | embeddingRef} the store stamps onto
-     * the envelope so a later read knows the record is embedded.
+     * Add (or replace) the embedding for the scope-qualified `target`. Returns the
+     * opaque {@link IMemoryEnvelope.embeddingRef | embeddingRef} the store stamps
+     * onto the envelope so a later read knows the record is embedded. Keying on the
+     * `(scope, id)` address (not a bare id) is load-bearing: two records that share
+     * a filename stem across scopes must not clobber each other's embedding.
      */
-    add(id: MemoryId, vector: Float32Array): Promise<Result<string>>;
+    add(target: IEdgeTarget, vector: Float32Array): Promise<Result<string>>;
     /**
-     * Remove the embedding for `id`. Returns the removed id. Idempotent — removing
-     * an id with no embedding still succeeds (returns the id).
+     * Remove the embedding for the scope-qualified `target`. Returns the removed
+     * target. Idempotent — removing a target with no embedding still succeeds
+     * (returns the target).
      */
-    remove(id: MemoryId): Promise<Result<MemoryId>>;
+    remove(target: IEdgeTarget): Promise<Result<IEdgeTarget>>;
     /**
      * Return the `topK` nearest records to `vector`, in descending score order.
      */
@@ -52,17 +63,32 @@ export interface IVectorIndex {
  * @public
  */
 export type MemoryEmbedder = (record: IMemoryRecord<unknown>) => Promise<Result<Float32Array>>;
+/**
+ * A record paired with its scope-qualified {@link IEdgeTarget | address}, as
+ * yielded by {@link IMemoryRecordSource.list}. The address is required because
+ * {@link InMemoryCosineIndex.rebuild} keys each re-embedded entry on the
+ * scope-qualified target, not a bare {@link MemoryId} — two records that share a
+ * filename stem across scopes must not collide when the whole vault is re-indexed.
+ * @public
+ */
+export interface IScopedMemoryRecord {
+    /** The record's scope-qualified `(scope, id)` address. */
+    readonly target: IEdgeTarget;
+    /** The record itself, passed to the embedder. */
+    readonly record: IMemoryRecord<unknown>;
+}
 /**
  * The minimal record-source surface {@link InMemoryCosineIndex.rebuild} reads to
- * re-embed an entire vault. {@link IMemoryStore} satisfies it structurally (its
- * `list` accepts an optional filter, which is assignable to this no-argument
- * shape), so a consumer passes the store directly — without the vector packlet
- * taking a dependency on the store packlet (which depends on the vector packlet
- * for {@link IVectorIndex}, so the reverse import would be a cycle).
+ * re-embed an entire vault. Each entry carries the record's scope-qualified
+ * address (see {@link IScopedMemoryRecord}) so the rebuild keys the vector index
+ * exactly as the incremental embed-on-write path does. A consumer backs this with
+ * the store's scoped index — the vector packlet does not import the store packlet
+ * (which depends on the vector packlet for {@link IVectorIndex}, so the reverse
+ * import would be a cycle).
  * @public
  */
 export interface IMemoryRecordSource {
-    /** List every record in the vault. */
-    list(): Promise<Result<ReadonlyArray<IMemoryRecord<unknown>>>>;
+    /** List every record in the vault, each paired with its scoped address. */
+    list(): Promise<Result<ReadonlyArray<IScopedMemoryRecord>>>;
 }
 //# sourceMappingURL=vectorIndex.d.ts.map

package/lib/packlets/vector/vectorIndex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vectorIndex.d.ts","sourceRoot":"","sources":["../../../src/packlets/vector/vectorIndex.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEnD;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,oCAAoC;IACpC,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC;IACtB,wDAAwD;IACxD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,GAAG,CAAC,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;IAEjE;;;OAGG;IACH,MAAM,CAAC,EAAE,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;IAEhD;;OAEG;IACH,KAAK,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;CAC5F;AAED;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC;AAE/F;;;;;;;;GAQG;AACH,MAAM,WAAW,mBAAmB;IAClC,sCAAsC;IACtC,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;CAChE"}
+{"version":3,"file":"vectorIndex.d.ts","sourceRoot":"","sources":["../../../src/packlets/vector/vectorIndex.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEtD;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,eAAe;IAC9B,yDAAyD;IACzD,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,wDAAwD;IACxD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;;;OAMG;IACH,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;IAExE;;;;OAIG;IACH,MAAM,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC;IAE1D;;OAEG;IACH,KAAK,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;CAC5F;AAED;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC;AAE/F;;;;;;;GAOG;AACH,MAAM,WAAW,mBAAmB;IAClC,0DAA0D;IAC1D,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,iDAAiD;IACjD,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;CACzC;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,mBAAmB;IAClC,2EAA2E;IAC3E,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC;CAC7D"}

package/lib/packlets/vector/vectorIndex.js.map

@@ -1 +1 @@
-{"version":3,"file":"vectorIndex.js","sourceRoot":"","sources":["../../../src/packlets/vector/vectorIndex.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*\n * Copyright (c) 2026 Erik Fortune\n * SPDX-License-Identifier: MIT\n */\n\nimport { Result } from '@fgv/ts-utils';\nimport { IMemoryRecord, MemoryId } from '../types';\n\n/**\n * A single hit returned by {@link IVectorIndex.query}: the matched record id and\n * the backend's similarity score (higher = more similar; the exact scale is\n * backend-defined). Hits are returned in descending score order.\n * @public\n */\nexport interface IVectorQueryHit {\n  /** The id of the matched record. */\n  readonly id: MemoryId;\n  /** Backend similarity score; higher is more similar. */\n  readonly score: number;\n}\n\n/**\n * The vector-index seam an embedding backend implements to make\n * {@link SemanticRetriever | semantic recall} operational.\n *\n * @remarks\n * Vectors cross this seam as `Float32Array` (the in-memory representation an\n * embedding model produces); `number[]` is reserved for the JSON-wire edges\n * (e.g. a provider's embedding response). The in-package brute-force cosine\n * implementation is {@link InMemoryCosineIndex}; a consumer can swap an external\n * ANN backend behind the same seam once N grows beyond the in-memory regime.\n *\n * Every operation returns a `Result` (async, since a real backend does I/O) so\n * failure is explicit and never throws across the seam.\n * @public\n */\nexport interface IVectorIndex {\n  /**\n   * Add (or replace) the embedding for `id`. Returns the opaque\n   * {@link IMemoryEnvelope.embeddingRef | embeddingRef} the store stamps onto\n   * the envelope so a later read knows the record is embedded.\n   */\n  add(id: MemoryId, vector: Float32Array): Promise<Result<string>>;\n\n  /**\n   * Remove the embedding for `id`. Returns the removed id. Idempotent — removing\n   * an id with no embedding still succeeds (returns the id).\n   */\n  remove(id: MemoryId): Promise<Result<MemoryId>>;\n\n  /**\n   * Return the `topK` nearest records to `vector`, in descending score order.\n   */\n  query(vector: Float32Array, topK: number): Promise<Result<ReadonlyArray<IVectorQueryHit>>>;\n}\n\n/**\n * Embeds a complete record into a vector for the store's embed-on-write hook.\n * Async and `Result`-returning, since a real embedder does a network call (cloud\n * provider) or in-process model inference. The consumer wires this — the core\n * package never calls an embedding provider directly, staying embedder-agnostic.\n * @public\n */\nexport type MemoryEmbedder = (record: IMemoryRecord<unknown>) => Promise<Result<Float32Array>>;\n\n/**\n * The minimal record-source surface {@link InMemoryCosineIndex.rebuild} reads to\n * re-embed an entire vault. {@link IMemoryStore} satisfies it structurally (its\n * `list` accepts an optional filter, which is assignable to this no-argument\n * shape), so a consumer passes the store directly — without the vector packlet\n * taking a dependency on the store packlet (which depends on the vector packlet\n * for {@link IVectorIndex}, so the reverse import would be a cycle).\n * @public\n */\nexport interface IMemoryRecordSource {\n  /** List every record in the vault. */\n  list(): Promise<Result<ReadonlyArray<IMemoryRecord<unknown>>>>;\n}\n"]}
+{"version":3,"file":"vectorIndex.js","sourceRoot":"","sources":["../../../src/packlets/vector/vectorIndex.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*\n * Copyright (c) 2026 Erik Fortune\n * SPDX-License-Identifier: MIT\n */\n\nimport { Result } from '@fgv/ts-utils';\nimport { IEdgeTarget, IMemoryRecord } from '../types';\n\n/**\n * A single hit returned by {@link IVectorIndex.query}: the matched record's\n * scope-qualified {@link IEdgeTarget | address} and the backend's similarity\n * score (higher = more similar; the exact scale is backend-defined). Hits are\n * returned in descending score order.\n *\n * @remarks\n * The address is a `(scope, id)` pair, NOT a bare {@link MemoryId} — per-scope\n * codecs (e.g. the medium-term codec's `turn-<n>` stems) legally mint the same\n * stem under different scopes, so a bare id could not disambiguate two records\n * that share a stem. The caller re-resolves the hit against the record index by\n * the same scoped address.\n * @public\n */\nexport interface IVectorQueryHit {\n  /** The scope-qualified address of the matched record. */\n  readonly target: IEdgeTarget;\n  /** Backend similarity score; higher is more similar. */\n  readonly score: number;\n}\n\n/**\n * The vector-index seam an embedding backend implements to make\n * {@link SemanticRetriever | semantic recall} operational.\n *\n * @remarks\n * Vectors cross this seam as `Float32Array` (the in-memory representation an\n * embedding model produces); `number[]` is reserved for the JSON-wire edges\n * (e.g. a provider's embedding response). The in-package brute-force cosine\n * implementation is {@link InMemoryCosineIndex}; a consumer can swap an external\n * ANN backend behind the same seam once N grows beyond the in-memory regime.\n *\n * Every operation returns a `Result` (async, since a real backend does I/O) so\n * failure is explicit and never throws across the seam.\n * @public\n */\nexport interface IVectorIndex {\n  /**\n   * Add (or replace) the embedding for the scope-qualified `target`. Returns the\n   * opaque {@link IMemoryEnvelope.embeddingRef | embeddingRef} the store stamps\n   * onto the envelope so a later read knows the record is embedded. Keying on the\n   * `(scope, id)` address (not a bare id) is load-bearing: two records that share\n   * a filename stem across scopes must not clobber each other's embedding.\n   */\n  add(target: IEdgeTarget, vector: Float32Array): Promise<Result<string>>;\n\n  /**\n   * Remove the embedding for the scope-qualified `target`. Returns the removed\n   * target. Idempotent — removing a target with no embedding still succeeds\n   * (returns the target).\n   */\n  remove(target: IEdgeTarget): Promise<Result<IEdgeTarget>>;\n\n  /**\n   * Return the `topK` nearest records to `vector`, in descending score order.\n   */\n  query(vector: Float32Array, topK: number): Promise<Result<ReadonlyArray<IVectorQueryHit>>>;\n}\n\n/**\n * Embeds a complete record into a vector for the store's embed-on-write hook.\n * Async and `Result`-returning, since a real embedder does a network call (cloud\n * provider) or in-process model inference. The consumer wires this — the core\n * package never calls an embedding provider directly, staying embedder-agnostic.\n * @public\n */\nexport type MemoryEmbedder = (record: IMemoryRecord<unknown>) => Promise<Result<Float32Array>>;\n\n/**\n * A record paired with its scope-qualified {@link IEdgeTarget | address}, as\n * yielded by {@link IMemoryRecordSource.list}. The address is required because\n * {@link InMemoryCosineIndex.rebuild} keys each re-embedded entry on the\n * scope-qualified target, not a bare {@link MemoryId} — two records that share a\n * filename stem across scopes must not collide when the whole vault is re-indexed.\n * @public\n */\nexport interface IScopedMemoryRecord {\n  /** The record's scope-qualified `(scope, id)` address. */\n  readonly target: IEdgeTarget;\n  /** The record itself, passed to the embedder. */\n  readonly record: IMemoryRecord<unknown>;\n}\n\n/**\n * The minimal record-source surface {@link InMemoryCosineIndex.rebuild} reads to\n * re-embed an entire vault. Each entry carries the record's scope-qualified\n * address (see {@link IScopedMemoryRecord}) so the rebuild keys the vector index\n * exactly as the incremental embed-on-write path does. A consumer backs this with\n * the store's scoped index — the vector packlet does not import the store packlet\n * (which depends on the vector packlet for {@link IVectorIndex}, so the reverse\n * import would be a cycle).\n * @public\n */\nexport interface IMemoryRecordSource {\n  /** List every record in the vault, each paired with its scoped address. */\n  list(): Promise<Result<ReadonlyArray<IScopedMemoryRecord>>>;\n}\n"]}

package/lib/test/unit/converters/antagonistRoundTrip.test.js

@@ -37,7 +37,7 @@ describe('antagonist — full on-disk round-trip preserves every optional field'
             links: [
                 {
                     type: 'rel',
-                    target: 'doc-2',
+                    target: { scope: 'knowledge', id: 'doc-2' },
                     confidence: 0.42,
                     provenance: { source: 'agent', by: 'curator', extra: { nested: true } },
                     valid_at: 111,
@@ -53,7 +53,7 @@ describe('antagonist — full on-disk round-trip preserves every optional field'
                 by: 'erik',
                 model: 'gpt-5',
                 confidence: 0.87,
-                derivedFrom: 'turn-3',
+                derivedFrom: { scope: 'conversations/c1', id: 'turn-3' },
                 // Opaque extension keys (per IProvenance's `[key: string]: unknown` arm).
                 sentiment: { score: 0.5 },
                 epistemic: 'belief'
@@ -75,7 +75,7 @@ describe('antagonist — full on-disk round-trip preserves every optional field'
             entityId: 'doc-2',
             kind,
             tags: [],
-            links: [{ type: 'rel', target: 'doc-3' }],
+            links: [{ type: 'rel', target: { scope: 'knowledge', id: 'doc-3' } }],
             created: 0,
             updated: 0,
             seq: 0,

package/lib/test/unit/converters/antagonistRoundTrip.test.js.map

@@ -1 +1 @@
-{"version":3,"file":"antagonistRoundTrip.test.js","sourceRoot":"","sources":["../../../../src/test/unit/converters/antagonistRoundTrip.test.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2026 Erik Fortune\n * SPDX-License-Identifier: MIT\n */\n\n/**\n * Antagonist torture test — convert/validate round-trip symmetry (target class\n * 7): every OPTIONAL field the envelope/edge/provenance shapes carry must\n * survive a full on-disk round-trip (serialize → YAML text → parse), not just a\n * single `Converter.convert` pass in memory. This exercises the exact path a\n * corrupted or field-dropping serializer/parser pair would break, mirroring the\n * `aiClientToolConfig`/`annotations` field-drop class named in the brief.\n */\n\nimport '@fgv/ts-utils-jest';\nimport { Converters } from '@fgv/ts-utils';\nimport {\n  BodyConverterRegistry,\n  IBodyConverterRegistry,\n  IMemoryEnvelope,\n  parseMemoryFile,\n  serializeMemoryFile\n} from '../../../index';\n\nconst kind = 'note' as IMemoryEnvelope['kind'];\n\nfunction registry(): IBodyConverterRegistry {\n  const reg = BodyConverterRegistry.create().orThrow();\n  reg.register(kind, Converters.string);\n  return reg;\n}\n\ndescribe('antagonist — full on-disk round-trip preserves every optional field', () => {\n  // Wrong impl this catches: a serializer/parser pair where one side silently\n  // drops an optional field (the exact class of bug the brief calls out for\n  // `aiClientToolConfig`/`annotations`-shaped converters) — e.g. omitting\n  // `temporal.invalid_at: null`, an edge's `valid_at`/`invalid_at`/`provenance`,\n  // a `null` `embeddingRef`, or a provenance extension key, because the author\n  // forgot to thread it through both the YAML emit AND the envelope Converter.\n  test('every optional envelope/edge/provenance field set simultaneously survives a full YAML round-trip', () => {\n    const envelope: IMemoryEnvelope = {\n      id: 'doc-1' as IMemoryEnvelope['id'],\n      entityId: 'doc-1' as IMemoryEnvelope['entityId'],\n      kind,\n      tags: ['t1', 't2'] as unknown as IMemoryEnvelope['tags'],\n      links: [\n        {\n          type: 'rel' as never,\n          target: 'doc-2' as never,\n          confidence: 0.42,\n          provenance: { source: 'agent', by: 'curator', extra: { nested: true } },\n          valid_at: 111,\n\n          invalid_at: null\n        }\n      ],\n      created: 1000,\n      updated: 2000,\n      seq: 7,\n      contentHash: 'abc123',\n      provenance: {\n        source: 'host-ingest',\n        by: 'erik',\n        model: 'gpt-5',\n        confidence: 0.87,\n        derivedFrom: 'turn-3' as never,\n        // Opaque extension keys (per IProvenance's `[key: string]: unknown` arm).\n        sentiment: { score: 0.5 },\n        epistemic: 'belief'\n      },\n\n      temporal: { valid_at: 500, invalid_at: null },\n\n      embeddingRef: null\n    };\n\n    const raw = serializeMemoryFile(envelope, 'the body text').orThrow();\n    expect(parseMemoryFile(raw, registry())).toSucceedAndSatisfy((record) => {\n      // Deep-equal the ENTIRE envelope, not field-by-field — a partial assertion\n      // list is exactly how a single dropped field slips through review.\n      expect(record.envelope).toEqual(envelope);\n      expect(record.body).toBe('the body text');\n    });\n  });\n\n  test('an absent temporal/embeddingRef/edge-optionals round-trips to fully absent (no null-vs-undefined drift)', () => {\n    const envelope: IMemoryEnvelope = {\n      id: 'doc-2' as IMemoryEnvelope['id'],\n      entityId: 'doc-2' as IMemoryEnvelope['entityId'],\n      kind,\n      tags: [],\n      links: [{ type: 'rel' as never, target: 'doc-3' as never }],\n      created: 0,\n      updated: 0,\n      seq: 0,\n      contentHash: '',\n      provenance: { source: 'agent' }\n    };\n    const raw = serializeMemoryFile(envelope, 'body').orThrow();\n    expect(parseMemoryFile(raw, registry())).toSucceedAndSatisfy((record) => {\n      expect(record.envelope.temporal).toBeUndefined();\n      expect(record.envelope.embeddingRef).toBeUndefined();\n      expect(record.envelope.links[0].confidence).toBeUndefined();\n      expect(record.envelope.links[0].provenance).toBeUndefined();\n      expect(record.envelope.links[0].valid_at).toBeUndefined();\n      expect(record.envelope.links[0].invalid_at).toBeUndefined();\n      expect(record.envelope).toEqual(envelope);\n    });\n  });\n});\n"]}
+{"version":3,"file":"antagonistRoundTrip.test.js","sourceRoot":"","sources":["../../../../src/test/unit/converters/antagonistRoundTrip.test.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2026 Erik Fortune\n * SPDX-License-Identifier: MIT\n */\n\n/**\n * Antagonist torture test — convert/validate round-trip symmetry (target class\n * 7): every OPTIONAL field the envelope/edge/provenance shapes carry must\n * survive a full on-disk round-trip (serialize → YAML text → parse), not just a\n * single `Converter.convert` pass in memory. This exercises the exact path a\n * corrupted or field-dropping serializer/parser pair would break, mirroring the\n * `aiClientToolConfig`/`annotations` field-drop class named in the brief.\n */\n\nimport '@fgv/ts-utils-jest';\nimport { Converters } from '@fgv/ts-utils';\nimport {\n  BodyConverterRegistry,\n  IBodyConverterRegistry,\n  IMemoryEnvelope,\n  parseMemoryFile,\n  serializeMemoryFile\n} from '../../../index';\n\nconst kind = 'note' as IMemoryEnvelope['kind'];\n\nfunction registry(): IBodyConverterRegistry {\n  const reg = BodyConverterRegistry.create().orThrow();\n  reg.register(kind, Converters.string);\n  return reg;\n}\n\ndescribe('antagonist — full on-disk round-trip preserves every optional field', () => {\n  // Wrong impl this catches: a serializer/parser pair where one side silently\n  // drops an optional field (the exact class of bug the brief calls out for\n  // `aiClientToolConfig`/`annotations`-shaped converters) — e.g. omitting\n  // `temporal.invalid_at: null`, an edge's `valid_at`/`invalid_at`/`provenance`,\n  // a `null` `embeddingRef`, or a provenance extension key, because the author\n  // forgot to thread it through both the YAML emit AND the envelope Converter.\n  test('every optional envelope/edge/provenance field set simultaneously survives a full YAML round-trip', () => {\n    const envelope: IMemoryEnvelope = {\n      id: 'doc-1' as IMemoryEnvelope['id'],\n      entityId: 'doc-1' as IMemoryEnvelope['entityId'],\n      kind,\n      tags: ['t1', 't2'] as unknown as IMemoryEnvelope['tags'],\n      links: [\n        {\n          type: 'rel' as never,\n          target: { scope: 'knowledge', id: 'doc-2' } as never,\n          confidence: 0.42,\n          provenance: { source: 'agent', by: 'curator', extra: { nested: true } },\n          valid_at: 111,\n\n          invalid_at: null\n        }\n      ],\n      created: 1000,\n      updated: 2000,\n      seq: 7,\n      contentHash: 'abc123',\n      provenance: {\n        source: 'host-ingest',\n        by: 'erik',\n        model: 'gpt-5',\n        confidence: 0.87,\n        derivedFrom: { scope: 'conversations/c1', id: 'turn-3' } as never,\n        // Opaque extension keys (per IProvenance's `[key: string]: unknown` arm).\n        sentiment: { score: 0.5 },\n        epistemic: 'belief'\n      },\n\n      temporal: { valid_at: 500, invalid_at: null },\n\n      embeddingRef: null\n    };\n\n    const raw = serializeMemoryFile(envelope, 'the body text').orThrow();\n    expect(parseMemoryFile(raw, registry())).toSucceedAndSatisfy((record) => {\n      // Deep-equal the ENTIRE envelope, not field-by-field — a partial assertion\n      // list is exactly how a single dropped field slips through review.\n      expect(record.envelope).toEqual(envelope);\n      expect(record.body).toBe('the body text');\n    });\n  });\n\n  test('an absent temporal/embeddingRef/edge-optionals round-trips to fully absent (no null-vs-undefined drift)', () => {\n    const envelope: IMemoryEnvelope = {\n      id: 'doc-2' as IMemoryEnvelope['id'],\n      entityId: 'doc-2' as IMemoryEnvelope['entityId'],\n      kind,\n      tags: [],\n      links: [{ type: 'rel' as never, target: { scope: 'knowledge', id: 'doc-3' } as never }],\n      created: 0,\n      updated: 0,\n      seq: 0,\n      contentHash: '',\n      provenance: { source: 'agent' }\n    };\n    const raw = serializeMemoryFile(envelope, 'body').orThrow();\n    expect(parseMemoryFile(raw, registry())).toSucceedAndSatisfy((record) => {\n      expect(record.envelope.temporal).toBeUndefined();\n      expect(record.envelope.embeddingRef).toBeUndefined();\n      expect(record.envelope.links[0].confidence).toBeUndefined();\n      expect(record.envelope.links[0].provenance).toBeUndefined();\n      expect(record.envelope.links[0].valid_at).toBeUndefined();\n      expect(record.envelope.links[0].invalid_at).toBeUndefined();\n      expect(record.envelope).toEqual(envelope);\n    });\n  });\n});\n"]}

package/lib/test/unit/converters/envelopeConverter.test.js

@@ -12,7 +12,7 @@ const validEnvelopeObject = {
     entityId: 'intro-to-rust',
     kind: 'knowledge',
     tags: ['rust', 'systems'],
-    links: [{ type: 'related', target: 'ownership' }],
+    links: [{ type: 'related', target: { scope: 'knowledge', id: 'ownership' } }],
     created: 1000,
     updated: 2000,
     seq: 5,
@@ -33,6 +33,23 @@ describe('provenanceConverter', () => {
     test('accepts an arbitrary source string (open vocabulary)', () => {
         expect(converters_1.provenanceConverter.convert({ source: 'host-ingest' })).toSucceedWith({ source: 'host-ingest' });
     });
+    test('validates a scope-qualified derivedFrom (nested { scope, id })', () => {
+        expect(converters_1.provenanceConverter.convert({
+            source: 'host-ingest',
+            derivedFrom: { scope: 'conversations/conv-a', id: 'turn-3' }
+        })).toSucceedAndSatisfy((p) => {
+            expect(p.derivedFrom).toEqual({ scope: 'conversations/conv-a', id: 'turn-3' });
+        });
+    });
+    test('rejects a bare-string derivedFrom (the pre-scoped format)', () => {
+        expect(converters_1.provenanceConverter.convert({ source: 'host-ingest', derivedFrom: 'turn-3' })).toFail();
+    });
+    test('rejects a derivedFrom missing scope', () => {
+        expect(converters_1.provenanceConverter.convert({ source: 'host-ingest', derivedFrom: { id: 'turn-3' } })).toFailWith(/scope/i);
+    });
+    test('rejects a derivedFrom missing id', () => {
+        expect(converters_1.provenanceConverter.convert({ source: 'host-ingest', derivedFrom: { scope: 'conversations/conv-a' } })).toFailWith(/id/i);
+    });
     test('fails when source is missing', () => {
         expect(converters_1.provenanceConverter.convert({ by: 'erik' })).toFail();
     });
@@ -40,18 +57,34 @@ describe('provenanceConverter', () => {
         expect(converters_1.provenanceConverter.convert('nope')).toFail();
     });
 });
+describe('edgeTargetConverter', () => {
+    test('validates a scope-qualified target', () => {
+        expect(converters_1.edgeTargetConverter.convert({ scope: 'conversations/conv-a', id: 'turn-3' })).toSucceedAndSatisfy((t) => {
+            expect(t).toEqual({ scope: 'conversations/conv-a', id: 'turn-3' });
+        });
+    });
+    test('rejects a target missing scope', () => {
+        expect(converters_1.edgeTargetConverter.convert({ id: 'turn-3' })).toFailWith(/scope/i);
+    });
+    test('rejects a target missing id', () => {
+        expect(converters_1.edgeTargetConverter.convert({ scope: 'conversations/conv-a' })).toFailWith(/id/i);
+    });
+    test('rejects a bare-string target (the pre-scoped format)', () => {
+        expect(converters_1.edgeTargetConverter.convert('turn-3')).toFail();
+    });
+});
 describe('edgeConverter', () => {
     test('validates a full attributed edge', () => {
         expect(converters_1.edgeConverter.convert({
             type: 'mtm-ref',
-            target: 'turn-3',
+            target: { scope: 'conversations/conv-a', id: 'turn-3' },
             confidence: 0.8,
             provenance: { source: 'agent' },
             valid_at: 100,
             invalid_at: 200
         })).toSucceedAndSatisfy((edge) => {
             expect(edge.type).toBe('mtm-ref');
-            expect(edge.target).toBe('turn-3');
+            expect(edge.target).toEqual({ scope: 'conversations/conv-a', id: 'turn-3' });
             expect(edge.confidence).toBe(0.8);
             expect(edge.provenance).toEqual({ source: 'agent' });
             expect(edge.valid_at).toBe(100);
@@ -59,23 +92,26 @@ describe('edgeConverter', () => {
         });
     });
     test('validates a minimal edge', () => {
-        expect(converters_1.edgeConverter.convert({ type: 'related', target: 'ownership' })).toSucceedAndSatisfy((edge) => {
+        expect(converters_1.edgeConverter.convert({ type: 'related', target: { scope: 'knowledge', id: 'ownership' } })).toSucceedAndSatisfy((edge) => {
             expect(edge.type).toBe('related');
-            expect(edge.target).toBe('ownership');
+            expect(edge.target).toEqual({ scope: 'knowledge', id: 'ownership' });
             expect(edge.confidence).toBeUndefined();
         });
     });
     test('accepts a null invalid_at (still valid)', () => {
-        expect(converters_1.edgeConverter.convert({ type: 'related', target: 'x', invalid_at: null })).toSucceedAndSatisfy((edge) => {
+        expect(converters_1.edgeConverter.convert({ type: 'related', target: { scope: 'knowledge', id: 'x' }, invalid_at: null })).toSucceedAndSatisfy((edge) => {
             expect(edge.invalid_at).toBeNull();
         });
     });
     test('fails when invalid_at is neither a number nor null', () => {
-        expect(converters_1.edgeConverter.convert({ type: 'related', target: 'x', invalid_at: 'soon' })).toFail();
+        expect(converters_1.edgeConverter.convert({ type: 'related', target: { scope: 'knowledge', id: 'x' }, invalid_at: 'soon' })).toFail();
     });
     test('fails when target is missing', () => {
         expect(converters_1.edgeConverter.convert({ type: 'related' })).toFail();
     });
+    test('fails when target is a bare string (rejects the pre-scoped format)', () => {
+        expect(converters_1.edgeConverter.convert({ type: 'related', target: 'ownership' })).toFail();
+    });
 });
 describe('temporalConverter', () => {
     test('validates a temporal block', () => {
@@ -112,6 +148,28 @@ describe('envelopeConverter', () => {
     test('fails when embeddingRef is neither a string nor null', () => {
         expect(converters_1.envelopeConverter.convert(Object.assign(Object.assign({}, validEnvelopeObject), { embeddingRef: 42 }))).toFail();
     });
+    test('rank is absent when not present', () => {
+        expect(converters_1.envelopeConverter.convert(validEnvelopeObject)).toSucceedAndSatisfy((envelope) => {
+            expect(envelope.rank).toBeUndefined();
+        });
+    });
+    test('validates and preserves a numeric rank', () => {
+        expect(converters_1.envelopeConverter.convert(Object.assign(Object.assign({}, validEnvelopeObject), { rank: 42 }))).toSucceedAndSatisfy((envelope) => {
+            expect(envelope.rank).toBe(42);
+        });
+    });
+    test('serialize/parse round-trips rank through frontmatter', () => {
+        const registry = converters_1.BodyConverterRegistry.create().orThrow();
+        registry.register('knowledge', ts_utils_1.Converters.string);
+        const envelope = converters_1.envelopeConverter.convert(Object.assign(Object.assign({}, validEnvelopeObject), { rank: 7 })).orThrow();
+        const file = (0, converters_1.serializeMemoryFile)(envelope, 'body').orThrow();
+        expect((0, converters_1.parseMemoryFile)(file, registry)).toSucceedAndSatisfy((record) => {
+            expect(record.envelope.rank).toBe(7);
+        });
+    });
+    test('fails when rank is not a number', () => {
+        expect(converters_1.envelopeConverter.convert(Object.assign(Object.assign({}, validEnvelopeObject), { rank: 'high' }))).toFail();
+    });
     test('fails when a required field is missing', () => {
         const missing = Object.assign({}, validEnvelopeObject);
         delete missing.contentHash;
@@ -178,6 +236,65 @@ describe('parseMemoryFile / serializeMemoryFile', () => {
             expect(record.body).toBe('The knowledge body.');
         });
     });
+    test('round-trips a scope-qualified edge target through the frontmatter intact', () => {
+        const envelope = converters_1.envelopeConverter
+            .convert(Object.assign(Object.assign({}, validEnvelopeObject), { links: [{ type: 'mtm-ref', target: { scope: 'conversations/conv-a', id: 'turn-3' } }] }))
+            .orThrow();
+        const file = (0, converters_1.serializeMemoryFile)(envelope, 'body').orThrow();
+        // On-wire the target is a nested object, NOT a bare scalar.
+        expect(file).toMatch(/scope: conversations\/conv-a/);
+        expect(file).toMatch(/id: turn-3/);
+        expect((0, converters_1.parseMemoryFile)(file, registry)).toSucceedAndSatisfy((record) => {
+            expect(record.envelope.links).toEqual([
+                { type: 'mtm-ref', target: { scope: 'conversations/conv-a', id: 'turn-3' } }
+            ]);
+            // Serializing the reparsed record reproduces byte-identical output.
+            expect((0, converters_1.serializeMemoryFile)(record.envelope, record.body)).toSucceedWith(file);
+        });
+    });
+    test('round-trips a scope-qualified provenance.derivedFrom through the frontmatter intact', () => {
+        const envelope = converters_1.envelopeConverter
+            .convert(Object.assign(Object.assign({}, validEnvelopeObject), { provenance: {
+                source: 'host-ingest',
+                derivedFrom: { scope: 'conversations/conv-a', id: 'turn-3' }
+            } }))
+            .orThrow();
+        const file = (0, converters_1.serializeMemoryFile)(envelope, 'body').orThrow();
+        // On-wire the back-reference is a nested object, NOT a bare scalar.
+        expect(file).toMatch(/scope: conversations\/conv-a/);
+        expect((0, converters_1.parseMemoryFile)(file, registry)).toSucceedAndSatisfy((record) => {
+            expect(record.envelope.provenance.derivedFrom).toEqual({
+                scope: 'conversations/conv-a',
+                id: 'turn-3'
+            });
+            expect((0, converters_1.serializeMemoryFile)(record.envelope, record.body)).toSucceedWith(file);
+        });
+    });
+    test('two records whose derivedFrom share a stem across scopes round-trip as distinct scoped refs', () => {
+        // Same idStem ('turn-3'), different scopes — exactly the ambiguity a bare
+        // MemoryId could not disambiguate. Each must round-trip to ITS OWN scope.
+        const makeFile = (scope) => {
+            const envelope = converters_1.envelopeConverter
+                .convert(Object.assign(Object.assign({}, validEnvelopeObject), { provenance: { source: 'host-ingest', derivedFrom: { scope, id: 'turn-3' } } }))
+                .orThrow();
+            return (0, converters_1.serializeMemoryFile)(envelope, 'body').orThrow();
+        };
+        const fileA = makeFile('conversations/conv-a');
+        const fileB = makeFile('conversations/conv-b');
+        expect(fileA).not.toBe(fileB);
+        expect((0, converters_1.parseMemoryFile)(fileA, registry)).toSucceedAndSatisfy((record) => {
+            expect(record.envelope.provenance.derivedFrom).toEqual({
+                scope: 'conversations/conv-a',
+                id: 'turn-3'
+            });
+        });
+        expect((0, converters_1.parseMemoryFile)(fileB, registry)).toSucceedAndSatisfy((record) => {
+            expect(record.envelope.provenance.derivedFrom).toEqual({
+                scope: 'conversations/conv-b',
+                id: 'turn-3'
+            });
+        });
+    });
     test('fails when the frontmatter cannot be split', () => {
         expect((0, converters_1.parseMemoryFile)('no delimiters', registry)).toFailWith(/missing opening frontmatter delimiter/i);
     });