@remnic/core 9.63.7 → 9.63.9

package/src/access-recall-response.ts

@@ -15,7 +15,7 @@ import { type BudgetDecision, toBudgetWarning } from "./cross-namespace-budget.j
 import { decideDisclosureEscalation } from "./recall-disclosure-escalation.js";
 import { type TagMatchMode, applyTagFilter, normalizeTags, parseTagMatch } from "./recall-tag-filter.js";
 import type { RecallDisclosure, RecallPlanMode } from "./types.js";
-import { displaySafeBudgetsApplied, displaySafeRecallSnapshot } from "./orchestration/recall-result-formatter.js";
+import { displaySafeRecallSnapshot } from "./orchestration/recall-result-formatter.js";
 import {
   boundRecallContextComposition,
   composeRecallContext,
@@ -305,7 +305,9 @@ export async function assembleRecallResponse(
       fallbackUsed: snapshot?.fallbackUsed ?? false,
       sourcesUsed: snapshot?.sourcesUsed ?? [],
       disclosure,
-      budgetsApplied: displaySafeBudgetsApplied(snapshot?.budgetsApplied, deps.orchestrator.config.memoryDir),
+      budgetsApplied: snapshot
+        ? displaySafeRecallSnapshot(snapshot, deps.orchestrator.config.memoryDir).budgetsApplied
+        : undefined,
       auditAnomalies,
       budgetWarning: toBudgetWarning(budgetDecision),
       latencyMs: snapshot?.latencyMs ?? (Date.now() - startedAt),

package/src/access-recall-surface.ts

@@ -26,7 +26,7 @@ import { expandScopeProfileReadNamespaces, resolveScopeProfilePlan } from "./nam
 import type { Orchestrator, RecallInvocationOptions } from "./orchestrator.js";
 import { decideDisclosureEscalation } from "./recall-disclosure-escalation.js";
 import { assembleRecallResponse } from "./access-recall-response.js";
-import type { LastRecallSnapshot } from "./recall-state.js";
+import { coerceIncludedMemories, type LastRecallSnapshot } from "./recall-state.js";
 import type { RecallContextComposition } from "./recall-context-composition.js";
 import { type TagMatchMode, applyTagFilter, normalizeTags, parseTagMatch } from "./recall-tag-filter.js";
 import { type RecallXraySnapshot, estimateRecallTokens } from "./recall-xray.js";
@@ -44,7 +44,6 @@ import {
 // Canonical copies (access-service.ts still carries private duplicates for
 // its remaining callers; dedupe tracked separately).
 import { qmdCollectionPathParts, qmdResultPathCandidates } from "./orchestration/qmd-result-resolver.js";
-
 export interface AccessRecallSurfaceDeps {
   readonly auditAdapter: AccessAuditAdapter | null;
   readonly budget: CrossNamespaceBudget;
@@ -214,7 +213,10 @@ export class AccessRecallSurface {
     rawExcerptsSuppressed?: boolean;
   }): Promise<EngramAccessRecallResponse> {
     const memoryIds = options.snapshot.results.map((result) => result.memoryId);
-    const resultPaths = options.snapshot.results.map((result) => result.path);
+    const includedMemories = options.snapshot.results.map((result) => ({
+      id: result.memoryId,
+      path: result.path,
+    }));
     const namespace = options.snapshot.namespace
       ? this.deps.resolveNamespace(options.snapshot.namespace)
       : this.deps.orchestrator.config.defaultNamespace;
@@ -243,7 +245,7 @@ export class AccessRecallSurface {
         finalContextChars: options.snapshot.budget.used,
       },
       latencyMs: Date.now() - options.startedAt,
-      resultPaths,
+      includedMemories,
     };
     const results = await this.deps.serializeRecallResults(
       snapshotForSerialization,
@@ -515,12 +517,10 @@ export class AccessRecallSurface {
               : null,
           );
     const rawExcerpts = rawExcerptsResult ?? undefined;
-
-    const resultNamespaces = snapshot.resultNamespaces ?? [];
-    for (let index = 0; index < (snapshot.resultPaths ?? []).length; index += 1) {
-      const memoryPath = snapshot.resultPaths?.[index];
-      const memoryNamespace = resultNamespaces[index];
+    for (const included of coerceIncludedMemories(snapshot)) {
+      const memoryPath = included.path;
       if (!memoryPath) continue;
+      const memoryNamespace = included.namespace;
       const seenKey = `${memoryNamespace ?? ""}\0${memoryPath}`;
       if (seen.has(seenKey)) continue;
       const resolved = await readResultPath(memoryPath, memoryNamespace);

package/src/access-service-namespace.test.ts

@@ -259,7 +259,7 @@ test("last recall serialization resolves namespace collection-prefixed result pa
       queryLen: 4,
       memoryIds: [],
       namespace: "default",
-      resultPaths: [`${collection}/archive/facts/2026-06-16/fact-001.md`],
+      includedMemories: [{ id: "", path: `${collection}/archive/facts/2026-06-16/fact-001.md` }],
     },
     "summary",
   );
@@ -355,7 +355,7 @@ test("last recall serialization does not fall back after namespace collection mi
       queryLen: 4,
       memoryIds: [],
       namespace: "default",
-      resultPaths: [`${collection}/2026-06-16/fact-001.md`],
+      includedMemories: [{ id: "", path: `${collection}/2026-06-16/fact-001.md` }],
     },
     "summary",
   );
@@ -428,7 +428,7 @@ test("last recall serialization resolves cold collection paths through snapshot
       queryLen: 4,
       memoryIds: [],
       namespace: "default",
-      resultPaths: ["test-memory-cold/facts/2026-06-16/fact-001.md"],
+      includedMemories: [{ id: "", path: "test-memory-cold/facts/2026-06-16/fact-001.md" }],
     },
     "summary",
   );
@@ -503,7 +503,7 @@ test("last recall serialization propagates locked namespace collection errors",
           queryLen: 4,
           memoryIds: [],
           namespace: "default",
-          resultPaths: [`${collection}/2026-06-16/fact-001.md`],
+          includedMemories: [{ id: "", path: `${collection}/2026-06-16/fact-001.md` }],
         },
         "summary",
       ),
@@ -563,7 +563,7 @@ test("last recall serialization does not treat date paths as collection prefixes
       queryLen: 4,
       memoryIds: [],
       namespace: "default",
-      resultPaths: ["2026-06-16/fact-001.md"],
+      includedMemories: [{ id: "", path: "2026-06-16/fact-001.md" }],
     },
     "summary",
   );
@@ -632,7 +632,7 @@ test("last recall serialization does not strip invalid collection prefixes", asy
       queryLen: 4,
       memoryIds: [],
       namespace: "default",
-      resultPaths: ["test-memory--not-a-token/2026-06-16/fact-001.md"],
+      includedMemories: [{ id: "", path: "test-memory--not-a-token/2026-06-16/fact-001.md" }],
     },
     "summary",
   );
@@ -733,7 +733,7 @@ test("last recall serialization preserves absolute paths from readable namespace
       queryLen: 4,
       memoryIds: [],
       namespace: "team",
-      resultPaths: [sharedMemoryPath],
+      includedMemories: [{ id: "", path: sharedMemoryPath }],
     },
     "summary",
   );
@@ -817,7 +817,7 @@ test("last recall serialization preserves absolute paths from dynamic namespace
       queryLen: 4,
       memoryIds: [],
       namespace: "team",
-      resultPaths: [dynamicMemoryPath],
+      includedMemories: [{ id: "", path: dynamicMemoryPath }],
     },
     "summary",
   );
@@ -905,7 +905,7 @@ test("last recall serialization rejects traversing collection paths", async () =
       queryLen: 4,
       memoryIds: [],
       namespace: "default",
-      resultPaths: [`${collection}/../../facts/2026-06-16/fact-001.md`],
+      includedMemories: [{ id: "", path: `${collection}/../../facts/2026-06-16/fact-001.md` }],
     },
     "summary",
   );

package/src/access-service-raw-excerpt-read-gate.test.ts

@@ -92,7 +92,7 @@ function makeRawExcerptProbe(options: {
     memoryIds: [],
     namespace: options.snapshotNamespace,
     recallNamespaces: [options.snapshotNamespace],
-    resultPaths: [],
+    includedMemories: [],
   };
 
   const storage = {

package/src/included-memories.ts

@@ -0,0 +1,88 @@
+export interface IncludedMemory {
+  id: string;
+  path: string;
+  namespace?: string;
+}
+
+type LegacyIncludedMemorySource = {
+  includedMemories?: unknown;
+  memoryIds?: unknown;
+  resultPaths?: unknown;
+  resultNamespaces?: unknown;
+  budgetsApplied?: unknown;
+};
+
+function legacyBudgetView(raw: LegacyIncludedMemorySource): {
+  includedMemoryIds?: unknown;
+  includedMemoryPaths?: unknown;
+  includedMemoryNamespaces?: unknown;
+} {
+  const budgets = raw.budgetsApplied;
+  if (!budgets || typeof budgets !== "object") return {};
+  const record = budgets as Record<string, unknown>;
+  return {
+    includedMemoryIds: record.includedMemoryIds,
+    includedMemoryPaths: record.includedMemoryPaths,
+    includedMemoryNamespaces: record.includedMemoryNamespaces,
+  };
+}
+
+function asStringList(value: unknown): string[] {
+  return Array.isArray(value) ? value.map((item) => (typeof item === "string" ? item : "")) : [];
+}
+
+function asOptionalStringList(value: unknown): Array<string | undefined> {
+  return Array.isArray(value)
+    ? value.map((item) => (typeof item === "string" ? item : undefined))
+    : [];
+}
+
+function normalizeIncludedMemory(value: unknown): IncludedMemory | undefined {
+  if (!value || typeof value !== "object") return undefined;
+  const record = value as { id?: unknown; path?: unknown; namespace?: unknown };
+  const id = typeof record.id === "string" ? record.id : "";
+  const path = typeof record.path === "string" ? record.path : "";
+  if (!id && !path) return undefined;
+  const namespace = typeof record.namespace === "string" ? record.namespace : undefined;
+  return namespace ? { id, path, namespace } : { id, path };
+}
+
+export function coerceIncludedMemories(raw: object): IncludedMemory[] {
+  const source = raw as LegacyIncludedMemorySource;
+  if (Array.isArray(source.includedMemories)) {
+    return source.includedMemories
+      .map(normalizeIncludedMemory)
+      .filter((item): item is IncludedMemory => item !== undefined);
+  }
+
+  const budgets = legacyBudgetView(source);
+  const ids = asStringList(source.memoryIds ?? budgets.includedMemoryIds);
+  const paths = asStringList(source.resultPaths ?? budgets.includedMemoryPaths);
+  const namespaces = asOptionalStringList(
+    source.resultNamespaces ?? budgets.includedMemoryNamespaces,
+  );
+  const count = Math.max(ids.length, paths.length);
+  const memories: IncludedMemory[] = [];
+  for (let index = 0; index < count; index += 1) {
+    const id = ids[index] ?? "";
+    const path = paths[index] ?? "";
+    if (!id && !path) continue;
+    const namespace = namespaces[index];
+    memories.push(namespace ? { id, path, namespace } : { id, path });
+  }
+  return memories;
+}
+
+export function includedMemoryIds(memories: readonly IncludedMemory[]): string[] {
+  return memories.map((memory) => memory.id);
+}
+
+export function includedMemoryPaths(memories: readonly IncludedMemory[]): string[] {
+  return memories.map((memory) => memory.path);
+}
+
+export function includedMemoryNamespaces(
+  memories: readonly IncludedMemory[],
+): Array<string | undefined> {
+  return memories.map((memory) => memory.namespace);
+}

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

@@ -20,7 +20,7 @@ import type { ObjectiveStateSearchResult } from "../objective-state.js";
 import type { IntentDebugSnapshot, QmdRecallSnapshot, QueryAwarePrefilter } from "../orchestrator.js";
 import type { CorpusReadOptions } from "../corpus-read-cancellation.js";
 import type { ProfilingCollector } from "../profiling.js";
-import type { GraphRecallExpandedEntry, LastRecallBudgetSummary, LastRecallStore, RecallHandleHistoryStore } from "../recall-state.js";
+import type { GraphRecallExpandedEntry, IncludedMemory, LastRecallBudgetSummary, LastRecallStore, RecallHandleHistoryStore } from "../recall-state.js";
 import type { RecallXraySnapshot } from "../recall-xray.js";
 import type { RerankCache } from "../rerank.js";
 import type { SearchBackend, SearchDegradation, SearchQueryOptions } from "../search/port.js";
@@ -115,6 +115,7 @@ export interface RecallInternalDeps {
     omittedIds: string[];
     truncated: boolean;
     finalChars: number;
+    includedMemories: IncludedMemory[];
     includedMemoryIds: string[];
     includedMemoryPaths: string[];
     includedMemoryNamespaces: Array<string | undefined>;
@@ -168,9 +169,6 @@ export interface RecallInternalDeps {
     truncated?: boolean;
     includedSections?: string[];
     omittedSections?: string[];
-    includedMemoryIds?: string[];
-    includedMemoryPaths?: string[];
-    includedMemoryNamespaces?: Array<string | undefined>;
     omittedMemoryIds?: string[];
   }): LastRecallBudgetSummary;
   buildQueryAwarePrefilter(

package/src/orchestration/recall-internal.ts

@@ -622,7 +622,7 @@ export class RecallInternalCoordinator {
               qmdHybridFetchLimit,
             }),
             latencyMs: Date.now() - recallStart,
-            resultPaths: [],
+            includedMemories: [],
             policyVersion,
             appendImpression: this.deps.config.recordEmptyRecallImpressions,
             identityInjection: {
@@ -4944,14 +4944,14 @@ export class RecallInternalCoordinator {
     const assembledRecall = this.deps.assembleRecallSections(
       sectionBuckets, contextBudgetForFooter(recallBudgetChars, curiosityFooter),
     );
-    recalledMemoryIds = assembledRecall.includedMemoryIds;
-    recalledMemoryPaths = assembledRecall.includedMemoryPaths;
-    recalledMemoryNamespaces = assembledRecall.includedMemoryNamespaces;
-    recalledMemoryCount = assembledRecall.includedMemoryIds.length;
+    recalledMemoryIds = assembledRecall.includedMemories.map((memory) => memory.id);
+    recalledMemoryPaths = assembledRecall.includedMemories.map((memory) => memory.path);
+    recalledMemoryNamespaces = assembledRecall.includedMemories.map((memory) => memory.namespace);
+    recalledMemoryCount = assembledRecall.includedMemories.length;
     this.deps.trackMemoryAccess(
-      assembledRecall.includedMemoryIds,
-      assembledRecall.includedMemoryPaths,
-      assembledRecall.includedMemoryNamespaces,
+      recalledMemoryIds,
+      recalledMemoryPaths,
+      recalledMemoryNamespaces,
     );
     const recalledContext = assembledRecall.sections.join("\n\n---\n\n");
     const composition = boundRecallContextComposition({
@@ -4987,9 +4987,6 @@ export class RecallInternalCoordinator {
       truncated: assembledRecall.truncated || compositionTruncated || curiosityFooterTruncated,
       includedSections,
       omittedSections,
-      includedMemoryIds: assembledRecall.includedMemoryIds,
-      includedMemoryPaths: assembledRecall.includedMemoryPaths,
-      includedMemoryNamespaces: assembledRecall.includedMemoryNamespaces,
       omittedMemoryIds: assembledRecall.omittedMemoryIds,
     });
     // X-ray capture (issue #570 PR 1).  Only fires when the caller
@@ -5241,8 +5238,7 @@ export class RecallInternalCoordinator {
           sourcesUsed,
           budgetsApplied,
           latencyMs: Date.now() - recallStart,
-          resultPaths: recalledMemoryPaths,
-          resultNamespaces: recalledMemoryNamespaces,
+          includedMemories: assembledRecall.includedMemories,
           policyVersion,
           appendImpression:
             recalledMemoryIds.length > 0 ||

package/src/orchestration/recall-result-formatter-display-safe.test.ts

@@ -2,19 +2,17 @@ import test from "node:test";
 import assert from "node:assert/strict";
 import { displaySafeRecallSnapshot } from "./recall-result-formatter.js";
 
-test("displaySafeRecallSnapshot relativizes result, budget, and tier-anchor paths without mutating input (#2077)", () => {
+test("displaySafeRecallSnapshot relativizes included-memory and tier-anchor paths without mutating input (#2077)", () => {
   const memoryDir = "/srv/memory";
   const flatAbs = `${memoryDir}/facts/2026-07-19/b.md`;
   const nsResultAbs = `${memoryDir}/namespaces/tok-team/facts/2026-07-19/r.md`;
-  // An anchor that is NOT among the returned results — no authoritative owner.
+  // An anchor that is NOT among the included memories — no authoritative owner.
   const unmatchedAnchorAbs = `${memoryDir}/namespaces/ns-616c706861/facts/2026-07-19/a.md`;
   const snapshot = {
-    resultPaths: [flatAbs, nsResultAbs],
-    resultNamespaces: [undefined, "team-alpha"],
-    budgetsApplied: {
-      includedMemoryPaths: [flatAbs, nsResultAbs],
-      includedMemoryNamespaces: [undefined, "team-alpha"],
-    },
+    includedMemories: [
+      { id: "mem-b", path: flatAbs },
+      { id: "mem-r", path: nsResultAbs, namespace: "team-alpha" },
+    ],
     tierExplain: {
       tier: "direct-answer",
       tierReason: "single high-confidence hit",
@@ -31,21 +29,20 @@ test("displaySafeRecallSnapshot relativizes result, budget, and tier-anchor path
 
   const safe = displaySafeRecallSnapshot(snapshot, memoryDir);
 
-  assert.deepEqual(safe.resultPaths, ["facts/2026-07-19/b.md", "team-alpha/facts/2026-07-19/r.md"]);
-  assert.deepEqual(safe.budgetsApplied.includedMemoryPaths, [
-    "facts/2026-07-19/b.md",
-    "team-alpha/facts/2026-07-19/r.md",
+  assert.deepEqual(safe.includedMemories, [
+    { id: "mem-b", path: "facts/2026-07-19/b.md" },
+    { id: "mem-r", path: "team-alpha/facts/2026-07-19/r.md", namespace: "team-alpha" },
   ]);
   assert.deepEqual(safe.tierExplain.sourceAnchors, [
-    // Anchor coincides with a namespaced result → reuses its authoritative namespace.
+    // Anchor coincides with a namespaced included memory → reuses its authoritative namespace.
     { path: "team-alpha/facts/2026-07-19/r.md", lineRange: [1, 2] },
-    // Anchor not among the results → truthful storage-relative segment, never a decode.
+    // Anchor not among the included memories → truthful storage-relative segment, never a decode.
     { path: "namespaces/ns-616c706861/facts/2026-07-19/a.md" },
-    // Anchor coincides with a default-namespace result → memoryDir-relative.
+    // Anchor coincides with a default-namespace included memory → memoryDir-relative.
     { path: "facts/2026-07-19/b.md" },
   ]);
 
   // The input snapshot must not be mutated — the live cache keeps absolute paths.
   assert.equal(snapshot.tierExplain.sourceAnchors[0].path, nsResultAbs);
-  assert.equal(snapshot.resultPaths[1], nsResultAbs);
+  assert.equal(snapshot.includedMemories[1].path, nsResultAbs);
 });

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

@@ -33,6 +33,7 @@ import type { WorkProductLedgerSearchResult } from "../work-product-ledger.js";
 import { trustResultFor, type TrustStageResultItem } from "../trust-score-stage.js";
 import { CONNECTOR_ID_PATTERN, CONNECTOR_LABEL_MAX_LENGTH } from "../connectors/label.js";
 import { isValidConnectorId } from "../connectors/index.js";
+import { coerceIncludedMemories, type IncludedMemory } from "../included-memories.js";
 import type {
   ContinuityIncidentRecord,
   IdentityInjectionMode,
@@ -112,43 +113,26 @@ export function displayResultPath(
     : resultPath;
 }
 
-/**
- * Return a copy of budget metadata with `includedMemoryPaths` rendered
- * memoryDir-relative, so recall/last-recall API callers never receive operator
- * filesystem paths via budget output even though the internal snapshot keeps
- * absolute paths for tracking/x-ray (#2020). Other fields are unchanged.
- */
-export function displaySafeBudgetsApplied<
-  T extends {
-    includedMemoryPaths?: string[];
-    includedMemoryNamespaces?: Array<string | undefined>;
-  },
->(budgetsApplied: T | undefined, memoryDir: string): T | undefined {
-  if (!budgetsApplied?.includedMemoryPaths) return budgetsApplied;
-  return {
-    ...budgetsApplied,
-    includedMemoryPaths: budgetsApplied.includedMemoryPaths.map((p, i) =>
-      displayResultPath(p, memoryDir, budgetsApplied.includedMemoryNamespaces?.[i]),
-    ),
-  };
-}
-
 /**
  * Return a display-safe copy of a recall snapshot for the `includeDebug=true`
- * surface (#2077). `resultPaths` and `budgetsApplied.includedMemoryPaths` are
- * rendered namespace-relative from their aligned namespace metadata; a
- * `tierExplain.sourceAnchors[]` entry reuses that SAME authoritative metadata
- * when its absolute path matches a result/included path, and otherwise falls
- * back to the memoryDir-relative on-disk form. Either way the debug flag never
- * leaks absolute operator paths, and an anchor is never attributed to a decoded
- * (guessed) namespace — an anchor carries no owner of its own. Returns a
- * shallow copy; the input snapshot is never mutated.
+ * surface (#2077). `includedMemories[].path` is rendered namespace-relative
+ * from each memory's own namespace — the same rendering `resultPaths` received
+ * before the struct consolidation; a `tierExplain.sourceAnchors[]` entry
+ * reuses that SAME authoritative metadata when its absolute path matches an
+ * included memory's path, and otherwise falls back to the memoryDir-relative
+ * on-disk form. Either way the debug flag never leaks absolute operator
+ * paths, and an anchor is never attributed to a decoded (guessed) namespace —
+ * an anchor carries no owner of its own. Returns a shallow copy; the input
+ * snapshot is never mutated.
  */
 export function displaySafeRecallSnapshot<
   T extends {
+    includedMemories?: IncludedMemory[];
+    memoryIds?: string[];
     resultPaths?: string[];
     resultNamespaces?: Array<string | undefined>;
     budgetsApplied?: {
+      includedMemoryIds?: string[];
       includedMemoryPaths?: string[];
       includedMemoryNamespaces?: Array<string | undefined>;
     };
@@ -157,21 +141,14 @@ export function displaySafeRecallSnapshot<
     };
   },
 >(snapshot: T, memoryDir: string): T {
-  const resultPaths = snapshot.resultPaths?.map((p, i) =>
-    displayResultPath(p, memoryDir, snapshot.resultNamespaces?.[i]),
-  );
-  // Authoritative absolute-path -> namespace map recorded at capture time, so a
-  // tier anchor that coincides with a returned result renders under the SAME
-  // namespace as that result instead of the raw storage segment (#2077).
+  const includedMemories = coerceIncludedMemories(snapshot).map((memory) => ({
+    ...memory,
+    path: displayResultPath(memory.path, memoryDir, memory.namespace),
+  }));
   const namespaceByPath = new Map<string, string | undefined>();
-  snapshot.resultPaths?.forEach((p, i) => {
-    if (!namespaceByPath.has(p)) namespaceByPath.set(p, snapshot.resultNamespaces?.[i]);
-  });
-  snapshot.budgetsApplied?.includedMemoryPaths?.forEach((p, i) => {
-    if (!namespaceByPath.has(p)) {
-      namespaceByPath.set(p, snapshot.budgetsApplied?.includedMemoryNamespaces?.[i]);
-    }
-  });
+  for (const memory of coerceIncludedMemories(snapshot)) {
+    if (!namespaceByPath.has(memory.path)) namespaceByPath.set(memory.path, memory.namespace);
+  }
   const tierExplain =
     snapshot.tierExplain?.sourceAnchors
       ? {
@@ -182,11 +159,21 @@ export function displaySafeRecallSnapshot<
           })),
         }
       : undefined;
+  const resultPaths = includedMemories.map((memory) => memory.path);
+  const resultNamespaces = includedMemories.map((memory) => memory.namespace);
   return {
     ...snapshot,
-    ...(resultPaths ? { resultPaths } : {}),
+    includedMemories,
+    resultPaths,
+    resultNamespaces,
     ...(snapshot.budgetsApplied
-      ? { budgetsApplied: displaySafeBudgetsApplied(snapshot.budgetsApplied, memoryDir) }
+      ? {
+          budgetsApplied: {
+            ...snapshot.budgetsApplied,
+            includedMemoryPaths: resultPaths,
+            includedMemoryNamespaces: resultNamespaces,
+          },
+        }
       : {}),
     ...(tierExplain ? { tierExplain } : {}),
   };

package/src/orchestration/recall-section-coordinator.ts

@@ -17,7 +17,7 @@
  * TierMigrationCoordinator accessor pattern.
  */
 
-import type { LastRecallBudgetSummary } from "../recall-state.js";
+import type { IncludedMemory, LastRecallBudgetSummary } from "../recall-state.js";
 import { estimateTokenCount } from "../token-estimate.js";
 import { graphemeUnits, truncateGraphemeSafe } from "../whitespace.js";
 import type { PluginConfig, RecallSectionConfig } from "../types.js";
@@ -273,6 +273,7 @@ export class RecallSectionCoordinator {
     omittedIds: string[];
     truncated: boolean;
     finalChars: number;
+    includedMemories: IncludedMemory[];
     includedMemoryIds: string[];
     includedMemoryPaths: string[];
     includedMemoryNamespaces: Array<string | undefined>;
@@ -340,6 +341,7 @@ export class RecallSectionCoordinator {
         omittedIds: orderedSections.map((entry) => entry.id),
         truncated: orderedSections.length > 0,
         finalChars: 0,
+        includedMemories: [],
         includedMemoryIds: [],
         includedMemoryPaths: [],
         includedMemoryNamespaces: [],
@@ -372,9 +374,7 @@ export class RecallSectionCoordinator {
         break;
       }
     }
-    const includedMemoryIds: string[] = [];
-    const includedMemoryPaths: string[] = [];
-    const includedMemoryNamespaces: Array<string | undefined> = [];
+    const includedMemories: IncludedMemory[] = [];
     let usedChars = 0;
     let usedTokens = 0;
     let truncated = false;
@@ -492,12 +492,12 @@ export class RecallSectionCoordinator {
               rendered = chunk.content;
               includedLeadingContent = false;
               includedAtomicCount = 1;
-              // Push id/path/namespace together so the parallel tracking arrays
-              // never misalign when a chunk carries only one of them (#2020).
               if (chunk.memoryId && chunk.memoryPath) {
-                includedMemoryIds.push(chunk.memoryId);
-                includedMemoryPaths.push(chunk.memoryPath);
-                includedMemoryNamespaces.push(chunk.memoryNamespace);
+                includedMemories.push(
+                  chunk.memoryNamespace
+                    ? { id: chunk.memoryId, path: chunk.memoryPath, namespace: chunk.memoryNamespace }
+                    : { id: chunk.memoryId, path: chunk.memoryPath },
+                );
               }
               continue;
             }
@@ -522,9 +522,11 @@ export class RecallSectionCoordinator {
           if (chunk.atomic) {
             includedAtomicCount += 1;
             if (chunk.memoryId && chunk.memoryPath) {
-              includedMemoryIds.push(chunk.memoryId);
-              includedMemoryPaths.push(chunk.memoryPath);
-              includedMemoryNamespaces.push(chunk.memoryNamespace);
+              includedMemories.push(
+                chunk.memoryNamespace
+                  ? { id: chunk.memoryId, path: chunk.memoryPath, namespace: chunk.memoryNamespace }
+                  : { id: chunk.memoryId, path: chunk.memoryPath },
+              );
             }
           } else {
             includedPostAtomicContent = true;
@@ -574,16 +576,14 @@ export class RecallSectionCoordinator {
       omittedIds,
       truncated,
       finalChars: usedChars,
-      includedMemoryIds,
-      includedMemoryPaths,
-      includedMemoryNamespaces,
+      includedMemories,
+      includedMemoryIds: includedMemories.map((memory) => memory.id),
+      includedMemoryPaths: includedMemories.map((memory) => memory.path),
+      includedMemoryNamespaces: includedMemories.map((memory) => memory.namespace),
       omittedMemoryIds: (() => {
-        // Key by (namespace, id): the same memory id can exist in more than one
-        // namespace, so an id-only subtraction would hide a budget-dropped copy
-        // when another namespace's copy was included (#2020).
         const includedKeys = new Set(
-          includedMemoryIds.map(
-            (id, i) => `${includedMemoryNamespaces[i] ?? ""}\u0000${id}`,
+          includedMemories.map(
+            (memory) => `${memory.namespace ?? ""}\u0000${memory.id}`,
           ),
         );
         return candidateMemoryChunks
@@ -604,9 +604,6 @@ export class RecallSectionCoordinator {
     finalContextChars?: number;
     truncated?: boolean;
     includedSections?: string[];
-    includedMemoryIds?: string[];
-    includedMemoryPaths?: string[];
-    includedMemoryNamespaces?: Array<string | undefined>;
     omittedMemoryIds?: string[];
     omittedSections?: string[];
   }): LastRecallBudgetSummary {
@@ -619,9 +616,6 @@ export class RecallSectionCoordinator {
       qmdHybridFetchLimit: options.qmdHybridFetchLimit,
       finalContextChars: options.finalContextChars,
       truncated: options.truncated,
-      includedMemoryIds: [...(options.includedMemoryIds ?? [])],
-      includedMemoryPaths: [...(options.includedMemoryPaths ?? [])],
-      includedMemoryNamespaces: [...(options.includedMemoryNamespaces ?? [])],
       omittedMemoryIds: [...(options.omittedMemoryIds ?? [])],
       includedSections: [...(options.includedSections ?? [])],
       omittedSections: [...(options.omittedSections ?? [])],

package/src/orchestrator.ts

@@ -260,6 +260,7 @@ import { NegativeExampleStore } from "./negative.js";
 import {
   LastRecallStore,
   RecallHandleHistoryStore,
+  type IncludedMemory,
   type LastRecallBudgetSummary,
   TierMigrationStatusStore,
   clampGraphRecallExpandedEntries,
@@ -2716,7 +2717,7 @@ export class Orchestrator {
     includedIds: string[];
     omittedIds: string[];
     truncated: boolean;
-    finalChars: number;
+    includedMemories: IncludedMemory[];
     includedMemoryIds: string[];
     includedMemoryPaths: string[];
     includedMemoryNamespaces: Array<string | undefined>;
@@ -3542,9 +3543,6 @@ export class Orchestrator {
     finalContextChars?: number;
     truncated?: boolean;
     includedSections?: string[];
-    includedMemoryIds?: string[];
-    includedMemoryPaths?: string[];
-    includedMemoryNamespaces?: Array<string | undefined>;
     omittedMemoryIds?: string[];
     omittedSections?: string[];
   }): LastRecallBudgetSummary {

package/src/recall-explain-renderer.test.ts

@@ -17,6 +17,10 @@ function legacySnapshot(
     queryHash: "deadbeef",
     queryLen: 21,
     memoryIds: ["mem-1", "mem-2"],
+    includedMemories: [
+      { id: "mem-1", path: "" },
+      { id: "mem-2", path: "" },
+    ],
     source: "hot_qmd",
     sourcesUsed: ["hot_qmd", "memories"],
     namespace: "workspace-a",