@ngockhoale/ukit 3.0.12 → 3.1.1

package/src/core/memory/migrate.js

@@ -13,7 +13,7 @@ import { readJsonIfExists, writeJson } from '../fileOps.js';
 import { loadRuntimeConfig } from '../runtimeConfig.js';
 import { mapLegacySources } from './migrateMapping.js';
 import { readRecordStore } from './recordStore.js';
-import { lookupRegisteredProjectId } from './projectIdentity.js';
+import { lookupRegisteredProjectId, resolveProjectIdentity } from './projectIdentity.js';
 
 const MARKER_NAME = 'migrated-from-v1.json';
 const DAY_MS = 24 * 60 * 60 * 1000;
@@ -123,8 +123,8 @@ function hasLegacyContent(sources) {
     || sources.sessions.length > 0 || sources.corruptFiles > 0;
 }
 
-async function episodeTtlMsFor(projectRoot) {
-  const config = await loadRuntimeConfig(projectRoot);
+async function episodeTtlMsFor(projectRoot, { homeDir } = {}) {
+  const config = await loadRuntimeConfig(projectRoot, { homeDir });
   const ttlDays = Number.isFinite(config?.memoryV2?.episodeTtlDays) && config.memoryV2.episodeTtlDays > 0
     ? config.memoryV2.episodeTtlDays
     : 90;
@@ -144,12 +144,12 @@ export async function needsMigration(projectRoot) {
 }
 
 /**
- * runMigration(projectRoot, { dryRun? } = {})
+ * runMigration(projectRoot, { dryRun?, homeDir? } = {})
  * → { migrated, skipped, plan, markerPath, backupDir }
  * No-op when the marker exists or no legacy files exist. dryRun returns the
  * full per-record plan ({id, source, action, reason}) and writes nothing.
  */
-export async function runMigration(projectRoot, { dryRun = false } = {}) {
+export async function runMigration(projectRoot, { dryRun = false, homeDir } = {}) {
   const paths = buildRuntimePaths(projectRoot);
   const markerPath = path.join(paths.memoryV2Dir, MARKER_NAME);
   const empty = { migrated: 0, skipped: 0, plan: [], markerPath, backupDir: null };
@@ -161,19 +161,26 @@ export async function runMigration(projectRoot, { dryRun = false } = {}) {
 
   // Tombstones + alias resolution feed the pure mapper — tombstone
   // precedence is planned here and enforced again inside mutateMemory.
-  // Registry lookups are async, so legacy ids are pre-resolved and handed
-  // to the mapper as a synchronous closure.
+  // Registry lookups are async and scoped to THIS home, so legacy ids are
+  // pre-resolved and handed to the mapper as a synchronous closure.
+  // `projectId` is the migrating project's own verified identity
+  // (read-only: mint:false) — the mapper only marks an alias conflict when a
+  // legacy name resolves away from this VERIFIED identity; an unbound or
+  // foreign-registered name keeps the legacy id rather than losing data.
   const prior = await readRecordStore(paths.memoryV2RecordsPath);
+  const ownIdentity = await resolveProjectIdentity(projectRoot, { homeDir, mint: false })
+    .catch(() => null);
+  const ownProjectId = ownIdentity?.projectId ?? null;
   const resolvedIds = new Map();
   for (const p of sources.projects) {
     if (p.id && !resolvedIds.has(p.id)) {
-      resolvedIds.set(p.id, await lookupRegisteredProjectId(p.id));
+      resolvedIds.set(p.id, await lookupRegisteredProjectId(p.id, { homeDir }));
     }
   }
   const { records, plan, skipped } = mapLegacySources(sources, {
-    projectId: null,
+    projectId: ownProjectId,
     now: Date.now(),
-    episodeTtlMs: await episodeTtlMsFor(projectRoot),
+    episodeTtlMs: await episodeTtlMsFor(projectRoot, { homeDir }),
     tombstones: prior.tombstones,
     resolveProjectId: (legacyId) => resolvedIds.get(legacyId) ?? null,
   });
@@ -206,7 +213,7 @@ export async function runMigration(projectRoot, { dryRun = false } = {}) {
   // records.
   const { mutateMemory } = await import('./mutateMemory.js');
   const restore = await mutateMemory(
-    { kind: 'project', projectRoot },
+    { kind: 'project', projectRoot, homeDir },
     { op: 'restore', payload: { records } },
   );
   if (restore.status !== 'ok') {

package/src/core/memory/migrateMapping.js

@@ -6,10 +6,12 @@
 //   opts: { projectId, now, episodeTtlMs?, tombstones?, resolveProjectId? }
 // Deterministic: record ids are `v1-<sha1(sourceKind:type:normalizedText)>` —
 // stable across runs and legacy file renames. No I/O; `now` is injected.
-// Rules (FR-003): tombstone precedence → plan 'tombstoned'; alias collision
-// (resolveProjectId returns a different verified identity) → plan 'conflict';
-// pending candidates → trust_tier 'candidate' + meta.legacyStatus 'pending',
-// never status 'active'; everything else → trust_tier 'legacy-unverified'.
+// Rules (FR-003): tombstone precedence → plan 'tombstoned'; alias conflict
+// (a contested 'ambiguous' name, or a name whose registered identity
+// provably differs from the migrating project's own verified id) → plan
+// 'conflict'; pending candidates → trust_tier 'candidate' + meta.legacyStatus
+// 'pending', never status 'active'; everything else → trust_tier
+// 'legacy-unverified'.
 
 import crypto from 'node:crypto';
 import { createRecord } from './records.js';
@@ -119,11 +121,17 @@ export function mapLegacySources(sources, {
     const file = entry?.file ?? `${legacyId ?? 'project'}.json`;
     if (!content || typeof content !== 'object') continue;
 
-    // Alias collision: a legacy id that resolves to a DIFFERENT verified
-    // identity is a conflict — never silently rebound to this project.
+    // Alias conflict: only a VERIFIED mismatch is a conflict — a contested
+    // ('ambiguous') name, or a name resolving to a registered identity that
+    // provably differs from this project's own verified id. When the
+    // migrating project has no verified binding (projectId null) the legacy
+    // name is kept as-is: repo-scoped reads still reach it through the
+    // registry's attested alias list, and keeping the id loses no data —
+    // rebinding to a foreign id is what must never happen silently.
     if (typeof resolveProjectId === 'function' && legacyId) {
       const resolved = resolveProjectId(legacyId);
-      if (resolved && resolved !== legacyId) {
+      if (resolved === 'ambiguous'
+        || (resolved && resolved !== legacyId && projectId != null && resolved !== projectId)) {
         plan.push({
           id: `v1-${crypto.createHash('sha1').update(`project:${legacyId}`).digest('hex')}`,
           source: file,

package/src/core/memory/mutateMemory.js

@@ -105,7 +105,7 @@ export async function mutateMemory(target, envelope = {}, { classifyAdd, guard }
   let projectId = null;
   if (target.kind === 'project') {
     try {
-      config = await loadRuntimeConfig(target.projectRoot);
+      config = await loadRuntimeConfig(target.projectRoot, { homeDir: target.homeDir });
       if (config?.memoryV2?.enabled === false) return { status: 'disabled' };
     } catch {
       // unreadable config → default enabled, keep going
@@ -291,9 +291,21 @@ export async function mutateMemory(target, envelope = {}, { classifyAdd, guard }
         additions.push(record);
       }
       appliedRecordId = additions[0]?.id;
-      // No-op restore: nothing to add → skip the write entirely so a
-      // re-run leaves the doc byte-identical (no generation bump).
+      // No-op restore: nothing to add → normally skip the write entirely so
+      // a re-run leaves the doc byte-identical (no generation bump). The
+      // exception is a missing store: a completed restore — and lazy v1→v2
+      // migration through this path — must still materialize an
+      // authoritative records.json, or a fully-skipped/empty legacy store
+      // silently strands the project on the pre-v2 facade. A corrupt doc is
+      // never overwritten by an empty restore — corrupt bytes stay
+      // byte-identical and reads keep reporting typed 'corrupt'.
       if (additions.length === 0) {
+        if (prior.state === 'missing') {
+          return {
+            result: { status: 'ok', added: 0, records: [] },
+            records,
+          };
+        }
         return { result: { status: 'ok', added: 0, records: [] } };
       }
       return {
@@ -301,7 +313,13 @@ export async function mutateMemory(target, envelope = {}, { classifyAdd, guard }
         records: [...records, ...additions],
         postWrite,
       };
-    }, { onCorrupt: op === 'restore' ? 'quarantine-empty' : undefined });
+    }, {
+      onCorrupt: op === 'restore' ? 'quarantine-empty' : undefined,
+      // TASK-007 (DF2-FR08): binds the memoized recorder to this project —
+      // recordStore emits one memory.write per persisted doc write. User
+      // targets carry no projectRoot → the disabled recorder no-ops.
+      telemetry: { op, projectRoot: target.projectRoot, config },
+    });
     if (receiptStage) {
       // Shadow receipt (FR-004): outcome/code/latency band only — never the
       // record body. Swallowed internally; cannot break the write.

package/src/core/memory/recordIndex.js

@@ -45,7 +45,9 @@ function recordTokens(record) {
 }
 
 // Identical scoring to retrieval.js scoreRecord — keep in sync (parity test).
-export function scoreRecordTokens(record, queryTokens) {
+// `now` is injectable so callers that pin a clock (parity checks, rankHits)
+// get byte-identical lexical scores regardless of wall-clock drift.
+export function scoreRecordTokens(record, queryTokens, now) {
   const typeWeight = RECORD_TYPE_WEIGHTS[record.type] ?? 1;
   if (queryTokens.length === 0) {
     return typeWeight * Math.max(0.1, record.confidence ?? 1);
@@ -56,8 +58,9 @@ export function scoreRecordTokens(record, queryTokens) {
     if (tokens.has(token)) matched += 1;
   }
   if (matched === 0) return 0;
+  const nowMs = typeof now === 'number' ? now : Date.now();
   const recencyBonus = record.created_at > 0
-    ? Math.min(1, record.created_at / Date.now())
+    ? Math.min(1, record.created_at / nowMs)
     : 0;
   return typeWeight * matched * Math.max(0.1, record.confidence ?? 1) + recencyBonus;
 }
@@ -74,7 +77,11 @@ export function createIndex({ maxRecords = 10000, maxPostings = 50000 } = {}) {
   let records = [];
   let postings = new Map(); // token → number[] (indexes into records)
   let postingsCount = 0;
-  let generation = 0;
+  // -1 = "no build observed yet". A fresh index must NOT report generation 0:
+  // generation-0 stores (new docs, marker-only fixtures) would compare equal
+  // in consumers' "needs rebuild" check and the first query would never build
+  // — query() then sees builtGeneration(-1) !== generation(0) and returns [].
+  let generation = -1;
   let builtGeneration = -1; // generation the postings actually reflect
   let evicted = 0;
 

package/src/core/memory/recordStore.js

@@ -10,6 +10,7 @@ import path from 'node:path';
 
 import { copyFileRawExclusive, readJsonIfExists, writeJson, withFileLock } from '../fileOps.js';
 import { normalizeRecord } from './records.js';
+import { emitMemoryWrite } from './memoryEmit.js';
 
 const SCHEMA_VERSION = 2;
 const TOMBSTONE_MAX = 512;
@@ -72,7 +73,10 @@ export async function readRecordStore(recordsPath) {
 }
 
 /**
- * writeRecordStore(recordsPath, records) → void
+ * writeRecordStore(recordsPath, records, {generation?, tombstones?,
+ * telemetry?}) → {generation, recordCount} of the persisted doc.
+ * `telemetry` = {projectRoot, config, op} → one metadata-only memory.write
+ * record after the rename lands (DF2-FR08); absent → no emit.
  * Atomic write; drops unrecoverable entries.
  *
  * Generation is strictly monotonic (SPEC §5 FR-005): the persisted value is
@@ -81,7 +85,7 @@ export async function readRecordStore(recordsPath) {
  * (one stat+parse) and keeps this function safe even when invoked outside
  * mutateRecordStore's lock.
  */
-export async function writeRecordStore(recordsPath, records, { generation, tombstones } = {}) {
+export async function writeRecordStore(recordsPath, records, { generation, tombstones, telemetry } = {}) {
   const normalized = (Array.isArray(records) ? records : [])
     .map((raw) => normalizeRecord(raw))
     .filter(Boolean);
@@ -90,12 +94,25 @@ export async function writeRecordStore(recordsPath, records, { generation, tombs
   const baseGeneration = Math.max(supplied, prior.generation);
   const baseTombstones = tombstones === undefined ? prior.tombstones : tombstones;
   const nextTombstones = (Array.isArray(baseTombstones) ? baseTombstones : []).slice(-TOMBSTONE_MAX);
+  const nextGeneration = baseGeneration + 1;
   await writeJson(recordsPath, {
     schemaVersion: SCHEMA_VERSION,
-    generation: baseGeneration + 1,
+    generation: nextGeneration,
     tombstones: nextTombstones,
     records: normalized,
   }, { fsync: true });
+  // TASK-007 (DF2-FR08): one memory.write record per persisted doc write,
+  // emitted only after the tmp+rename lands. Metadata-only (op, counts,
+  // kind buckets, sha256 refs); O(1) no-op when the stage is off and
+  // never-throw — telemetry can never fail the write.
+  if (telemetry != null) {
+    emitMemoryWrite({
+      ...telemetry,
+      recordCount: normalized.length,
+      tombstoneCount: nextTombstones.length,
+    });
+  }
+  return { generation: nextGeneration, recordCount: normalized.length };
 }
 
 /**
@@ -179,6 +196,14 @@ export async function mutateRecordStore(recordsPath, mutate, opts = {}) {
       await writeRecordStore(recordsPath, mutation.records, {
         generation: prior.generation,
         tombstones: mutation.tombstones ?? prior.tombstones,
+        // Emit contract (TASK-007): the caller supplies the observability
+        // binding once ({projectRoot, config}); the subject — the record(s)
+        // this write changed — is derived from the mutation's own result so
+        // every op emits exactly one record for one persisted write.
+        telemetry: opts.telemetry == null ? undefined : {
+          ...opts.telemetry,
+          subject: mutation.result?.record ?? mutation.result?.records,
+        },
       });
       // Test-only crash-injection hook (TASK-002): UKIT_TEST_CRASH_AT=
       // 'post-doc-write' kills the process after the doc rename but before

package/src/core/memory/retrieval.js

@@ -14,6 +14,7 @@ import { createIndex, normalize, scoreRecordTokens, tokenize } from './recordInd
 import { buildMemoryHit, rankHits } from './memoryHit.js';
 import { resolveRecordFreshness } from './memoryFreshness.js';
 import { getHeadSha } from '../codeintel/freshness.js';
+import { emitRetrievalQuery, emitMemoryRetrieved } from './memoryEmit.js';
 
 function compactPhraseList(values, { limit = 1, fallback = 'n/a' } = {}) {
   const normalized = [...new Set(
@@ -173,13 +174,13 @@ export const RECORD_TYPE_WEIGHTS = Object.freeze({
 // 'empty' — 'corrupt'|'disabled'|'migrating' mean the v2 lane is authoritative
 // and empty (FR-008). queryRecords itself triggers ensureMigrated on the real
 // store — no explicit migration here.
-async function queryV2Records(projectRoot, { projectId } = {}) {
+async function queryV2Records(projectRoot, { projectId, homeDir } = {}) {
   let policy = {};
   let config = null;
   try {
-    config = await loadRuntimeConfig(projectRoot);
+    config = await loadRuntimeConfig(projectRoot, { homeDir });
     if (config?.memoryV2?.enabled === false) {
-      return { state: 'disabled', records: [], policy, generation: 0 };
+    return { state: 'disabled', records: [], policy, generation: 0, config };
     }
     if (config?.memoryV2?.policy && typeof config.memoryV2.policy === 'object') {
       policy = config.memoryV2.policy;
@@ -195,11 +196,11 @@ async function queryV2Records(projectRoot, { projectId } = {}) {
     ? resolveMemoryStage(config, 'eligibility', { projectId })
     : 'default';
   if (eligibilityStage === 'off') {
-    return { state: 'missing', records: [], policy, generation: 0 };
+    return { state: 'missing', records: [], policy, generation: 0, config };
   }
   if (eligibilityStage === 'shadow') {
     const startedAt = Date.now();
-    const probe = await loadV2Records(projectRoot, {});
+    const probe = await loadV2Records(projectRoot, {}, { config, projectId, homeDir });
     await appendRolloutReceipt(projectRoot, {
       plane: 'eligibility',
       stage: 'shadow',
@@ -207,15 +208,15 @@ async function queryV2Records(projectRoot, { projectId } = {}) {
       code: probe.state,
       latencyBand: latencyBandForMs(Date.now() - startedAt),
     });
-    return { state: 'missing', records: [], policy, generation: 0 };
+    return { state: 'missing', records: [], policy, generation: 0, config };
   }
-  const { state, records, generation } = await loadV2Records(projectRoot, {}, { config, projectId });
+  const { state, records, generation } = await loadV2Records(projectRoot, {}, { config, projectId, homeDir });
   // Index plane (FR-003): 'off' → linear scan; 'shadow' → indexed path runs
   // for measurement only, linear result is served; live → indexed path.
   const indexStage = config
     ? resolveMemoryStage(config, 'index', { projectId })
     : 'default';
-  return { state, records, policy, generation: generation ?? 0, indexStage };
+  return { state, records, policy, generation: generation ?? 0, indexStage, config };
 }
 
 // 'missing'|'empty' → legacy compat lane; every other state keeps the v2 lane
@@ -236,10 +237,15 @@ export const LEGACY_SCOPE_MATCH = {
 // rankHits includes bonus-only (lexical=0) records; the index path can only
 // surface token-matching candidates, so the scan path pre-filters to the
 // same candidate pool (scoreRecordTokens > 0) — identical hits either way.
-function searchRecords(records, query, scope, limit, eligibleCtx, policy) {
+// Returns {hits, candidateCount} — the count feeds retrieval.query telemetry
+// (DF2-FR08) without recomputing the pool.
+function searchRecords(records, query, scope, limit, eligibleCtx, policy, now) {
   const queryTokens = tokenize(query);
-  const candidates = records.filter((record) => scoreRecordTokens(record, queryTokens) > 0);
-  return rankHits(candidates, { queryTokens, eligibleCtx, policy, scope, limit });
+  const candidates = records.filter((record) => scoreRecordTokens(record, queryTokens, now) > 0);
+  return {
+    hits: rankHits(candidates, { queryTokens, eligibleCtx, policy, scope, limit, now }),
+    candidateCount: candidates.length,
+  };
 }
 
 // Freshness is resolved post-limit only (≤ limit × MAX_EVIDENCE stats per
@@ -247,7 +253,7 @@ function searchRecords(records, query, scope, limit, eligibleCtx, policy) {
 // non-file evidence, `command` is filled lazily via getHeadSha (one bounded
 // git spawn per call, never per record). Resolver errors degrade to
 // 'unknown' and never break search.
-async function attachFreshness(hits, records, { projectRoot, watermarks } = {}) {
+async function attachFreshness(hits, records, { projectRoot, watermarks, now } = {}) {
   if (!Array.isArray(hits) || hits.length === 0) return hits;
   const recordById = new Map((records ?? []).map((record) => [record.id, record]));
   const needsCommand = watermarks?.command == null && hits.some((hit) => {
@@ -266,6 +272,7 @@ async function attachFreshness(hits, records, { projectRoot, watermarks } = {})
     hit.freshness = await resolveRecordFreshness(record, {
       projectRoot,
       watermarks: resolvedWatermarks,
+      now,
     });
   }));
   return hits;
@@ -287,10 +294,10 @@ export function resetRecordIndexForTests() {
   recordIndexes.clear();
 }
 
-function searchRecordsIndexed(records, query, scope, limit, eligibleCtx, policy, indexKey, generation) {
+function searchRecordsIndexed(records, query, scope, limit, eligibleCtx, policy, indexKey, generation, now) {
   const queryTokens = tokenize(query);
   if (queryTokens.length === 0) {
-    return searchRecords(records, query, scope, limit, eligibleCtx, policy);
+    return searchRecords(records, query, scope, limit, eligibleCtx, policy, now);
   }
   try {
     let index = recordIndexes.get(indexKey);
@@ -303,19 +310,48 @@ function searchRecordsIndexed(records, query, scope, limit, eligibleCtx, policy,
     }
     const candidates = index.query(queryTokens, { limit: records.length })
       .map((hit) => hit.record);
-    return rankHits(candidates, { queryTokens, eligibleCtx, policy, scope, limit });
+    return {
+      hits: rankHits(candidates, { queryTokens, eligibleCtx, policy, scope, limit, now }),
+      candidateCount: candidates.length,
+    };
   } catch {
-    return searchRecords(records, query, scope, limit, eligibleCtx, policy);
+    return searchRecords(records, query, scope, limit, eligibleCtx, policy, now);
   }
 }
 
-export async function search(query, scope = 'all', limit = 10, { projectRoot, projectId, projectAliases, index = true, watermarks } = {}) {
-  const { state, records, policy, generation, indexStage } = await queryV2Records(projectRoot, { projectId });
+export async function search(query, scope = 'all', limit = 10, { projectRoot, projectId, projectAliases, index = true, watermarks, homeDir, now } = {}) {
+  const startedAt = Date.now();
+  const { state, records, policy, generation, indexStage, config } = await queryV2Records(projectRoot, { projectId, homeDir });
   const effective = resolveEffectiveScope(
     { projectId: projectId ?? null },
     REQUESTED_SCOPE_TO_POLICY[scope] ?? scope,
   );
+
+  // TASK-007 (DF2-FR08): every search() exits through emitQuery once —
+  // one retrieval.query + one memory.retrieved per returned hit, metadata
+  // only. Stage-off short-circuits inside the helpers before any hashing.
+  const emitQuery = ({ lane, indexed, candidateCount, results }) => {
+    const freshness = {};
+    for (const hit of results) {
+      const bucket = hit?.freshness?.state;
+      if (typeof bucket === 'string') freshness[bucket] = (freshness[bucket] ?? 0) + 1;
+    }
+    emitRetrievalQuery({
+      projectRoot,
+      config,
+      lane,
+      scope,
+      indexed,
+      candidateCount,
+      returnedCount: results.length,
+      durationMs: Date.now() - startedAt,
+      freshness,
+    });
+    emitMemoryRetrieved({ projectRoot, config, hits: results });
+  };
+
   if (effective.denied) {
+    emitQuery({ lane: 'v2', indexed: false, candidateCount: 0, results: [] });
     return [];
   }
   const eligibleCtx = {
@@ -330,36 +366,38 @@ export async function search(query, scope = 'all', limit = 10, { projectRoot, pr
     // indexed path for measurement, discards it, and serves the scan result
     // (zero output change) plus a bounded receipt.
     if (index !== false && indexStage === 'shadow') {
-      const startedAt = Date.now();
+      const shadowStarted = Date.now();
       try {
-        searchRecordsIndexed(records, query, scope, limit, eligibleCtx, policy, indexKey, generation);
+        searchRecordsIndexed(records, query, scope, limit, eligibleCtx, policy, indexKey, generation, now);
         await appendRolloutReceipt(projectRoot, {
           plane: 'index', stage: 'shadow', outcome: 'ok', code: 'search',
-          latencyBand: latencyBandForMs(Date.now() - startedAt),
+          latencyBand: latencyBandForMs(Date.now() - shadowStarted),
         });
       } catch {
         await appendRolloutReceipt(projectRoot, {
           plane: 'index', stage: 'shadow', outcome: 'error', code: 'search',
-          latencyBand: latencyBandForMs(Date.now() - startedAt),
+          latencyBand: latencyBandForMs(Date.now() - shadowStarted),
         });
       }
     }
-    const hits = index === false || indexStage === 'off' || indexStage === 'shadow'
-      ? searchRecords(records, query, scope, limit, eligibleCtx, policy)
-      : searchRecordsIndexed(
+    const useIndex = index !== false && indexStage !== 'off' && indexStage !== 'shadow';
+    const { hits, candidateCount } = useIndex
+      ? searchRecordsIndexed(
           records, query, scope, limit, eligibleCtx, policy,
           indexKey,
           generation,
-        );
-    return attachFreshness(hits, records, { projectRoot, watermarks });
+          now,
+        )
+      : searchRecords(records, query, scope, limit, eligibleCtx, policy, now);
+    const results = await attachFreshness(hits, records, { projectRoot, watermarks, now });
+    emitQuery({ lane: 'v2', indexed: useIndex, candidateCount, results });
+    return results;
   }
 
-  const items = await listMemoryItems(projectRoot);
+  const items = await listMemoryItems(projectRoot, { homeDir });
   const queryTokens = tokenize(query);
-
-
-  return items
-    .filter((item) => withinScope(item, scope, projectId, projectAliases))
+  const inScope = items.filter((item) => withinScope(item, scope, projectId, projectAliases));
+  const results = inScope
     .map((item) => ({
       item,
       score: scoreItem(item, queryTokens),
@@ -372,6 +410,8 @@ export async function search(query, scope = 'all', limit = 10, { projectRoot, pr
     ))
     .slice(0, limit)
     .map((entry) => buildSearchResult(entry.item, entry.score));
+  emitQuery({ lane: 'legacy', indexed: false, candidateCount: inScope.length, results });
+  return results;
 }
 
 function findRelatedItemIds(targetItem, allItems) {
@@ -402,8 +442,8 @@ function findRelatedItemIds(targetItem, allItems) {
     .slice(0, 5);
 }
 
-export async function expand(id, { projectRoot, projectId, projectAliases } = {}) {
-  const { state, records, policy } = await queryV2Records(projectRoot, { projectId });
+export async function expand(id, { projectRoot, projectId, projectAliases, homeDir } = {}) {
+  const { state, records, policy } = await queryV2Records(projectRoot, { projectId, homeDir });
   if (!v2AllowsLegacyFallback(state)) {
     const effective = resolveEffectiveScope({ projectId: projectId ?? null }, 'all');
     const eligibleCtx = {
@@ -439,7 +479,7 @@ export async function expand(id, { projectRoot, projectId, projectAliases } = {}
     };
   }
 
-  const items = await listMemoryItems(projectRoot);
+  const items = await listMemoryItems(projectRoot, { homeDir });
   const target = items.find((item) => item.id === id);
   if (!target) {
     return { id, fullContent: '', relatedItems: [] };
@@ -622,18 +662,19 @@ export async function getContextInjection(
     promptCache = false,
     inputCompression = true,
     projectAliases = [],
+    homeDir,
   } = {},
 ) {
-  const { state, records, policy } = await queryV2Records(projectRoot, { projectId });
+  const { state, records, policy } = await queryV2Records(projectRoot, { projectId, homeDir });
   const v2Active = !v2AllowsLegacyFallback(state);
-  const items = v2Active ? [] : await listMemoryItems(projectRoot);
+  const items = v2Active ? [] : await listMemoryItems(projectRoot, { homeDir });
   const pressureState = await readCompactPressureState(projectRoot);
   const recallPlan = resolveRecallPressurePlan({
     maxTokens,
     limit,
     pressureState,
   });
-  const rankedItems = await search(currentTask, 'all', Math.max(limit * 3, 8), { projectRoot, projectId, projectAliases });
+  const rankedItems = await search(currentTask, 'all', Math.max(limit * 3, 8), { projectRoot, projectId, projectAliases, homeDir });
   const eligibleCtx = { projectId: projectId ?? null, projectAliases, includeUser: recallPlan.includeUserMemory };
   const selectedItems = v2Active
     ? dedupeItemsById(rankedItems