claude-memory-layer 1.0.30 → 1.0.32

package/tests/core/retrieval-services.test.ts

@@ -1,185 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  createRetrievalServices,
-  type RetrievalEventStore
-} from '../../src/core/engine/retrieval-services.js';
-import type { Embedder } from '../../src/core/embedder.js';
-import type { Matcher } from '../../src/core/matcher.js';
-import type { Retriever, UnifiedRetrievalResult } from '../../src/core/retriever.js';
-import type { MemoryEvent } from '../../src/core/types.js';
-import type { VectorStore } from '../../src/core/vector-store.js';
-
-function event(id: string): MemoryEvent {
-  return {
-    id,
-    sessionId: 's1',
-    eventType: 'agent_response',
-    content: 'retrieval factory keeps MemoryService thin',
-    canonicalKey: `test/${id}`,
-    dedupeKey: `s1:${id}`,
-    timestamp: new Date('2026-02-25T00:00:00.000Z'),
-    metadata: {}
-  };
-}
-
-function retrievalResult(id = 'e1'): UnifiedRetrievalResult {
-  const memoryEvent = event(id);
-  return {
-    memories: [{ event: memoryEvent, score: 0.92, sessionContext: 'nearby context' }],
-    matchResult: {
-      match: { event: memoryEvent, score: 0.92 },
-      confidence: 'high'
-    },
-    totalTokens: 10,
-    context: memoryEvent.content,
-    fallbackTrace: ['stage:primary:fast'],
-    selectedDebug: [{ eventId: id, score: 0.92, semanticScore: 0.8, lexicalScore: 0.4, recencyScore: 0.1 }],
-    candidateDebug: [{ eventId: id, score: 0.92, semanticScore: 0.8, lexicalScore: 0.4, recencyScore: 0.1 }]
-  };
-}
-
-describe('createRetrievalServices', () => {
-  it('builds one retriever and wires the retrieval service bundle to shared ports', async () => {
-    let initializeCalls = 0;
-    const traceInputs: Array<Record<string, unknown>> = [];
-    const retrieveCalls: Array<{ query: string; options: Record<string, unknown> }> = [];
-    const traceStats = {
-      totalQueries: 2,
-      avgCandidateCount: 1,
-      avgSelectedCount: 1,
-      selectionRate: 1
-    };
-    const vectorStore = { marker: 'vector' } as unknown as VectorStore;
-    const embedder = { marker: 'embedder' } as unknown as Embedder;
-    const matcher = { marker: 'matcher' } as unknown as Matcher;
-    const store = {
-      getHelpfulnessStats: async () => ({
-        avgScore: 0.8,
-        totalEvaluated: 25,
-        totalRetrievals: 30,
-        helpful: 20,
-        neutral: 3,
-        unhelpful: 2
-      }),
-      recordRetrievalTrace: async (input: Record<string, unknown>) => { traceInputs.push(input); },
-      incrementAccessCount: async (_eventIds: string[]) => {},
-      recordRetrieval: async (_eventId: string, _sessionId: string, _score: number, _query: string) => {},
-      getEvent: async (id: string) => event(id),
-      getSessionEvents: async (_sessionId: string) => [event('e1')],
-      getRecentEvents: async (_limit?: number) => [event('e1')],
-      getRetrievalTraceStats: async () => traceStats,
-      getRecentRetrievalTraces: async () => [],
-      getMostAccessed: async () => [],
-      evaluateSessionHelpfulness: async (_sessionId: string) => {},
-      getUnevaluatedSessions: async () => [],
-      getHelpfulMemories: async () => []
-    };
-    let createArgs: {
-      eventStore: unknown;
-      vectorStore: unknown;
-      embedder: unknown;
-      matcher: unknown;
-    } | null = null;
-    let registeredRewriter: ((query: string) => Promise<string | null>) | null = null;
-    const fakeRetriever = {
-      setQueryRewriter(rewriter: (query: string) => Promise<string | null>) {
-        registeredRewriter = rewriter;
-      },
-      async retrieve(query: string, options: Record<string, unknown>) {
-        retrieveCalls.push({ query, options });
-        return retrievalResult('e1');
-      }
-    } as unknown as Retriever;
-
-    const services = createRetrievalServices({
-      initialize: async () => { initializeCalls += 1; },
-      eventStore: store,
-      vectorStore,
-      embedder,
-      matcher,
-      getProjectHash: () => 'project-1',
-      hasSharedStore: () => false,
-      createRetriever: (eventStore, vectorStoreArg, embedderArg, matcherArg) => {
-        createArgs = {
-          eventStore,
-          vectorStore: vectorStoreArg,
-          embedder: embedderArg,
-          matcher: matcherArg
-        };
-        return fakeRetriever;
-      }
-    });
-
-    expect(services.retriever).toBe(fakeRetriever);
-    expect(createArgs).toEqual({ eventStore: store, vectorStore, embedder, matcher });
-    expect(registeredRewriter).toEqual(expect.any(Function));
-
-    await services.retrievalOrchestrator.retrieveMemories('thin core', { sessionId: 's1', topK: 2 });
-
-    expect(retrieveCalls[0]).toMatchObject({
-      query: 'thin core',
-      options: {
-        topK: 2,
-        projectHash: 'project-1',
-        projectScopeMode: 'strict'
-      }
-    });
-    expect(traceInputs[0]).toMatchObject({
-      sessionId: 's1',
-      projectHash: 'project-1',
-      queryText: 'thin core',
-      selectedEventIds: ['e1'],
-      candidateEventIds: ['e1'],
-      confidence: 'high'
-    });
-
-    const disclosure = await services.retrievalDisclosureService.search('thin core disclosure', { topK: 1 });
-    expect(disclosure.results[0]).toMatchObject({
-      id: 'event:e1',
-      sourceRef: 'event:e1',
-      sessionId: 's1'
-    });
-
-    await expect(services.retrievalAnalyticsService.getRetrievalTraceStats()).resolves.toEqual(traceStats);
-    expect(initializeCalls).toBe(3);
-  });
-
-  it('rejects default retriever stores that lack retriever read methods', () => {
-    const incompleteStore = {
-      recordRetrievalTrace: async (_input: Record<string, unknown>) => {},
-      incrementAccessCount: async (_eventIds: string[]) => {},
-      recordRetrieval: async (_eventId: string, _sessionId: string, _score: number, _query: string) => {},
-      getEvent: async (id: string) => event(id),
-      getSessionEvents: async (_sessionId: string) => [event('e1')],
-      getRetrievalTraceStats: async () => ({
-        totalQueries: 0,
-        avgCandidateCount: 0,
-        avgSelectedCount: 0,
-        selectionRate: 0
-      }),
-      getRecentRetrievalTraces: async () => [],
-      getMostAccessed: async () => [],
-      evaluateSessionHelpfulness: async (_sessionId: string) => {},
-      getUnevaluatedSessions: async () => [],
-      getHelpfulMemories: async () => [],
-      getHelpfulnessStats: async () => ({
-        avgScore: 0,
-        totalEvaluated: 0,
-        totalRetrievals: 0,
-        helpful: 0,
-        neutral: 0,
-        unhelpful: 0
-      })
-    } as unknown as RetrievalEventStore;
-
-    expect(() => createRetrievalServices({
-      initialize: async () => {},
-      eventStore: incompleteStore,
-      vectorStore: { marker: 'vector' } as unknown as VectorStore,
-      embedder: { marker: 'embedder' } as unknown as Embedder,
-      matcher: { marker: 'matcher' } as unknown as Matcher,
-      getProjectHash: () => null,
-      hasSharedStore: () => false
-    })).toThrow(/getRecentEvents/);
-  });
-});

package/tests/core/retriever-fallback-chain.test.ts

@@ -1,223 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Retriever } from '../../src/core/retriever.js';
-import { Matcher } from '../../src/core/matcher.js';
-import type { MemoryEvent } from '../../src/core/types.js';
-
-function ev(id: string, content: string): MemoryEvent {
-  return {
-    id,
-    eventType: 'user_prompt',
-    sessionId: 's1',
-    timestamp: new Date('2026-02-24T00:00:00.000Z'),
-    content,
-    canonicalKey: id,
-    dedupeKey: id,
-    metadata: {}
-  };
-}
-
-describe('Retriever fallback chain', () => {
-  it('falls back from fast to deep when fast has no result', async () => {
-    const e = ev('e1', 'deep result memory');
-    let vectorCalls = 0;
-
-    const fakeEventStore = {
-      async keywordSearch() {
-        return [];
-      },
-      async getRecentEvents() {
-        return [e];
-      },
-      async getEvent(id: string) {
-        return id === 'e1' ? e : null;
-      },
-      async getSessionEvents() {
-        return [e];
-      }
-    };
-
-    const fakeVectorStore = {
-      async search() {
-        vectorCalls += 1;
-        return [{ id: 'v1', eventId: 'e1', content: e.content, score: 0.9, sessionId: 's1', eventType: e.eventType, timestamp: e.timestamp.toISOString() }];
-      }
-    };
-
-    const fakeEmbedder = { async embed() { return { vector: [0.1, 0.2] }; } };
-
-    const retriever = new Retriever(fakeEventStore as any, fakeVectorStore as any, fakeEmbedder as any, new Matcher());
-    const out = await retriever.retrieve('result', { strategy: 'auto', topK: 3, includeSessionContext: false });
-
-    expect(out.memories.length).toBeGreaterThan(0);
-    expect(vectorCalls).toBeGreaterThan(0);
-    expect(out.fallbackTrace).toContain('fallback:deep');
-  });
-
-  it('applies custom rerank weights when provided', async () => {
-    const e1 = ev('a', 'keyword hit exact');
-    const e2 = ev('b', 'less related');
-
-    const fakeEventStore = {
-      async keywordSearch() { return []; },
-      async getRecentEvents() { return [e1, e2]; },
-      async getEvent(id: string) { return id === 'a' ? e1 : id === 'b' ? e2 : null; },
-      async getSessionEvents() { return [e1, e2]; }
-    };
-
-    const fakeVectorStore = {
-      async search() {
-        return [
-          { id: 'v1', eventId: 'b', content: e2.content, score: 0.95, sessionId: 's1', eventType: e2.eventType, timestamp: e2.timestamp.toISOString() },
-          { id: 'v2', eventId: 'a', content: e1.content, score: 0.7, sessionId: 's1', eventType: e1.eventType, timestamp: e1.timestamp.toISOString() },
-        ];
-      }
-    };
-
-    const fakeEmbedder = { async embed() { return { vector: [0.1, 0.2] }; } };
-    const retriever = new Retriever(fakeEventStore as any, fakeVectorStore as any, fakeEmbedder as any, new Matcher());
-
-    const out = await retriever.retrieve('keyword hit', {
-      strategy: 'deep',
-      topK: 3,
-      includeSessionContext: false,
-      rerankWeights: { semantic: 0.2, lexical: 0.7, recency: 0.1 }
-    });
-
-    expect(out.memories[0]?.event.id).toBe('a');
-  });
-
-  it('applies TTL/decay penalty for stale low-overlap memories', async () => {
-    const old = {
-      ...ev('old', 'generic memory'),
-      timestamp: new Date(Date.now() - 1000 * 60 * 60 * 24 * 120),
-    };
-    const fresh = {
-      ...ev('fresh', 'generic memory'),
-      timestamp: new Date(),
-    };
-
-    const fakeEventStore = {
-      async keywordSearch() { return []; },
-      async getRecentEvents() { return [old, fresh]; },
-      async getEvent(id: string) { return id === 'old' ? old : id === 'fresh' ? fresh : null; },
-      async getSessionEvents() { return [old, fresh]; }
-    };
-
-    const fakeVectorStore = {
-      async search() {
-        return [
-          { id: 'v1', eventId: 'old', content: old.content, score: 0.9, sessionId: old.sessionId, eventType: old.eventType, timestamp: old.timestamp.toISOString() },
-          { id: 'v2', eventId: 'fresh', content: fresh.content, score: 0.85, sessionId: fresh.sessionId, eventType: fresh.eventType, timestamp: fresh.timestamp.toISOString() },
-        ];
-      }
-    };
-
-    const fakeEmbedder = { async embed() { return { vector: [0.1, 0.2] }; } };
-    const retriever = new Retriever(fakeEventStore as any, fakeVectorStore as any, fakeEmbedder as any, new Matcher());
-
-    const out = await retriever.retrieve('different query', {
-      strategy: 'deep',
-      topK: 2,
-      includeSessionContext: false,
-      decayPolicy: { enabled: true, windowDays: 30, maxPenalty: 0.3 }
-    });
-
-    expect(out.memories[0]?.event.id).toBe('fresh');
-  });
-
-  it('merges rewritten deep query results when intentRewrite is enabled', async () => {
-    const a = ev('a', '원문 질의에서는 약한 결과');
-    const b = ev('b', '재작성 질의에서 강한 결과');
-
-    const fakeEventStore = {
-      async keywordSearch() { return []; },
-      async getRecentEvents() { return [a, b]; },
-      async getEvent(id: string) { return id === 'a' ? a : id === 'b' ? b : null; },
-      async getSessionEvents() { return [a, b]; }
-    };
-
-    let call = 0;
-    const fakeVectorStore = {
-      async search() {
-        call += 1;
-        if (call === 1) {
-          return [{ id: 'v1', eventId: 'a', content: a.content, score: 0.8, sessionId: 's1', eventType: a.eventType, timestamp: a.timestamp.toISOString() }];
-        }
-        return [{ id: 'v2', eventId: 'b', content: b.content, score: 0.95, sessionId: 's1', eventType: b.eventType, timestamp: b.timestamp.toISOString() }];
-      }
-    };
-
-    const fakeEmbedder = { async embed() { return { vector: [0.1, 0.2] }; } };
-    const retriever = new Retriever(fakeEventStore as any, fakeVectorStore as any, fakeEmbedder as any, new Matcher());
-    retriever.setQueryRewriter(async () => '확장된 재작성 질의');
-
-    const out = await retriever.retrieve('원문 질의', {
-      strategy: 'deep',
-      topK: 3,
-      includeSessionContext: false,
-      intentRewrite: true,
-    });
-
-    expect(out.memories[0]?.event.id).toBe('b');
-  });
-
-  it('expands related events with graph-hop retrieval', async () => {
-    const seed = ev('seed', 'seed event');
-    const neighbor = {
-      ...ev('neighbor', 'related artifact memory'),
-      metadata: { relatedEventIds: ['seed'] },
-    };
-    const seedWithEdge = { ...seed, metadata: { relatedEventIds: ['neighbor'] } };
-
-    const fakeEventStore = {
-      async keywordSearch() { return []; },
-      async getRecentEvents() { return [seedWithEdge, neighbor]; },
-      async getEvent(id: string) {
-        if (id === 'seed') return seedWithEdge;
-        if (id === 'neighbor') return neighbor;
-        return null;
-      },
-      async getSessionEvents() { return [seedWithEdge, neighbor]; }
-    };
-
-    const fakeVectorStore = {
-      async search() {
-        return [{ id: 'v1', eventId: 'seed', content: seedWithEdge.content, score: 0.95, sessionId: 's1', eventType: seedWithEdge.eventType, timestamp: seedWithEdge.timestamp.toISOString() }];
-      }
-    };
-
-    const fakeEmbedder = { async embed() { return { vector: [0.1, 0.2] }; } };
-    const retriever = new Retriever(fakeEventStore as any, fakeVectorStore as any, fakeEmbedder as any, new Matcher());
-
-    const out = await retriever.retrieve('seed event', {
-      strategy: 'deep',
-      topK: 5,
-      includeSessionContext: false,
-      graphHop: { enabled: true, maxHops: 1, hopPenalty: 0.1 }
-    });
-
-    const ids = out.memories.map((m) => m.event.id);
-    expect(ids).toContain('seed');
-    expect(ids).toContain('neighbor');
-  });
-
-  it('uses summary fallback when both fast and deep fail', async () => {
-    const e = ev('e2', 'keyword overlap fallback candidate');
-
-    const fakeEventStore = {
-      async keywordSearch() { return []; },
-      async getRecentEvents() { return [e]; },
-      async getEvent(id: string) { return id === 'e2' ? e : null; },
-      async getSessionEvents() { return [e]; }
-    };
-
-    const fakeVectorStore = { async search() { return []; } };
-    const fakeEmbedder = { async embed() { return { vector: [0.1, 0.2] }; } };
-
-    const retriever = new Retriever(fakeEventStore as any, fakeVectorStore as any, fakeEmbedder as any, new Matcher());
-    const out = await retriever.retrieve('fallback candidate', { strategy: 'auto', topK: 3, includeSessionContext: false });
-
-    expect(out.fallbackTrace).toContain('fallback:summary');
-    expect(out.memories[0]?.event.id).toBe('e2');
-  });
-});

package/tests/core/retriever-strategy-scope.test.ts

@@ -1,164 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Retriever } from '../../src/core/retriever.js';
-import { Matcher } from '../../src/core/matcher.js';
-import type { MemoryEvent } from '../../src/core/types.js';
-
-function ev(id: string, sessionId: string, eventType: MemoryEvent['eventType'], content: string, canonicalKey: string): MemoryEvent {
-  return {
-    id,
-    sessionId,
-    eventType,
-    content,
-    canonicalKey,
-    dedupeKey: `${sessionId}:${id}`,
-    timestamp: new Date('2026-02-24T00:00:00.000Z'),
-    metadata: {}
-  };
-}
-
-describe('Retriever strategy/scope', () => {
-  const e1 = ev('e1', 'agent:main:alpha', 'user_prompt', '아침 브리핑 선호', 'pref/briefing/morning');
-  const e2 = ev('e2', 'agent:main:beta', 'agent_response', '점심 이후 요약은 잘 안봄', 'pref/briefing/lunch');
-
-  const fakeEventStore = {
-    async keywordSearch() {
-      return [
-        { event: e1, rank: -0.1 },
-        { event: e2, rank: -0.2 }
-      ];
-    },
-    async getRecentEvents() {
-      return [e1, e2];
-    },
-    async getEvent(id: string) {
-      return id === 'e1' ? e1 : id === 'e2' ? e2 : null;
-    },
-    async getSessionEvents(sessionId: string) {
-      return [e1, e2].filter((x) => x.sessionId === sessionId);
-    }
-  };
-
-  const fakeVectorStore = {
-    async search() {
-      return [
-        {
-          id: 'v1',
-          eventId: 'e2',
-          content: e2.content,
-          score: 0.92,
-          sessionId: e2.sessionId,
-          eventType: e2.eventType,
-          timestamp: e2.timestamp.toISOString()
-        },
-        {
-          id: 'v2',
-          eventId: 'e1',
-          content: e1.content,
-          score: 0.8,
-          sessionId: e1.sessionId,
-          eventType: e1.eventType,
-          timestamp: e1.timestamp.toISOString()
-        }
-      ];
-    }
-  };
-
-  const fakeEmbedder = {
-    async embed() {
-      return { vector: [0.1, 0.2, 0.3] };
-    }
-  };
-
-  it('uses fast strategy keyword path', async () => {
-    const retriever = new Retriever(fakeEventStore as any, fakeVectorStore as any, fakeEmbedder as any, new Matcher());
-    const out = await retriever.retrieve('브리핑', { strategy: 'fast', topK: 2, includeSessionContext: false });
-
-    expect(out.memories.length).toBe(2);
-    expect(out.memories[0].event.id).toBe('e1');
-  });
-
-  it('applies scoped filters (session prefix + canonical prefix + includes)', async () => {
-    const retriever = new Retriever(fakeEventStore as any, fakeVectorStore as any, fakeEmbedder as any, new Matcher());
-
-    const out = await retriever.retrieve('브리핑', {
-      strategy: 'deep',
-      topK: 5,
-      includeSessionContext: false,
-      scope: {
-        sessionIdPrefix: 'agent:main:alpha',
-        canonicalKeyPrefix: 'pref/briefing/morning',
-        contentIncludes: ['아침']
-      }
-    });
-
-    expect(out.memories.length).toBe(1);
-    expect(out.memories[0].event.id).toBe('e1');
-  });
-
-  it('returns no memories for command-artifact queries instead of semantic false positives', async () => {
-    const retriever = new Retriever(fakeEventStore as any, fakeVectorStore as any, fakeEmbedder as any, new Matcher());
-
-    const out = await retriever.retrieve('local-command-stdout command-name opus', {
-      strategy: 'deep',
-      topK: 5,
-      minScore: 0.1,
-      includeSessionContext: false
-    });
-
-    expect(out.memories).toEqual([]);
-    expect(out.fallbackTrace).toContain('guard:command-artifact-query');
-  });
-
-  it('filters technical identifier queries when candidates have no exact technical overlap', async () => {
-    const retriever = new Retriever(fakeEventStore as any, fakeVectorStore as any, fakeEmbedder as any, new Matcher());
-
-    const out = await retriever.retrieve('DuckDB legacy storage migrate', {
-      strategy: 'deep',
-      topK: 5,
-      minScore: 0.1,
-      includeSessionContext: false
-    });
-
-    expect(out.memories).toEqual([]);
-  });
-
-  it('keeps technical identifier matches when candidate content contains the identifier', async () => {
-    const technical = ev(
-      'e3',
-      'agent:main:alpha',
-      'agent_response',
-      'SQLite FTS failure no such column T.event_id is fixed with event_id UNINDEXED.',
-      'fix/sqlite/fts'
-    );
-    const eventStore = {
-      ...fakeEventStore,
-      async getEvent(id: string) {
-        if (id === 'e3') return technical;
-        return fakeEventStore.getEvent(id);
-      }
-    };
-    const vectorStore = {
-      async search() {
-        return [{
-          id: 'v3',
-          eventId: 'e3',
-          content: technical.content,
-          score: 0.93,
-          sessionId: technical.sessionId,
-          eventType: technical.eventType,
-          timestamp: technical.timestamp.toISOString()
-        }];
-      }
-    };
-    const retriever = new Retriever(eventStore as any, vectorStore as any, fakeEmbedder as any, new Matcher());
-
-    const out = await retriever.retrieve('T.event_id FTS rebuild', {
-      strategy: 'deep',
-      topK: 5,
-      minScore: 0.1,
-      includeSessionContext: false
-    });
-
-    expect(out.memories.map((memory) => memory.event.id)).toEqual(['e3']);
-  });
-});

package/tests/core/retriever.memu-adoption.test.ts

@@ -1,122 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Retriever } from '../../src/core/retriever.js';
-import type { MemoryEvent, MatchResult } from '../../src/core/types.js';
-import type { SearchResult } from '../../src/core/vector-store.js';
-
-class FakeEventStore {
-  constructor(private readonly events: Record<string, MemoryEvent>) {}
-
-  async getEvent(id: string): Promise<MemoryEvent | null> {
-    return this.events[id] || null;
-  }
-
-  async getSessionEvents(sessionId: string): Promise<MemoryEvent[]> {
-    return Object.values(this.events).filter((e) => e.sessionId === sessionId);
-  }
-
-  async getRecentEvents(): Promise<MemoryEvent[]> {
-    return Object.values(this.events);
-  }
-
-  async keywordSearch(query: string): Promise<Array<{ event: MemoryEvent; rank: number }>> {
-    const lowered = query.toLowerCase();
-    const matches = Object.values(this.events)
-      .filter((event) => event.content.toLowerCase().includes(lowered))
-      .map((event, index) => ({ event, rank: -(index + 1) }));
-    return matches;
-  }
-}
-
-class FakeVectorStore {
-  constructor(private readonly results: SearchResult[]) {}
-
-  async search(): Promise<SearchResult[]> {
-    return this.results;
-  }
-}
-
-class FakeEmbedder {
-  async embed(): Promise<{ vector: number[] }> {
-    return { vector: [0.1, 0.2, 0.3] };
-  }
-}
-
-class FakeMatcher {
-  matchSearchResults(results: SearchResult[]): MatchResult {
-    if (results.length === 0) {
-      return { match: null, confidence: 'none' };
-    }
-
-    const top = results[0];
-    return {
-      match: {
-        event: {
-          id: top.eventId,
-          eventType: top.eventType as MemoryEvent['eventType'],
-          sessionId: top.sessionId,
-          timestamp: new Date(top.timestamp),
-          content: top.content,
-          canonicalKey: top.eventId,
-          dedupeKey: top.eventId,
-          metadata: {}
-        },
-        score: top.score
-      },
-      confidence: 'suggested'
-    };
-  }
-}
-
-function makeEvent(id: string, content: string, metadata?: Record<string, unknown>): MemoryEvent {
-  return {
-    id,
-    eventType: 'user_prompt',
-    sessionId: 's1',
-    timestamp: new Date('2026-01-01T00:00:00.000Z'),
-    content,
-    canonicalKey: id,
-    dedupeKey: id,
-    metadata
-  };
-}
-
-describe('Retriever memU-inspired enhancements', () => {
-  it('applies metadata scope filter with hierarchical key path', async () => {
-    const e1 = makeEvent('e1', 'first memory', { scope: { project: { id: 'alpha' } } });
-    const e2 = makeEvent('e2', 'second memory', { scope: { project: { id: 'beta' } } });
-
-    const retriever = new Retriever(
-      new FakeEventStore({ e1, e2 }) as any,
-      new FakeVectorStore([
-        { id: '1', eventId: 'e1', content: e1.content, score: 0.9, sessionId: 's1', eventType: e1.eventType, timestamp: e1.timestamp.toISOString() },
-        { id: '2', eventId: 'e2', content: e2.content, score: 0.89, sessionId: 's1', eventType: e2.eventType, timestamp: e2.timestamp.toISOString() }
-      ]) as any,
-      new FakeEmbedder() as any,
-      new FakeMatcher() as any
-    );
-
-    const result = await retriever.retrieve('memory', {
-      scope: { metadata: { 'scope.project.id': 'alpha' } }
-    });
-
-    expect(result.memories).toHaveLength(1);
-    expect(result.memories[0].event.id).toBe('e1');
-  });
-
-  it('uses fast strategy keyword retrieval when requested', async () => {
-    const e1 = makeEvent('e1', 'fix deployment issue with nginx');
-    const e2 = makeEvent('e2', 'random unrelated text');
-
-    const retriever = new Retriever(
-      new FakeEventStore({ e1, e2 }) as any,
-      new FakeVectorStore([]) as any,
-      new FakeEmbedder() as any,
-      new FakeMatcher() as any
-    );
-
-    const result = await retriever.retrieve('deployment', { strategy: 'fast', topK: 5 });
-
-    expect(result.memories.length).toBeGreaterThan(0);
-    expect(result.memories[0].event.id).toBe('e1');
-  });
-});