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

package/temp/ts-agent-memory.api.json

@@ -1731,6 +1731,89 @@
             "endIndex": 5
           }
         },
+        {
+          "kind": "Variable",
+          "canonicalReference": "@fgv/ts-agent-memory!edgeTargetConverter:var",
+          "docComment": "/**\n * Converter for a scope-qualified {@link IEdgeTarget}. Both `scope` and `id` are required — the whole point of the scoped target is that a bare id is ambiguous across scopes.\n *\n * @public\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "edgeTargetConverter: "
+            },
+            {
+              "kind": "Reference",
+              "text": "Converter",
+              "canonicalReference": "@fgv/ts-utils!Converter:interface"
+            },
+            {
+              "kind": "Content",
+              "text": "<"
+            },
+            {
+              "kind": "Reference",
+              "text": "IEdgeTarget",
+              "canonicalReference": "@fgv/ts-agent-memory!IEdgeTarget:interface"
+            },
+            {
+              "kind": "Content",
+              "text": ">"
+            }
+          ],
+          "fileUrlPath": "src/packlets/converters/envelopeConverter.ts",
+          "isReadonly": true,
+          "releaseTag": "Public",
+          "name": "edgeTargetConverter",
+          "variableTypeTokenRange": {
+            "startIndex": 1,
+            "endIndex": 5
+          }
+        },
+        {
+          "kind": "Function",
+          "canonicalReference": "@fgv/ts-agent-memory!edgeTargetKey:function(1)",
+          "docComment": "/**\n * The canonical composite-key string for an {@link IEdgeTarget}: scope + id, NUL-separated. NUL is excluded from both components (scope segments are filename-safe; {@link MemoryId} is portable-filename-safe), so it is a collision-proof separator. This is the ONE canonicalization every consumer that keys on a scoped target uses — the backlink index, the cycle guard, and the ingest edge-validation path all route through it so their notions of \"same target\" cannot drift.\n *\n * @public\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export declare function edgeTargetKey(target: "
+            },
+            {
+              "kind": "Reference",
+              "text": "IEdgeTarget",
+              "canonicalReference": "@fgv/ts-agent-memory!IEdgeTarget:interface"
+            },
+            {
+              "kind": "Content",
+              "text": "): "
+            },
+            {
+              "kind": "Content",
+              "text": "string"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "src/packlets/types/envelope.ts",
+          "returnTypeTokenRange": {
+            "startIndex": 3,
+            "endIndex": 4
+          },
+          "releaseTag": "Public",
+          "overloadIndex": 1,
+          "parameters": [
+            {
+              "parameterName": "target",
+              "parameterTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              },
+              "isOptional": false
+            }
+          ],
+          "name": "edgeTargetKey"
+        },
         {
           "kind": "TypeAlias",
           "canonicalReference": "@fgv/ts-agent-memory!EntityId:type",
@@ -1861,6 +1944,38 @@
           "name": "FileTreeMemoryStore",
           "preserveMemberOrder": false,
           "members": [
+            {
+              "kind": "Method",
+              "canonicalReference": "@fgv/ts-agent-memory!FileTreeMemoryStore#asRecordSource:member(1)",
+              "docComment": "/**\n * Adapt this store to the {@link IMemoryRecordSource} seam so it can drive {@link IVectorIndex} rebuilds (e.g. `InMemoryCosineIndex.rebuild`). The returned source's `list()` delegates to {@link IMemoryStore.listScoped}. The store cannot implement {@link IMemoryRecordSource} directly because its `list(filter?)` returns bare records (the ergonomic query surface) while the seam's `list()` returns scope-qualified records.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "asRecordSource(): "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "IMemoryRecordSource",
+                  "canonicalReference": "@fgv/ts-agent-memory!IMemoryRecordSource:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isStatic": false,
+              "returnTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              },
+              "releaseTag": "Public",
+              "isProtected": false,
+              "overloadIndex": 1,
+              "parameters": [],
+              "isOptional": false,
+              "isAbstract": false,
+              "name": "asRecordSource"
+            },
             {
               "kind": "Method",
               "canonicalReference": "@fgv/ts-agent-memory!FileTreeMemoryStore.create:member(1)",
@@ -2272,6 +2387,69 @@
               "isAbstract": false,
               "name": "list"
             },
+            {
+              "kind": "Method",
+              "canonicalReference": "@fgv/ts-agent-memory!FileTreeMemoryStore#listScoped:member(1)",
+              "docComment": "/**\n * List EVERY record in the vault, each paired with its scope-qualified `(scope, id)` address — the projection {@link IMemoryRecordSource} requires. Unlike {@link IMemoryStore.list | list}, it takes no filter (whole-vault) and returns {@link IScopedMemoryRecord}s so a re-index keys each entry on the same scoped target the incremental embed-on-write path uses. Two records that share a filename stem across scopes appear as distinct entries.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "listScoped(): "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "Promise",
+                  "canonicalReference": "!Promise:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": "<"
+                },
+                {
+                  "kind": "Reference",
+                  "text": "Result",
+                  "canonicalReference": "@fgv/ts-utils!Result:type"
+                },
+                {
+                  "kind": "Content",
+                  "text": "<"
+                },
+                {
+                  "kind": "Reference",
+                  "text": "ReadonlyArray",
+                  "canonicalReference": "!ReadonlyArray:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": "<"
+                },
+                {
+                  "kind": "Reference",
+                  "text": "IScopedMemoryRecord",
+                  "canonicalReference": "@fgv/ts-agent-memory!IScopedMemoryRecord:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": ">>>"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isStatic": false,
+              "returnTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 9
+              },
+              "releaseTag": "Public",
+              "isProtected": false,
+              "overloadIndex": 1,
+              "parameters": [],
+              "isOptional": false,
+              "isAbstract": false,
+              "name": "listScoped"
+            },
             {
               "kind": "Method",
               "canonicalReference": "@fgv/ts-agent-memory!FileTreeMemoryStore#put:member(1)",
@@ -3290,7 +3468,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@fgv/ts-agent-memory!ICandidateEdge#source:member",
-              "docComment": "/**\n * The reference id (codec `idStem`) of the candidate the edge originates from.\n */\n",
+              "docComment": "/**\n * The scope-qualified reference (codec `(scope, idStem)`) of the candidate the edge originates from.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -3298,8 +3476,8 @@
                 },
                 {
                   "kind": "Reference",
-                  "text": "MemoryId",
-                  "canonicalReference": "@fgv/ts-agent-memory!MemoryId:type"
+                  "text": "IEdgeTarget",
+                  "canonicalReference": "@fgv/ts-agent-memory!IEdgeTarget:interface"
                 },
                 {
                   "kind": "Content",
@@ -3583,6 +3761,56 @@
                 "endIndex": 5
               }
             },
+            {
+              "kind": "PropertySignature",
+              "canonicalReference": "@fgv/ts-agent-memory!ICreateMemoryToolsParams#projectItem:member",
+              "docComment": "/**\n * Optional host projector mapping a record (and the requested detail tier) to its agent-visible {@link IMemoryToolResultItem}. When supplied, every `memory_search` / `memory_context` / `memory_read` result item is produced by this callback — the host owns how much of the body a `'gist'` vs `'full'` result carries, so it can bound the default (`'gist'`) path.\n *\n * When absent, the built-in default projection is used (full body plus the {@link ICreateMemoryToolsParams.handleFor | handleFor} handle), which ignores the detail tier — behavior is byte-identical to a build with no projector.\n *\n * The callback is guarded exactly like `handleFor`: a throw degrades to the default full-body projection for that item rather than failing the whole search.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "readonly projectItem?: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "(record: "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "IMemoryRecord",
+                  "canonicalReference": "@fgv/ts-agent-memory!IMemoryRecord:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": "<unknown>, detail: "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "MemoryDetailTier",
+                  "canonicalReference": "@fgv/ts-agent-memory!MemoryDetailTier:type"
+                },
+                {
+                  "kind": "Content",
+                  "text": ") => "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "IMemoryToolResultItem",
+                  "canonicalReference": "@fgv/ts-agent-memory!IMemoryToolResultItem:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isReadonly": true,
+              "isOptional": true,
+              "releaseTag": "Public",
+              "name": "projectItem",
+              "propertyTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 7
+              }
+            },
             {
               "kind": "PropertySignature",
               "canonicalReference": "@fgv/ts-agent-memory!ICreateMemoryToolsParams#registry:member",
@@ -3714,7 +3942,7 @@
         {
           "kind": "Interface",
           "canonicalReference": "@fgv/ts-agent-memory!ICycleGuardEdge:interface",
-          "docComment": "/**\n * A directed edge in the link graph the cycle guard reasons over: `source` links to `target` under relation `type`.\n *\n * @public\n */\n",
+          "docComment": "/**\n * A directed edge in the link graph the cycle guard reasons over: scope-qualified `source` links to scope-qualified `target` under relation `type`.\n *\n * @public\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -3737,8 +3965,8 @@
                 },
                 {
                   "kind": "Reference",
-                  "text": "MemoryId",
-                  "canonicalReference": "@fgv/ts-agent-memory!MemoryId:type"
+                  "text": "IEdgeTarget",
+                  "canonicalReference": "@fgv/ts-agent-memory!IEdgeTarget:interface"
                 },
                 {
                   "kind": "Content",
@@ -3765,8 +3993,8 @@
                 },
                 {
                   "kind": "Reference",
-                  "text": "MemoryId",
-                  "canonicalReference": "@fgv/ts-agent-memory!MemoryId:type"
+                  "text": "IEdgeTarget",
+                  "canonicalReference": "@fgv/ts-agent-memory!IEdgeTarget:interface"
                 },
                 {
                   "kind": "Content",
@@ -3816,7 +4044,7 @@
         {
           "kind": "Interface",
           "canonicalReference": "@fgv/ts-agent-memory!IEdge:interface",
-          "docComment": "/**\n * An attributed link between two records. Carries the relation type, the target id, and optional confidence / provenance / world-truth validity. Replaces bare string references (e.g. PersonAIlity's `IMtmRef` becomes an `IEdge` with `type: LinkType('mtm-ref')`).\n *\n * @public\n */\n",
+          "docComment": "/**\n * An attributed link between two records. Carries the relation type, the scope-qualified {@link IEdgeTarget | target}, and optional confidence / provenance / world-truth validity. Replaces bare string references (e.g. PersonAIlity's `IMtmRef` becomes an `IEdge` with `type: LinkType('mtm-ref')`).\n *\n * @public\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -3913,7 +4141,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@fgv/ts-agent-memory!IEdge#target:member",
-              "docComment": "/**\n * The linked-to record.\n */\n",
+              "docComment": "/**\n * The scope-qualified address of the linked-to record.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -3921,8 +4149,8 @@
                 },
                 {
                   "kind": "Reference",
-                  "text": "MemoryId",
-                  "canonicalReference": "@fgv/ts-agent-memory!MemoryId:type"
+                  "text": "IEdgeTarget",
+                  "canonicalReference": "@fgv/ts-agent-memory!IEdgeTarget:interface"
                 },
                 {
                   "kind": "Content",
@@ -3998,23 +4226,23 @@
         },
         {
           "kind": "Interface",
-          "canonicalReference": "@fgv/ts-agent-memory!IEntityResolutionCandidate:interface",
-          "docComment": "/**\n * A near-duplicate candidate surfaced to the {@link IEntityResolver} by stage-4 layer-2 similarity search: an existing record whose embedding is within the similarity threshold of the incoming candidate.\n *\n * @public\n */\n",
+          "canonicalReference": "@fgv/ts-agent-memory!IEdgeTarget:interface",
+          "docComment": "/**\n * The physical address of a linked-to record: the `(scope, id)` pair that uniquely identifies it. Both components are required because a bare {@link MemoryId} is NOT unique across scopes — per-scope codecs (e.g. the medium-term codec's `turn-<n>` stems) legally mint the same stem under different scopes, so an edge that carried only the id would be ambiguous. `(scope, id)` matches the store's `getById(scope, id)` addressing and the index's composite primary key.\n *\n * @public\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
-              "text": "export interface IEntityResolutionCandidate "
+              "text": "export interface IEdgeTarget "
             }
           ],
-          "fileUrlPath": "src/packlets/ingest/model.ts",
+          "fileUrlPath": "src/packlets/types/envelope.ts",
           "releaseTag": "Public",
-          "name": "IEntityResolutionCandidate",
+          "name": "IEdgeTarget",
           "preserveMemberOrder": false,
           "members": [
             {
               "kind": "PropertySignature",
-              "canonicalReference": "@fgv/ts-agent-memory!IEntityResolutionCandidate#id:member",
-              "docComment": "/**\n * The existing record's id.\n */\n",
+              "canonicalReference": "@fgv/ts-agent-memory!IEdgeTarget#id:member",
+              "docComment": "/**\n * The target record's stable file-stem id (unique WITHIN {@link IEdgeTarget.scope}).\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -4039,6 +4267,52 @@
                 "endIndex": 2
               }
             },
+            {
+              "kind": "PropertySignature",
+              "canonicalReference": "@fgv/ts-agent-memory!IEdgeTarget#scope:member",
+              "docComment": "/**\n * The scope the target record lives under.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "readonly scope: "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "MemoryScopeKey",
+                  "canonicalReference": "@fgv/ts-agent-memory!MemoryScopeKey:type"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isReadonly": true,
+              "isOptional": false,
+              "releaseTag": "Public",
+              "name": "scope",
+              "propertyTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              }
+            }
+          ],
+          "extendsTokenRanges": []
+        },
+        {
+          "kind": "Interface",
+          "canonicalReference": "@fgv/ts-agent-memory!IEntityResolutionCandidate:interface",
+          "docComment": "/**\n * A near-duplicate candidate surfaced to the {@link IEntityResolver} by stage-4 layer-2 similarity search: an existing record whose embedding is within the similarity threshold of the incoming candidate.\n *\n * @public\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export interface IEntityResolutionCandidate "
+            }
+          ],
+          "fileUrlPath": "src/packlets/ingest/model.ts",
+          "releaseTag": "Public",
+          "name": "IEntityResolutionCandidate",
+          "preserveMemberOrder": false,
+          "members": [
             {
               "kind": "PropertySignature",
               "canonicalReference": "@fgv/ts-agent-memory!IEntityResolutionCandidate#record:member",
@@ -4097,6 +4371,34 @@
                 "startIndex": 1,
                 "endIndex": 2
               }
+            },
+            {
+              "kind": "PropertySignature",
+              "canonicalReference": "@fgv/ts-agent-memory!IEntityResolutionCandidate#target:member",
+              "docComment": "/**\n * The existing record's scope-qualified `(scope, id)` address. Scope-qualified (not a bare {@link MemoryId}) because per-scope codecs legally mint the same stem under different scopes — the {@link ResolutionVerdict} target the resolver returns must round-trip this exact address so the write binds the intended record.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "readonly target: "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "IEdgeTarget",
+                  "canonicalReference": "@fgv/ts-agent-memory!IEdgeTarget:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isReadonly": true,
+              "isOptional": false,
+              "releaseTag": "Public",
+              "name": "target",
+              "propertyTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              }
             }
           ],
           "extendsTokenRanges": []
@@ -4548,6 +4850,56 @@
                 "endIndex": 5
               }
             },
+            {
+              "kind": "PropertySignature",
+              "canonicalReference": "@fgv/ts-agent-memory!IFileTreeMemoryStoreCreateParams#rankProjectors:member",
+              "docComment": "/**\n * Optional per-kind host projector map. When a kind has an entry, the store runs the projector on the fully-resolved (post-merge) record on every put AND every update — in the same pass that recomputes `contentHash` — and stamps the numeric result into {@link IMemoryEnvelope.rank}, which the index's rank view and `orderBy: 'rank'` retrieval sort by (descending, absent last). Absent for a kind → that kind's records carry no `rank`. Purely additive and zero-overhead when unwired: an absent map leaves every write byte-identical. The projector is a host callback — a throw is logged at `warn` and the record is stamped with no `rank`, never failing the write (mirrors the store's other guard-host-callbacks conventions).\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "readonly rankProjectors?: "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "ReadonlyMap",
+                  "canonicalReference": "!ReadonlyMap:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": "<"
+                },
+                {
+                  "kind": "Reference",
+                  "text": "Kind",
+                  "canonicalReference": "@fgv/ts-agent-memory!Kind:type"
+                },
+                {
+                  "kind": "Content",
+                  "text": ", "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "RankProjector",
+                  "canonicalReference": "@fgv/ts-agent-memory!RankProjector:type"
+                },
+                {
+                  "kind": "Content",
+                  "text": ">"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isReadonly": true,
+              "isOptional": true,
+              "releaseTag": "Public",
+              "name": "rankProjectors",
+              "propertyTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 7
+              }
+            },
             {
               "kind": "PropertySignature",
               "canonicalReference": "@fgv/ts-agent-memory!IFileTreeMemoryStoreCreateParams#registry:member",
@@ -5463,7 +5815,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@fgv/ts-agent-memory!IIngestItem#sourceId:member",
-              "docComment": "/**\n * Optional back-link to the memory record this item was derived from (e.g. the MTM turn an extracted fact came from). When present, fgv stamps it as {@link IProvenance.derivedFrom | provenance.derivedFrom} on every record ingested from this item (stage 6) — the cross-kind provenance spine.\n */\n",
+              "docComment": "/**\n * Optional scope-qualified back-link to the memory record this item was derived from (e.g. the MTM turn an extracted fact came from). When present, fgv stamps it as {@link IProvenance.derivedFrom | provenance.derivedFrom} on every record ingested from this item (stage 6) — the cross-kind provenance spine. A scope-qualified {@link IEdgeTarget} (not a bare {@link MemoryId}) because per-scope codecs legally reuse a stem across scopes, so a bare id would be ambiguous.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -5471,8 +5823,8 @@
                 },
                 {
                   "kind": "Reference",
-                  "text": "MemoryId",
-                  "canonicalReference": "@fgv/ts-agent-memory!MemoryId:type"
+                  "text": "IEdgeTarget",
+                  "canonicalReference": "@fgv/ts-agent-memory!IEdgeTarget:interface"
                 },
                 {
                   "kind": "Content",
@@ -6149,6 +6501,33 @@
                 "endIndex": 2
               }
             },
+            {
+              "kind": "PropertySignature",
+              "canonicalReference": "@fgv/ts-agent-memory!IMemoryEnvelope#rank:member",
+              "docComment": "/**\n * Store-computed host-defined ordering value, produced by the kind's {@link RankProjector} on every put/update and stamped into the envelope in the same pass that recomputes {@link IMemoryEnvelope.contentHash | contentHash}. Absent when the kind has no registered projector (or the projector threw on this record). Ordered retrieval (`orderBy: 'rank'`) and the index's rank view sort by this value descending, placing records with an absent `rank` last.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "readonly rank?: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "number"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isReadonly": true,
+              "isOptional": true,
+              "releaseTag": "Public",
+              "name": "rank",
+              "propertyTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              }
+            },
             {
               "kind": "PropertySignature",
               "canonicalReference": "@fgv/ts-agent-memory!IMemoryEnvelope#seq:member",
@@ -6365,7 +6744,7 @@
             {
               "kind": "MethodSignature",
               "canonicalReference": "@fgv/ts-agent-memory!IMemoryIndex#backlinks:member(1)",
-              "docComment": "/**\n * The ids of records whose `links` point AT `target` (inbound edges). The seed map for B2 link-traversal.\n */\n",
+              "docComment": "/**\n * The scope-qualified sources of records whose `links` point AT `target` (inbound edges), keyed on the target's `(scope, id)` address. The seed map for B2 link-traversal; results are {@link IEdgeTarget}s so a caller can feed them straight back in as further traversal seeds.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -6373,8 +6752,8 @@
                 },
                 {
                   "kind": "Reference",
-                  "text": "MemoryId",
-                  "canonicalReference": "@fgv/ts-agent-memory!MemoryId:type"
+                  "text": "IEdgeTarget",
+                  "canonicalReference": "@fgv/ts-agent-memory!IEdgeTarget:interface"
                 },
                 {
                   "kind": "Content",
@@ -6391,8 +6770,8 @@
                 },
                 {
                   "kind": "Reference",
-                  "text": "MemoryId",
-                  "canonicalReference": "@fgv/ts-agent-memory!MemoryId:type"
+                  "text": "IEdgeTarget",
+                  "canonicalReference": "@fgv/ts-agent-memory!IEdgeTarget:interface"
                 },
                 {
                   "kind": "Content",
@@ -6482,6 +6861,48 @@
               ],
               "name": "byKind"
             },
+            {
+              "kind": "MethodSignature",
+              "canonicalReference": "@fgv/ts-agent-memory!IMemoryIndex#byRank:member(1)",
+              "docComment": "/**\n * All records ordered by store-computed {@link IMemoryEnvelope.rank} descending, with recency (most-recently-updated, then `seq`) as a tiebreak. Records with an absent `rank` sort LAST (after every ranked record), then by recency among themselves. Serves a bounded top-M ({@link IMemoryEnvelope.rank}-ordered) page from the in-memory index with no full-vault (filesystem) scan.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "byRank(): "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "ReadonlyArray",
+                  "canonicalReference": "!ReadonlyArray:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": "<"
+                },
+                {
+                  "kind": "Reference",
+                  "text": "IMemoryRecord",
+                  "canonicalReference": "@fgv/ts-agent-memory!IMemoryRecord:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": "<unknown>>"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isOptional": false,
+              "returnTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 5
+              },
+              "releaseTag": "Public",
+              "overloadIndex": 1,
+              "parameters": [],
+              "name": "byRank"
+            },
             {
               "kind": "MethodSignature",
               "canonicalReference": "@fgv/ts-agent-memory!IMemoryIndex#byRecency:member(1)",
@@ -8096,11 +8517,102 @@
               "excerptTokens": [
                 {
                   "kind": "Content",
-                  "text": "readonly asOf?: "
+                  "text": "readonly asOf?: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "number"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isReadonly": true,
+              "isOptional": true,
+              "releaseTag": "Public",
+              "name": "asOf",
+              "propertyTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              }
+            },
+            {
+              "kind": "PropertySignature",
+              "canonicalReference": "@fgv/ts-agent-memory!IMemoryQuery#filter:member",
+              "docComment": "/**\n * Arbitrary predicate applied after the scope / kind / tag pre-filter.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "readonly filter?: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "(record: "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "IMemoryRecord",
+                  "canonicalReference": "@fgv/ts-agent-memory!IMemoryRecord:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": "<unknown>) => boolean"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isReadonly": true,
+              "isOptional": true,
+              "releaseTag": "Public",
+              "name": "filter",
+              "propertyTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 4
+              }
+            },
+            {
+              "kind": "PropertySignature",
+              "canonicalReference": "@fgv/ts-agent-memory!IMemoryQuery#hops:member",
+              "docComment": "/**\n * BFS hop count for link traversal. Default: 1.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "readonly hops?: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "number"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isReadonly": true,
+              "isOptional": true,
+              "releaseTag": "Public",
+              "name": "hops",
+              "propertyTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              }
+            },
+            {
+              "kind": "PropertySignature",
+              "canonicalReference": "@fgv/ts-agent-memory!IMemoryQuery#kind:member",
+              "docComment": "/**\n * Restrict to records of this kind — the single-kind shorthand for {@link IMemoryQuery.kinds | kinds}. When both are set they compose as AND (the record's kind must satisfy both), so `kind` must itself be a member of `kinds` for anything to match.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "readonly kind?: "
                 },
                 {
-                  "kind": "Content",
-                  "text": "number"
+                  "kind": "Reference",
+                  "text": "Kind",
+                  "canonicalReference": "@fgv/ts-agent-memory!Kind:type"
                 },
                 {
                   "kind": "Content",
@@ -8110,7 +8622,7 @@
               "isReadonly": true,
               "isOptional": true,
               "releaseTag": "Public",
-              "name": "asOf",
+              "name": "kind",
               "propertyTypeTokenRange": {
                 "startIndex": 1,
                 "endIndex": 2
@@ -8118,25 +8630,30 @@
             },
             {
               "kind": "PropertySignature",
-              "canonicalReference": "@fgv/ts-agent-memory!IMemoryQuery#filter:member",
-              "docComment": "/**\n * Arbitrary predicate applied after the scope / kind / tag pre-filter.\n */\n",
+              "canonicalReference": "@fgv/ts-agent-memory!IMemoryQuery#kinds:member",
+              "docComment": "/**\n * Restrict to records in ANY of these kinds — the general (multi-kind) form of {@link IMemoryQuery.kind | kind}. Absent → no kind-set constraint (today's behavior). An explicit empty array `[]` matches NOTHING (mirroring the non-positive-`limit` \"explicit empty\" convention), never \"match all\".\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
-                  "text": "readonly filter?: "
+                  "text": "readonly kinds?: "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "ReadonlyArray",
+                  "canonicalReference": "!ReadonlyArray:interface"
                 },
                 {
                   "kind": "Content",
-                  "text": "(record: "
+                  "text": "<"
                 },
                 {
                   "kind": "Reference",
-                  "text": "IMemoryRecord",
-                  "canonicalReference": "@fgv/ts-agent-memory!IMemoryRecord:interface"
+                  "text": "Kind",
+                  "canonicalReference": "@fgv/ts-agent-memory!Kind:type"
                 },
                 {
                   "kind": "Content",
-                  "text": "<unknown>) => boolean"
+                  "text": ">"
                 },
                 {
                   "kind": "Content",
@@ -8146,20 +8663,20 @@
               "isReadonly": true,
               "isOptional": true,
               "releaseTag": "Public",
-              "name": "filter",
+              "name": "kinds",
               "propertyTypeTokenRange": {
                 "startIndex": 1,
-                "endIndex": 4
+                "endIndex": 5
               }
             },
             {
               "kind": "PropertySignature",
-              "canonicalReference": "@fgv/ts-agent-memory!IMemoryQuery#hops:member",
-              "docComment": "/**\n * BFS hop count for link traversal. Default: 1.\n */\n",
+              "canonicalReference": "@fgv/ts-agent-memory!IMemoryQuery#limit:member",
+              "docComment": "/**\n * Maximum records to return. Applied after all other filters.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
-                  "text": "readonly hops?: "
+                  "text": "readonly limit?: "
                 },
                 {
                   "kind": "Content",
@@ -8173,7 +8690,7 @@
               "isReadonly": true,
               "isOptional": true,
               "releaseTag": "Public",
-              "name": "hops",
+              "name": "limit",
               "propertyTypeTokenRange": {
                 "startIndex": 1,
                 "endIndex": 2
@@ -8181,17 +8698,17 @@
             },
             {
               "kind": "PropertySignature",
-              "canonicalReference": "@fgv/ts-agent-memory!IMemoryQuery#kind:member",
-              "docComment": "/**\n * Restrict to records of this kind.\n */\n",
+              "canonicalReference": "@fgv/ts-agent-memory!IMemoryQuery#linkedFrom:member",
+              "docComment": "/**\n * Restrict to records linked FROM this scope-qualified seed (outbound).\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
-                  "text": "readonly kind?: "
+                  "text": "readonly linkedFrom?: "
                 },
                 {
                   "kind": "Reference",
-                  "text": "Kind",
-                  "canonicalReference": "@fgv/ts-agent-memory!Kind:type"
+                  "text": "IEdgeTarget",
+                  "canonicalReference": "@fgv/ts-agent-memory!IEdgeTarget:interface"
                 },
                 {
                   "kind": "Content",
@@ -8201,7 +8718,7 @@
               "isReadonly": true,
               "isOptional": true,
               "releaseTag": "Public",
-              "name": "kind",
+              "name": "linkedFrom",
               "propertyTypeTokenRange": {
                 "startIndex": 1,
                 "endIndex": 2
@@ -8209,16 +8726,17 @@
             },
             {
               "kind": "PropertySignature",
-              "canonicalReference": "@fgv/ts-agent-memory!IMemoryQuery#limit:member",
-              "docComment": "/**\n * Maximum records to return. Applied after all other filters.\n */\n",
+              "canonicalReference": "@fgv/ts-agent-memory!IMemoryQuery#linkedTo:member",
+              "docComment": "/**\n * Restrict to records linked TO this scope-qualified seed (inbound / backlinks).\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
-                  "text": "readonly limit?: "
+                  "text": "readonly linkedTo?: "
                 },
                 {
-                  "kind": "Content",
-                  "text": "number"
+                  "kind": "Reference",
+                  "text": "IEdgeTarget",
+                  "canonicalReference": "@fgv/ts-agent-memory!IEdgeTarget:interface"
                 },
                 {
                   "kind": "Content",
@@ -8228,7 +8746,7 @@
               "isReadonly": true,
               "isOptional": true,
               "releaseTag": "Public",
-              "name": "limit",
+              "name": "linkedTo",
               "propertyTypeTokenRange": {
                 "startIndex": 1,
                 "endIndex": 2
@@ -8236,17 +8754,16 @@
             },
             {
               "kind": "PropertySignature",
-              "canonicalReference": "@fgv/ts-agent-memory!IMemoryQuery#linkedFrom:member",
-              "docComment": "/**\n * Restrict to records linked FROM this id (outbound).\n */\n",
+              "canonicalReference": "@fgv/ts-agent-memory!IMemoryQuery#offset:member",
+              "docComment": "/**\n * Records to skip after ordering, before `limit` — so `{ offset, limit }` is a stable page window over the ordered result set. Default 0. A non-positive or absent offset is today's behavior (no skip); an offset past the end yields an empty page, never a throw.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
-                  "text": "readonly linkedFrom?: "
+                  "text": "readonly offset?: "
                 },
                 {
-                  "kind": "Reference",
-                  "text": "MemoryId",
-                  "canonicalReference": "@fgv/ts-agent-memory!MemoryId:type"
+                  "kind": "Content",
+                  "text": "number"
                 },
                 {
                   "kind": "Content",
@@ -8256,7 +8773,7 @@
               "isReadonly": true,
               "isOptional": true,
               "releaseTag": "Public",
-              "name": "linkedFrom",
+              "name": "offset",
               "propertyTypeTokenRange": {
                 "startIndex": 1,
                 "endIndex": 2
@@ -8264,17 +8781,16 @@
             },
             {
               "kind": "PropertySignature",
-              "canonicalReference": "@fgv/ts-agent-memory!IMemoryQuery#linkedTo:member",
-              "docComment": "/**\n * Restrict to records linked TO this id (inbound / backlinks).\n */\n",
+              "canonicalReference": "@fgv/ts-agent-memory!IMemoryQuery#orderBy:member",
+              "docComment": "/**\n * Ordering for the result set. `'recency'` (the default when absent — today's exact behavior) orders most-recently-updated first; `'rank'` orders by the store-computed {@link IMemoryEnvelope.rank} descending (records with an absent `rank` last), with recency as the tiebreak. Combined with `{ limit, offset }` this yields a bounded top-M rank-ordered page with no full-vault scan.\n *\n * @remarks\n *\n * `orderBy` governs the ordered non-semantic retrievers (recency / tag / structured-filter / link-traversal) and the {@link HybridRetriever}'s post-merge ordering. The {@link SemanticRetriever} is the sole exception: it preserves its native vector-similarity order regardless of `orderBy` — re-sorting semantic hits by `rank` would discard the similarity ranking that is the whole point of that path; a consumer that wants rank ordering uses a non-semantic query.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
-                  "text": "readonly linkedTo?: "
+                  "text": "readonly orderBy?: "
                 },
                 {
-                  "kind": "Reference",
-                  "text": "MemoryId",
-                  "canonicalReference": "@fgv/ts-agent-memory!MemoryId:type"
+                  "kind": "Content",
+                  "text": "'recency' | 'rank'"
                 },
                 {
                   "kind": "Content",
@@ -8284,7 +8800,7 @@
               "isReadonly": true,
               "isOptional": true,
               "releaseTag": "Public",
-              "name": "linkedTo",
+              "name": "orderBy",
               "propertyTypeTokenRange": {
                 "startIndex": 1,
                 "endIndex": 2
@@ -8500,7 +9016,7 @@
         {
           "kind": "Interface",
           "canonicalReference": "@fgv/ts-agent-memory!IMemoryRecordSource:interface",
-          "docComment": "/**\n * 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).\n *\n * @public\n */\n",
+          "docComment": "/**\n * The minimal record-source surface {@link InMemoryCosineIndex.rebuild} reads to 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).\n *\n * @public\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -8515,7 +9031,7 @@
             {
               "kind": "MethodSignature",
               "canonicalReference": "@fgv/ts-agent-memory!IMemoryRecordSource#list:member(1)",
-              "docComment": "/**\n * List every record in the vault.\n */\n",
+              "docComment": "/**\n * List every record in the vault, each paired with its scoped address.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -8550,12 +9066,12 @@
                 },
                 {
                   "kind": "Reference",
-                  "text": "IMemoryRecord",
-                  "canonicalReference": "@fgv/ts-agent-memory!IMemoryRecord:interface"
+                  "text": "IScopedMemoryRecord",
+                  "canonicalReference": "@fgv/ts-agent-memory!IScopedMemoryRecord:interface"
                 },
                 {
                   "kind": "Content",
-                  "text": "<unknown>>>>"
+                  "text": ">>>"
                 },
                 {
                   "kind": "Content",
@@ -8813,6 +9329,35 @@
           "name": "IMemoryStore",
           "preserveMemberOrder": false,
           "members": [
+            {
+              "kind": "MethodSignature",
+              "canonicalReference": "@fgv/ts-agent-memory!IMemoryStore#asRecordSource:member(1)",
+              "docComment": "/**\n * Adapt this store to the {@link IMemoryRecordSource} seam so it can drive {@link IVectorIndex} rebuilds (e.g. `InMemoryCosineIndex.rebuild`). The returned source's `list()` delegates to {@link IMemoryStore.listScoped}. The store cannot implement {@link IMemoryRecordSource} directly because its `list(filter?)` returns bare records (the ergonomic query surface) while the seam's `list()` returns scope-qualified records.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "asRecordSource(): "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "IMemoryRecordSource",
+                  "canonicalReference": "@fgv/ts-agent-memory!IMemoryRecordSource:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isOptional": false,
+              "returnTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              },
+              "releaseTag": "Public",
+              "overloadIndex": 1,
+              "parameters": [],
+              "name": "asRecordSource"
+            },
             {
               "kind": "MethodSignature",
               "canonicalReference": "@fgv/ts-agent-memory!IMemoryStore#delete:member(1)",
@@ -9149,6 +9694,66 @@
               ],
               "name": "list"
             },
+            {
+              "kind": "MethodSignature",
+              "canonicalReference": "@fgv/ts-agent-memory!IMemoryStore#listScoped:member(1)",
+              "docComment": "/**\n * List EVERY record in the vault, each paired with its scope-qualified `(scope, id)` address — the projection {@link IMemoryRecordSource} requires. Unlike {@link IMemoryStore.list | list}, it takes no filter (whole-vault) and returns {@link IScopedMemoryRecord}s so a re-index keys each entry on the same scoped target the incremental embed-on-write path uses. Two records that share a filename stem across scopes appear as distinct entries.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "listScoped(): "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "Promise",
+                  "canonicalReference": "!Promise:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": "<"
+                },
+                {
+                  "kind": "Reference",
+                  "text": "Result",
+                  "canonicalReference": "@fgv/ts-utils!Result:type"
+                },
+                {
+                  "kind": "Content",
+                  "text": "<"
+                },
+                {
+                  "kind": "Reference",
+                  "text": "ReadonlyArray",
+                  "canonicalReference": "!ReadonlyArray:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": "<"
+                },
+                {
+                  "kind": "Reference",
+                  "text": "IScopedMemoryRecord",
+                  "canonicalReference": "@fgv/ts-agent-memory!IScopedMemoryRecord:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": ">>>"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isOptional": false,
+              "returnTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 9
+              },
+              "releaseTag": "Public",
+              "overloadIndex": 1,
+              "parameters": [],
+              "name": "listScoped"
+            },
             {
               "kind": "MethodSignature",
               "canonicalReference": "@fgv/ts-agent-memory!IMemoryStore#put:member(1)",
@@ -9870,16 +10475,16 @@
             {
               "kind": "Method",
               "canonicalReference": "@fgv/ts-agent-memory!InMemoryCosineIndex#add:member(1)",
-              "docComment": "/**\n * 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.\n */\n",
+              "docComment": "/**\n * 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.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
-                  "text": "add(id: "
+                  "text": "add(target: "
                 },
                 {
                   "kind": "Reference",
-                  "text": "MemoryId",
-                  "canonicalReference": "@fgv/ts-agent-memory!MemoryId:type"
+                  "text": "IEdgeTarget",
+                  "canonicalReference": "@fgv/ts-agent-memory!IEdgeTarget:interface"
                 },
                 {
                   "kind": "Content",
@@ -9927,7 +10532,7 @@
               "overloadIndex": 1,
               "parameters": [
                 {
-                  "parameterName": "id",
+                  "parameterName": "target",
                   "parameterTypeTokenRange": {
                     "startIndex": 1,
                     "endIndex": 2
@@ -10092,7 +10697,7 @@
             {
               "kind": "Method",
               "canonicalReference": "@fgv/ts-agent-memory!InMemoryCosineIndex#rebuild:member(1)",
-              "docComment": "/**\n * Re-embed every record from `source` and rebuild the index from scratch. Clears the current contents (and the established dimension) first, so a re-embed with a different model is supported. Returns the number of vectors indexed.\n *\n * On any failure (list, embed, or add) the index is rolled back to empty 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.\n *\n * @param source - The record source to re-embed (an {@link IMemoryStore} satisfies this structurally).\n *\n * @param embed - The embedder applied to each record.\n */\n",
+              "docComment": "/**\n * Re-embed every record from `source` and rebuild the index from scratch. Clears the current contents (and the established dimension) first, so a re-embed with a different model is supported. Returns the number of vectors indexed.\n *\n * On any failure (list, embed, or add) the index is rolled back to empty 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.\n *\n * @param source - The scope-qualified record source to re-embed.\n *\n * @param embed - The embedder applied to each record.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -10172,16 +10777,16 @@
             {
               "kind": "Method",
               "canonicalReference": "@fgv/ts-agent-memory!InMemoryCosineIndex#remove:member(1)",
-              "docComment": "/**\n * Remove the embedding for `id`. Returns the removed id. Idempotent — removing an id with no embedding still succeeds (returns the id).\n */\n",
+              "docComment": "/**\n * Remove the embedding for the scope-qualified `target`. Returns the removed target. Idempotent — removing a target with no embedding still succeeds (returns the target).\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
-                  "text": "remove(id: "
+                  "text": "remove(target: "
                 },
                 {
                   "kind": "Reference",
-                  "text": "MemoryId",
-                  "canonicalReference": "@fgv/ts-agent-memory!MemoryId:type"
+                  "text": "IEdgeTarget",
+                  "canonicalReference": "@fgv/ts-agent-memory!IEdgeTarget:interface"
                 },
                 {
                   "kind": "Content",
@@ -10207,8 +10812,8 @@
                 },
                 {
                   "kind": "Reference",
-                  "text": "MemoryId",
-                  "canonicalReference": "@fgv/ts-agent-memory!MemoryId:type"
+                  "text": "IEdgeTarget",
+                  "canonicalReference": "@fgv/ts-agent-memory!IEdgeTarget:interface"
                 },
                 {
                   "kind": "Content",
@@ -10229,7 +10834,7 @@
               "overloadIndex": 1,
               "parameters": [
                 {
-                  "parameterName": "id",
+                  "parameterName": "target",
                   "parameterTypeTokenRange": {
                     "startIndex": 1,
                     "endIndex": 2
@@ -10395,7 +11000,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@fgv/ts-agent-memory!IProvenance#derivedFrom:member",
-              "docComment": "/**\n * Back-link to the source experience record. Enables the cross-kind provenance spine.\n */\n",
+              "docComment": "/**\n * Scope-qualified back-link to the source record. Enables the cross-kind provenance spine. A scope-qualified {@link IEdgeTarget} (not a bare {@link MemoryId}) because per-scope codecs (e.g. the MTM codec's `turn-<n>` stems) legally reuse a stem across scopes, so a bare id would be ambiguous — the same reason {@link IEdge.target} is scope-qualified.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -10403,8 +11008,8 @@
                 },
                 {
                   "kind": "Reference",
-                  "text": "MemoryId",
-                  "canonicalReference": "@fgv/ts-agent-memory!MemoryId:type"
+                  "text": "IEdgeTarget",
+                  "canonicalReference": "@fgv/ts-agent-memory!IEdgeTarget:interface"
                 },
                 {
                   "kind": "Content",
@@ -10524,7 +11129,7 @@
             {
               "kind": "PropertySignature",
               "canonicalReference": "@fgv/ts-agent-memory!IRelationCandidate#id:member",
-              "docComment": "/**\n * Its resolved reference id (codec `idStem` — the stable entity reference).\n */\n",
+              "docComment": "/**\n * Its resolved scope-qualified reference (codec `(scope, idStem)` — the stable entity address).\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -10532,8 +11137,8 @@
                 },
                 {
                   "kind": "Reference",
-                  "text": "MemoryId",
-                  "canonicalReference": "@fgv/ts-agent-memory!MemoryId:type"
+                  "text": "IEdgeTarget",
+                  "canonicalReference": "@fgv/ts-agent-memory!IEdgeTarget:interface"
                 },
                 {
                   "kind": "Content",
@@ -10735,6 +11340,84 @@
           ],
           "extendsTokenRanges": []
         },
+        {
+          "kind": "Interface",
+          "canonicalReference": "@fgv/ts-agent-memory!IScopedMemoryRecord:interface",
+          "docComment": "/**\n * 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.\n *\n * @public\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export interface IScopedMemoryRecord "
+            }
+          ],
+          "fileUrlPath": "src/packlets/vector/vectorIndex.ts",
+          "releaseTag": "Public",
+          "name": "IScopedMemoryRecord",
+          "preserveMemberOrder": false,
+          "members": [
+            {
+              "kind": "PropertySignature",
+              "canonicalReference": "@fgv/ts-agent-memory!IScopedMemoryRecord#record:member",
+              "docComment": "/**\n * The record itself, passed to the embedder.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "readonly record: "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "IMemoryRecord",
+                  "canonicalReference": "@fgv/ts-agent-memory!IMemoryRecord:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": "<unknown>"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isReadonly": true,
+              "isOptional": false,
+              "releaseTag": "Public",
+              "name": "record",
+              "propertyTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 3
+              }
+            },
+            {
+              "kind": "PropertySignature",
+              "canonicalReference": "@fgv/ts-agent-memory!IScopedMemoryRecord#target:member",
+              "docComment": "/**\n * The record's scope-qualified `(scope, id)` address.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "readonly target: "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "IEdgeTarget",
+                  "canonicalReference": "@fgv/ts-agent-memory!IEdgeTarget:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isReadonly": true,
+              "isOptional": false,
+              "releaseTag": "Public",
+              "name": "target",
+              "propertyTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              }
+            }
+          ],
+          "extendsTokenRanges": []
+        },
         {
           "kind": "Interface",
           "canonicalReference": "@fgv/ts-agent-memory!ISemanticBackend:interface",
@@ -11443,16 +12126,16 @@
             {
               "kind": "MethodSignature",
               "canonicalReference": "@fgv/ts-agent-memory!IVectorIndex#add:member(1)",
-              "docComment": "/**\n * 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.\n */\n",
+              "docComment": "/**\n * 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.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
-                  "text": "add(id: "
+                  "text": "add(target: "
                 },
                 {
                   "kind": "Reference",
-                  "text": "MemoryId",
-                  "canonicalReference": "@fgv/ts-agent-memory!MemoryId:type"
+                  "text": "IEdgeTarget",
+                  "canonicalReference": "@fgv/ts-agent-memory!IEdgeTarget:interface"
                 },
                 {
                   "kind": "Content",
@@ -11499,7 +12182,7 @@
               "overloadIndex": 1,
               "parameters": [
                 {
-                  "parameterName": "id",
+                  "parameterName": "target",
                   "parameterTypeTokenRange": {
                     "startIndex": 1,
                     "endIndex": 2
@@ -11614,16 +12297,16 @@
             {
               "kind": "MethodSignature",
               "canonicalReference": "@fgv/ts-agent-memory!IVectorIndex#remove:member(1)",
-              "docComment": "/**\n * Remove the embedding for `id`. Returns the removed id. Idempotent — removing an id with no embedding still succeeds (returns the id).\n */\n",
+              "docComment": "/**\n * Remove the embedding for the scope-qualified `target`. Returns the removed target. Idempotent — removing a target with no embedding still succeeds (returns the target).\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
-                  "text": "remove(id: "
+                  "text": "remove(target: "
                 },
                 {
                   "kind": "Reference",
-                  "text": "MemoryId",
-                  "canonicalReference": "@fgv/ts-agent-memory!MemoryId:type"
+                  "text": "IEdgeTarget",
+                  "canonicalReference": "@fgv/ts-agent-memory!IEdgeTarget:interface"
                 },
                 {
                   "kind": "Content",
@@ -11649,8 +12332,8 @@
                 },
                 {
                   "kind": "Reference",
-                  "text": "MemoryId",
-                  "canonicalReference": "@fgv/ts-agent-memory!MemoryId:type"
+                  "text": "IEdgeTarget",
+                  "canonicalReference": "@fgv/ts-agent-memory!IEdgeTarget:interface"
                 },
                 {
                   "kind": "Content",
@@ -11670,7 +12353,7 @@
               "overloadIndex": 1,
               "parameters": [
                 {
-                  "parameterName": "id",
+                  "parameterName": "target",
                   "parameterTypeTokenRange": {
                     "startIndex": 1,
                     "endIndex": 2
@@ -11686,7 +12369,7 @@
         {
           "kind": "Interface",
           "canonicalReference": "@fgv/ts-agent-memory!IVectorQueryHit:interface",
-          "docComment": "/**\n * 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.\n *\n * @public\n */\n",
+          "docComment": "/**\n * 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.\n *\n * @remarks\n *\n * 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.\n *\n * @public\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -11700,17 +12383,16 @@
           "members": [
             {
               "kind": "PropertySignature",
-              "canonicalReference": "@fgv/ts-agent-memory!IVectorQueryHit#id:member",
-              "docComment": "/**\n * The id of the matched record.\n */\n",
+              "canonicalReference": "@fgv/ts-agent-memory!IVectorQueryHit#score:member",
+              "docComment": "/**\n * Backend similarity score; higher is more similar.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
-                  "text": "readonly id: "
+                  "text": "readonly score: "
                 },
                 {
-                  "kind": "Reference",
-                  "text": "MemoryId",
-                  "canonicalReference": "@fgv/ts-agent-memory!MemoryId:type"
+                  "kind": "Content",
+                  "text": "number"
                 },
                 {
                   "kind": "Content",
@@ -11720,7 +12402,7 @@
               "isReadonly": true,
               "isOptional": false,
               "releaseTag": "Public",
-              "name": "id",
+              "name": "score",
               "propertyTypeTokenRange": {
                 "startIndex": 1,
                 "endIndex": 2
@@ -11728,16 +12410,17 @@
             },
             {
               "kind": "PropertySignature",
-              "canonicalReference": "@fgv/ts-agent-memory!IVectorQueryHit#score:member",
-              "docComment": "/**\n * Backend similarity score; higher is more similar.\n */\n",
+              "canonicalReference": "@fgv/ts-agent-memory!IVectorQueryHit#target:member",
+              "docComment": "/**\n * The scope-qualified address of the matched record.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
-                  "text": "readonly score: "
+                  "text": "readonly target: "
                 },
                 {
-                  "kind": "Content",
-                  "text": "number"
+                  "kind": "Reference",
+                  "text": "IEdgeTarget",
+                  "canonicalReference": "@fgv/ts-agent-memory!IEdgeTarget:interface"
                 },
                 {
                   "kind": "Content",
@@ -11747,7 +12430,7 @@
               "isReadonly": true,
               "isOptional": false,
               "releaseTag": "Public",
-              "name": "score",
+              "name": "target",
               "propertyTypeTokenRange": {
                 "startIndex": 1,
                 "endIndex": 2
@@ -12713,7 +13396,7 @@
         {
           "kind": "Function",
           "canonicalReference": "@fgv/ts-agent-memory!limitRecords:function(1)",
-          "docComment": "/**\n * Truncate to `query.limit` records (a no-op when `limit` is absent). Applied last, after ordering, so it always takes the top-N of the ordered result. A non-positive `limit` is public query input and means \"no records\" — it returns an empty array rather than letting a negative value slip into `slice`.\n *\n * @public\n */\n",
+          "docComment": "/**\n * Apply the `{ offset, limit }` page window to an ordered record set. Applied last, after ordering, so it always takes a stable window of the ordered result. `offset` is applied first (records to skip), then `limit` (top-N of the remainder).\n *\n * @remarks\n *\n * Both bounds are public query input and are guarded against non-positive values slipping into `slice`: - `offset` absent or non-positive → no skip (today's behavior). An offset past the end yields an empty page rather than a throw. - `limit` absent → no truncation; a non-positive `limit` means \"no records\" and returns an empty array.\n *\n * @public\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -12745,6 +13428,14 @@
               "kind": "Content",
               "text": "number"
             },
+            {
+              "kind": "Content",
+              "text": ", offset?: "
+            },
+            {
+              "kind": "Content",
+              "text": "number"
+            },
             {
               "kind": "Content",
               "text": "): "
@@ -12774,8 +13465,8 @@
           ],
           "fileUrlPath": "src/packlets/retrieve/retriever.ts",
           "returnTypeTokenRange": {
-            "startIndex": 8,
-            "endIndex": 12
+            "startIndex": 10,
+            "endIndex": 14
           },
           "releaseTag": "Public",
           "overloadIndex": 1,
@@ -12795,6 +13486,14 @@
                 "endIndex": 7
               },
               "isOptional": true
+            },
+            {
+              "parameterName": "offset",
+              "parameterTypeTokenRange": {
+                "startIndex": 8,
+                "endIndex": 9
+              },
+              "isOptional": true
             }
           ],
           "name": "limitRecords"
@@ -12848,7 +13547,7 @@
         {
           "kind": "Class",
           "canonicalReference": "@fgv/ts-agent-memory!LinkTraversalRetriever:class",
-          "docComment": "/**\n * Breadth-first link-traversal retriever. From a seed {@link MemoryId} it walks the link graph up to `query.hops` levels and returns the records reached (excluding the seed), recency-ordered and limited.\n *\n * @remarks\n *\n * - **Direction.** `linkedFrom` walks OUTBOUND edges (each record's `envelope.links[].target`); `linkedTo` walks INBOUND edges (the index's `backlinks`). Exactly one is the seed; `linkedFrom` wins if both are set. - **Bound + cycle safety.** Traversal is bounded by `hops` (default `1` — a single hop) and a visited-set guard. The graph is keyed by bare string {@link MemoryId}s, so a `Set<string>` visited-set is the exact, collision-free cycle key — no structural hashing (e.g. `Crc32Normalizer`) is needed. A self-loop or any multi-hop cycle terminates because a revisited id is never re-expanded. - **Post-filter.** The scope / kind / tag / predicate axes of the query are applied to the reached records (the link axes are the traversal itself).\n *\n * @public\n */\n",
+          "docComment": "/**\n * Breadth-first link-traversal retriever. From a scope-qualified {@link IEdgeTarget} seed it walks the link graph up to `query.hops` levels and returns the records reached (excluding the seed), recency-ordered and limited.\n *\n * @remarks\n *\n * - **Direction.** `linkedFrom` walks OUTBOUND edges (each record's `envelope.links[].target`); `linkedTo` walks INBOUND edges (the index's `backlinks`). Exactly one is the seed; `linkedFrom` wins if both are set. - **Scope-qualified nodes.** Every graph node is an {@link IEdgeTarget} `(scope, id)` pair, so following an edge to `turn-3` reaches ONLY the record in the edge's own scope — never a same-stem record in another scope. - **Bound + cycle safety.** Traversal is bounded by `hops` (default `1` — a single hop) and a visited-set guard. Nodes are canonicalized to their `(scope, id)` string via {@link edgeTargetKey}, so a `Set<string>` visited-set is the exact, collision-free cycle key — no structural hashing (e.g. `Crc32Normalizer`) is needed. A self-loop or any multi-hop cycle terminates because a revisited node is never re-expanded. - **Post-filter.** The scope / kind / tag / predicate axes of the query are applied to the reached records (the link axes are the traversal itself).\n *\n * @public\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -13707,6 +14406,32 @@
             }
           ]
         },
+        {
+          "kind": "TypeAlias",
+          "canonicalReference": "@fgv/ts-agent-memory!MemoryDetailTier:type",
+          "docComment": "/**\n * The detail tier a `memory_search` / `memory_context` result is projected at. `'gist'` is the default (bounded) path; `'full'` is opt-in. Only meaningful when a host {@link ICreateMemoryToolsParams.projectItem | projectItem} is supplied — the built-in default projection returns the full body regardless.\n *\n * @public\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export type MemoryDetailTier = "
+            },
+            {
+              "kind": "Content",
+              "text": "'gist' | 'full'"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "src/packlets/tools/memoryTools.ts",
+          "releaseTag": "Public",
+          "name": "MemoryDetailTier",
+          "typeTokenRange": {
+            "startIndex": 1,
+            "endIndex": 2
+          }
+        },
         {
           "kind": "TypeAlias",
           "canonicalReference": "@fgv/ts-agent-memory!MemoryEmbedder:type",
@@ -13828,7 +14553,7 @@
             {
               "kind": "Method",
               "canonicalReference": "@fgv/ts-agent-memory!MemoryIndex#backlinks:member(1)",
-              "docComment": "/**\n * The ids of records whose `links` point AT `target` (inbound edges). The seed map for B2 link-traversal.\n */\n",
+              "docComment": "/**\n * The scope-qualified sources of records whose `links` point AT `target` (inbound edges), keyed on the target's `(scope, id)` address. The seed map for B2 link-traversal; results are {@link IEdgeTarget}s so a caller can feed them straight back in as further traversal seeds.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -13836,8 +14561,8 @@
                 },
                 {
                   "kind": "Reference",
-                  "text": "MemoryId",
-                  "canonicalReference": "@fgv/ts-agent-memory!MemoryId:type"
+                  "text": "IEdgeTarget",
+                  "canonicalReference": "@fgv/ts-agent-memory!IEdgeTarget:interface"
                 },
                 {
                   "kind": "Content",
@@ -13854,8 +14579,8 @@
                 },
                 {
                   "kind": "Reference",
-                  "text": "MemoryId",
-                  "canonicalReference": "@fgv/ts-agent-memory!MemoryId:type"
+                  "text": "IEdgeTarget",
+                  "canonicalReference": "@fgv/ts-agent-memory!IEdgeTarget:interface"
                 },
                 {
                   "kind": "Content",
@@ -13951,6 +14676,51 @@
               "isAbstract": false,
               "name": "byKind"
             },
+            {
+              "kind": "Method",
+              "canonicalReference": "@fgv/ts-agent-memory!MemoryIndex#byRank:member(1)",
+              "docComment": "/**\n * All records ordered by store-computed {@link IMemoryEnvelope.rank} descending, with recency (most-recently-updated, then `seq`) as a tiebreak. Records with an absent `rank` sort LAST (after every ranked record), then by recency among themselves. Serves a bounded top-M ({@link IMemoryEnvelope.rank}-ordered) page from the in-memory index with no full-vault (filesystem) scan.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "byRank(): "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "ReadonlyArray",
+                  "canonicalReference": "!ReadonlyArray:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": "<"
+                },
+                {
+                  "kind": "Reference",
+                  "text": "IMemoryRecord",
+                  "canonicalReference": "@fgv/ts-agent-memory!IMemoryRecord:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": "<unknown>>"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isStatic": false,
+              "returnTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 5
+              },
+              "releaseTag": "Public",
+              "isProtected": false,
+              "overloadIndex": 1,
+              "parameters": [],
+              "isOptional": false,
+              "isAbstract": false,
+              "name": "byRank"
+            },
             {
               "kind": "Method",
               "canonicalReference": "@fgv/ts-agent-memory!MemoryIndex#byRecency:member(1)",
@@ -15369,6 +16139,74 @@
             "endIndex": 2
           }
         },
+        {
+          "kind": "Function",
+          "canonicalReference": "@fgv/ts-agent-memory!orderingCompare:function(1)",
+          "docComment": "/**\n * Select the record comparator for a query's {@link IMemoryQuery.orderBy | orderBy} axis: {@link rankCompare} for `'rank'`, {@link recencyCompare} otherwise (the default, byte-identical to the pre-`orderBy` behavior).\n *\n * @public\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export declare function orderingCompare(orderBy?: "
+            },
+            {
+              "kind": "Reference",
+              "text": "IMemoryQuery",
+              "canonicalReference": "@fgv/ts-agent-memory!IMemoryQuery:interface"
+            },
+            {
+              "kind": "Content",
+              "text": "['orderBy']"
+            },
+            {
+              "kind": "Content",
+              "text": "): "
+            },
+            {
+              "kind": "Content",
+              "text": "(a: "
+            },
+            {
+              "kind": "Reference",
+              "text": "IMemoryRecord",
+              "canonicalReference": "@fgv/ts-agent-memory!IMemoryRecord:interface"
+            },
+            {
+              "kind": "Content",
+              "text": "<unknown>, b: "
+            },
+            {
+              "kind": "Reference",
+              "text": "IMemoryRecord",
+              "canonicalReference": "@fgv/ts-agent-memory!IMemoryRecord:interface"
+            },
+            {
+              "kind": "Content",
+              "text": "<unknown>) => number"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "src/packlets/retrieve/retriever.ts",
+          "returnTypeTokenRange": {
+            "startIndex": 4,
+            "endIndex": 9
+          },
+          "releaseTag": "Public",
+          "overloadIndex": 1,
+          "parameters": [
+            {
+              "parameterName": "orderBy",
+              "parameterTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 3
+              },
+              "isOptional": true
+            }
+          ],
+          "name": "orderingCompare"
+        },
         {
           "kind": "Function",
           "canonicalReference": "@fgv/ts-agent-memory!parseMemoryFile:function(1)",
@@ -15561,6 +16399,112 @@
             "endIndex": 8
           }
         },
+        {
+          "kind": "Function",
+          "canonicalReference": "@fgv/ts-agent-memory!rankCompare:function(1)",
+          "docComment": "/**\n * Rank comparator: store-computed {@link IMemoryEnvelope.rank} descending, with {@link recencyCompare} as the tiebreak. Records with an absent `rank` sort LAST (after every ranked record), then by recency among themselves. Mirrors the index's rank-view ordering.\n *\n * @public\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export declare function rankCompare(a: "
+            },
+            {
+              "kind": "Reference",
+              "text": "IMemoryRecord",
+              "canonicalReference": "@fgv/ts-agent-memory!IMemoryRecord:interface"
+            },
+            {
+              "kind": "Content",
+              "text": "<unknown>"
+            },
+            {
+              "kind": "Content",
+              "text": ", b: "
+            },
+            {
+              "kind": "Reference",
+              "text": "IMemoryRecord",
+              "canonicalReference": "@fgv/ts-agent-memory!IMemoryRecord:interface"
+            },
+            {
+              "kind": "Content",
+              "text": "<unknown>"
+            },
+            {
+              "kind": "Content",
+              "text": "): "
+            },
+            {
+              "kind": "Content",
+              "text": "number"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "src/packlets/retrieve/retriever.ts",
+          "returnTypeTokenRange": {
+            "startIndex": 7,
+            "endIndex": 8
+          },
+          "releaseTag": "Public",
+          "overloadIndex": 1,
+          "parameters": [
+            {
+              "parameterName": "a",
+              "parameterTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 3
+              },
+              "isOptional": false
+            },
+            {
+              "parameterName": "b",
+              "parameterTypeTokenRange": {
+                "startIndex": 4,
+                "endIndex": 6
+              },
+              "isOptional": false
+            }
+          ],
+          "name": "rankCompare"
+        },
+        {
+          "kind": "TypeAlias",
+          "canonicalReference": "@fgv/ts-agent-memory!RankProjector:type",
+          "docComment": "/**\n * A per-kind host projection from a fully-resolved (post-merge) memory record to a numeric ordering value. Registered per kind at store construction (see `rankProjectors`); the store runs it on every put/update over the same resolved record whose `contentHash` it computes, stamping the result into {@link IMemoryEnvelope.rank}. The store never interprets the body — the host owns what the number means. A projector that throws is treated as \"no rank for this record\" (logged at `warn`), never failing the write.\n *\n * @public\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export type RankProjector = "
+            },
+            {
+              "kind": "Content",
+              "text": "(record: "
+            },
+            {
+              "kind": "Reference",
+              "text": "IMemoryRecord",
+              "canonicalReference": "@fgv/ts-agent-memory!IMemoryRecord:interface"
+            },
+            {
+              "kind": "Content",
+              "text": "<unknown>) => number"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "src/packlets/types/envelope.ts",
+          "releaseTag": "Public",
+          "name": "RankProjector",
+          "typeTokenRange": {
+            "startIndex": 1,
+            "endIndex": 4
+          }
+        },
         {
           "kind": "Function",
           "canonicalReference": "@fgv/ts-agent-memory!recencyCompare:function(1)",
@@ -15843,7 +16787,7 @@
         {
           "kind": "TypeAlias",
           "canonicalReference": "@fgv/ts-agent-memory!ResolutionVerdict:type",
-          "docComment": "/**\n * The four dedup verdicts a {@link IEntityResolver} (or fgv's exact-match layer) returns for a candidate. See the design note §3 for the verdict → write disposition mapping.\n *\n * @public\n */\n",
+          "docComment": "/**\n * The four dedup verdicts a {@link IEntityResolver} (or fgv's exact-match layer) returns for a candidate. See the design note §3 for the verdict → write disposition mapping. Each target-bearing arm carries a scope-qualified {@link IEdgeTarget} (not a bare {@link MemoryId}) so the verdict resolves to a single record even when a filename stem is reused across scopes.\n *\n * @public\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -15855,8 +16799,8 @@
             },
             {
               "kind": "Reference",
-              "text": "MemoryId",
-              "canonicalReference": "@fgv/ts-agent-memory!MemoryId:type"
+              "text": "IEdgeTarget",
+              "canonicalReference": "@fgv/ts-agent-memory!IEdgeTarget:interface"
             },
             {
               "kind": "Content",
@@ -15864,8 +16808,8 @@
             },
             {
               "kind": "Reference",
-              "text": "MemoryId",
-              "canonicalReference": "@fgv/ts-agent-memory!MemoryId:type"
+              "text": "IEdgeTarget",
+              "canonicalReference": "@fgv/ts-agent-memory!IEdgeTarget:interface"
             },
             {
               "kind": "Content",
@@ -15873,8 +16817,8 @@
             },
             {
               "kind": "Reference",
-              "text": "MemoryId",
-              "canonicalReference": "@fgv/ts-agent-memory!MemoryId:type"
+              "text": "IEdgeTarget",
+              "canonicalReference": "@fgv/ts-agent-memory!IEdgeTarget:interface"
             },
             {
               "kind": "Content",