claude-memory-layer 1.0.27 → 1.0.28

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

@@ -0,0 +1,185 @@
+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/{retriever-fallback-chain.test.ts → core/retriever-fallback-chain.test.ts}

@@ -1,7 +1,7 @@
 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';
+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 {

package/tests/{retriever-strategy-scope.test.ts → core/retriever-strategy-scope.test.ts}

@@ -1,7 +1,7 @@
 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';
+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 {
@@ -94,4 +94,71 @@ describe('Retriever strategy/scope', () => {
     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/{retriever.memu-adoption.test.ts → core/retriever.memu-adoption.test.ts}

@@ -1,7 +1,7 @@
 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';
+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>) {}

package/tests/core/session-history-importer-filter.test.ts

@@ -0,0 +1,78 @@
+import { mkdtempSync, rmSync, utimesSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  isClaudeLocalCommandArtifact,
+  isWorthStoringPrompt,
+  SessionHistoryImporter,
+  type ImportResult
+} from '../../src/services/session-history-importer.js';
+
+const tempDirs: string[] = [];
+
+function tempDir() {
+  const dir = mkdtempSync(join(tmpdir(), 'cml-session-importer-'));
+  tempDirs.push(dir);
+  return dir;
+}
+
+function makeImportResult(overrides: Partial<ImportResult> = {}): ImportResult {
+  return {
+    totalSessions: 1,
+    totalMessages: 1,
+    importedPrompts: 1,
+    importedResponses: 0,
+    skippedDuplicates: 0,
+    errors: [],
+    ...overrides
+  };
+}
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe('session history importer prompt filtering', () => {
+  it('drops Claude local-command artifacts that dilute retrieval quality', () => {
+    const artifact = `<command-name>/model</command-name>\n<local-command-stdout>Using model opus</local-command-stdout>`;
+
+    expect(isClaudeLocalCommandArtifact(artifact)).toBe(true);
+    expect(isWorthStoringPrompt(artifact)).toBe(false);
+  });
+
+  it('keeps substantive imported user prompts', () => {
+    expect(isWorthStoringPrompt('이 프로젝트에서 memory retrieval 구조를 더 가볍게 개선해줘')).toBe(true);
+  });
+
+  it('imports only the most recently modified matching Claude session when sessionLimit is set', async () => {
+    const dir = tempDir();
+    const older = join(dir, 'older.jsonl');
+    const newest = join(dir, 'newest.jsonl');
+    const oldest = join(dir, 'oldest.jsonl');
+    for (const filePath of [older, newest, oldest]) {
+      writeFileSync(filePath, '{}\n', 'utf8');
+    }
+    utimesSync(oldest, new Date('2026-05-01T00:00:00.000Z'), new Date('2026-05-01T00:00:00.000Z'));
+    utimesSync(older, new Date('2026-05-02T00:00:00.000Z'), new Date('2026-05-02T00:00:00.000Z'));
+    utimesSync(newest, new Date('2026-05-03T00:00:00.000Z'), new Date('2026-05-03T00:00:00.000Z'));
+
+    const importer = new SessionHistoryImporter({} as never) as SessionHistoryImporter & {
+      findProjectDirs: ReturnType<typeof vi.fn>;
+      findSessionFiles: ReturnType<typeof vi.fn>;
+      importSessionFile: ReturnType<typeof vi.fn>;
+    };
+    importer.findProjectDirs = vi.fn(async () => [dir]);
+    importer.findSessionFiles = vi.fn(async () => [older, newest, oldest]);
+    importer.importSessionFile = vi.fn(async () => makeImportResult());
+
+    const result = await importer.importProject('/repo/current', { sessionLimit: 1 });
+
+    expect(result.totalSessions).toBe(1);
+    expect(importer.importSessionFile).toHaveBeenCalledTimes(1);
+    expect(importer.importSessionFile).toHaveBeenCalledWith(newest, expect.objectContaining({ sessionLimit: 1 }));
+  });
+});

package/tests/core/session-qrels.test.ts

@@ -0,0 +1,250 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import * as path from 'node:path';
+import { tmpdir } from 'node:os';
+
+import { describe, expect, it } from 'vitest';
+
+import {
+  buildSessionQrelsFixtureFromJsonl,
+  collectClaudeSessionJsonlFiles,
+  summarizeSessionQrelsFixture
+} from '../../src/core/session-qrels.js';
+
+describe('session qrels fixture generation', () => {
+  it('turns Claude-style user/assistant session turns into replay qrels', () => {
+    const jsonl = [
+      JSON.stringify({
+        type: 'user',
+        sessionId: 's1',
+        message: { role: 'user', content: 'retrieval benchmark should report nDCG and precision together' },
+        timestamp: '2026-05-05T00:00:00.000Z'
+      }),
+      JSON.stringify({
+        type: 'assistant',
+        sessionId: 's1',
+        message: { role: 'assistant', content: [{ type: 'text', text: 'Use graded relevance qrels and report nDCG@k beside Precision@k and Recall@k.' }] },
+        timestamp: '2026-05-05T00:01:00.000Z'
+      }),
+      JSON.stringify({
+        type: 'user',
+        sessionId: 's1',
+        message: { role: 'user', content: '<command-name>/model</command-name>\n<local-command-stdout>opus</local-command-stdout>' }
+      }),
+      JSON.stringify({
+        type: 'assistant',
+        sessionId: 's1',
+        message: { role: 'assistant', content: 'This local command result must not become a benchmark qrel.' }
+      }),
+      JSON.stringify({
+        type: 'user',
+        sessionId: 's1',
+        message: { role: 'user', content: [{ type: 'text', text: 'fast search CLI should avoid embedding startup for qrels smoke tests' }] }
+      }),
+      JSON.stringify({
+        type: 'assistant',
+        sessionId: 's1',
+        message: { role: 'assistant', content: 'Fast search benchmark fixtures should stay lightweight and deterministic.' }
+      })
+    ].join('\n');
+
+    const fixture = buildSessionQrelsFixtureFromJsonl(jsonl, {
+      name: 'session-qrels-test',
+      ks: [1, 3]
+    });
+
+    expect(fixture.name).toBe('session-qrels-test');
+    expect(fixture.ks).toEqual([1, 3]);
+    expect(fixture.queries).toHaveLength(2);
+    expect(fixture.memories).toHaveLength(2);
+    expect(fixture.queries[0]).toMatchObject({
+      queryId: 'q-s1-1',
+      query: 'retrieval benchmark should report nDCG and precision together',
+      expectedIds: ['m-s1-1'],
+      expectedRelevance: { 'm-s1-1': 2 }
+    });
+    expect(fixture.memories[0]).toMatchObject({
+      id: 'm-s1-1',
+      content: 'Use graded relevance qrels and report nDCG@k beside Precision@k and Recall@k.',
+      sourceSessionId: 's1'
+    });
+    expect(fixture.queries.map((query) => query.query)).not.toContain('opus');
+  });
+
+  it('pairs pending prompts independently per session id', () => {
+    const jsonl = [
+      JSON.stringify({
+        type: 'user',
+        sessionId: 's1',
+        message: { role: 'user', content: 'session one asks about retrieval replay metrics' }
+      }),
+      JSON.stringify({
+        type: 'user',
+        sessionId: 's2',
+        message: { role: 'user', content: 'session two asks about qrels generation safety' }
+      }),
+      JSON.stringify({
+        type: 'assistant',
+        sessionId: 's1',
+        message: { role: 'assistant', content: 'Session one answer explains nDCG replay metrics.' }
+      }),
+      JSON.stringify({
+        type: 'assistant',
+        sessionId: 's2',
+        message: { role: 'assistant', content: 'Session two answer explains qrels generation safety.' }
+      })
+    ].join('\n');
+
+    const fixture = buildSessionQrelsFixtureFromJsonl(jsonl);
+
+    expect(fixture.queries.map((query) => [query.queryId, query.query])).toEqual([
+      ['q-s1-1', 'session one asks about retrieval replay metrics'],
+      ['q-s2-1', 'session two asks about qrels generation safety']
+    ]);
+    expect(fixture.memories.map((memory) => [memory.id, memory.content])).toEqual([
+      ['m-s1-1', 'Session one answer explains nDCG replay metrics.'],
+      ['m-s2-1', 'Session two answer explains qrels generation safety.']
+    ]);
+  });
+
+  it('adds known-answer labels and explicit no-match qrels', () => {
+    const jsonl = [
+      JSON.stringify({
+        type: 'user',
+        sessionId: 's-known',
+        message: { role: 'user', content: 'how should replay qrels record known answer fixtures' }
+      }),
+      JSON.stringify({
+        type: 'assistant',
+        sessionId: 's-known',
+        message: { role: 'assistant', content: 'Known-answer qrels should keep the expected assistant answer tied to the expected memory id.' }
+      })
+    ].join('\n');
+
+    const fixture = buildSessionQrelsFixtureFromJsonl(jsonl, {
+      noMatchQueries: [
+        {
+          queryId: 'q-negative-empty-result',
+          query: 'unanswered moon cheese deployment question',
+          forbiddenIds: ['m-s-known-1'],
+          sourceSessionId: 's-known'
+        }
+      ]
+    });
+
+    expect(fixture.queries).toHaveLength(2);
+    expect(fixture.queries[0]).toMatchObject({
+      queryId: 'q-s-known-1',
+      expectation: 'match',
+      expectedIds: ['m-s-known-1'],
+      knownAnswer: 'Known-answer qrels should keep the expected assistant answer tied to the expected memory id.'
+    });
+    expect(fixture.queries[1]).toMatchObject({
+      queryId: 'q-negative-empty-result',
+      query: 'unanswered moon cheese deployment question',
+      expectation: 'no_match',
+      expectedIds: [],
+      expectedRelevance: {},
+      forbiddenIds: ['m-s-known-1'],
+      sourceSessionId: 's-known'
+    });
+
+    const summary = summarizeSessionQrelsFixture(fixture);
+    expect(summary).toMatchObject({
+      queryCount: 2,
+      positiveQueryCount: 1,
+      noMatchQueryCount: 1,
+      knownAnswerCount: 1
+    });
+  });
+
+  it('can redact raw session text when generating shareable qrels metadata', () => {
+    const jsonl = [
+      JSON.stringify({
+        type: 'user',
+        sessionId: 'sensitive',
+        message: { role: 'user', content: 'SECRET customer project prompt should not leak' }
+      }),
+      JSON.stringify({
+        type: 'assistant',
+        sessionId: 'sensitive',
+        message: { role: 'assistant', content: 'SECRET implementation answer should not leak' }
+      })
+    ].join('\n');
+
+    const fixture = buildSessionQrelsFixtureFromJsonl(jsonl, { redactContent: true });
+    const serialized = JSON.stringify(fixture);
+
+    expect(serialized).not.toContain('SECRET');
+    expect(fixture.queries[0]).toMatchObject({
+      queryId: 'q-sensitive-1',
+      query: '[redacted query q-sensitive-1]',
+      expectedIds: ['m-sensitive-1']
+    });
+    expect(fixture.memories[0]).toMatchObject({
+      id: 'm-sensitive-1',
+      content: '[redacted memory m-sensitive-1]'
+    });
+  });
+
+  it('summarizes generated qrels without leaking raw prompt or memory content', () => {
+    const jsonl = [
+      JSON.stringify({
+        type: 'user',
+        sessionId: 'sensitive',
+        message: { role: 'user', content: 'SECRET customer retrieval question with enough words' }
+      }),
+      JSON.stringify({
+        type: 'assistant',
+        sessionId: 'sensitive',
+        message: { role: 'assistant', content: 'SECRET assistant answer that should stay out of reports' }
+      })
+    ].join('\n');
+    const fixture = buildSessionQrelsFixtureFromJsonl(jsonl, {
+      name: 'private-real-session-qrels',
+      ks: [1, 3, 10],
+      sourceFileCount: 2,
+      rawContentIncluded: true
+    });
+
+    const summary = summarizeSessionQrelsFixture(fixture);
+    const serialized = JSON.stringify(summary);
+
+    expect(summary).toMatchObject({
+      name: 'private-real-session-qrels',
+      queryCount: 1,
+      memoryCount: 1,
+      sourceSessionCount: 1,
+      sourceFileCount: 2,
+      rawContentIncluded: true,
+      ks: [1, 3, 10]
+    });
+    expect(summary.perSession).toEqual([
+      {
+        sourceSessionId: 'sensitive',
+        queryCount: 1,
+        memoryCount: 1,
+        firstTurnIndex: 1,
+        lastTurnIndex: 1
+      }
+    ]);
+    expect(serialized).not.toContain('SECRET');
+  });
+
+  it('collects Claude JSONL sessions recursively while excluding subagents by default', async () => {
+    const root = path.join(tmpdir(), `session-qrels-${process.pid}-${Date.now()}`);
+    const projectDir = path.join(root, 'project-a');
+    const subagentDir = path.join(projectDir, 'subagents');
+    await mkdir(subagentDir, { recursive: true });
+    await writeFile(path.join(projectDir, 'top.jsonl'), '{}\n', 'utf8');
+    await writeFile(path.join(subagentDir, 'agent.jsonl'), '{}\n', 'utf8');
+    await writeFile(path.join(projectDir, 'notes.txt'), 'ignore', 'utf8');
+
+    await expect(collectClaudeSessionJsonlFiles(root)).resolves.toEqual([
+      path.join(projectDir, 'top.jsonl')
+    ]);
+    await expect(collectClaudeSessionJsonlFiles(root, { includeSubagents: true })).resolves.toEqual([
+      path.join(subagentDir, 'agent.jsonl'),
+      path.join(projectDir, 'top.jsonl')
+    ]);
+  });
+});

package/tests/{sqlite-event-store-replication.test.ts → core/sqlite-event-store-replication.test.ts}

@@ -7,7 +7,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 
-import { SQLiteEventStore } from '../src/core/sqlite-event-store.js';
+import { SQLiteEventStore } from '../../src/core/sqlite-event-store.js';
 
 describe('SQLiteEventStore replication helpers', () => {
   let tempDir: string;
@@ -88,5 +88,40 @@ describe('SQLiteEventStore replication helpers', () => {
     expect(dup.isDuplicate).toBe(true);
     expect(dup.eventId).toBe(sourceEvent!.id);
   });
+
+  it('keeps FTS event_id populated after deleteSessionEvents recreates triggers', async () => {
+    await storeA.append({ eventType: 'user_prompt', sessionId: 'delete-me', timestamp: new Date(), content: 'temporary kiwi memory' });
+    await storeA.append({ eventType: 'user_prompt', sessionId: 'keep-me', timestamp: new Date(), content: 'persistent pineapple memory' });
+
+    await expect(storeA.deleteSessionEvents('delete-me')).resolves.toBe(1);
+
+    const appendAfterTriggerRecreation = await storeA.append({
+      eventType: 'user_prompt',
+      sessionId: 'keep-me',
+      timestamp: new Date(),
+      content: 'fresh dragonfruit memory'
+    });
+    expect(appendAfterTriggerRecreation.success).toBe(true);
+
+    await expect(storeA.rebuildFtsIndex()).resolves.toBe(2);
+    const results = await storeA.keywordSearch('dragonfruit', 5);
+
+    expect(results.map((result) => result.event.content)).toEqual(['fresh dragonfruit memory']);
+  });
+
+  it('supports event updates and deletes on a fresh FTS table before manual rebuild', async () => {
+    const appendResult = await storeA.append({
+      eventType: 'user_prompt',
+      sessionId: 'mutable-session',
+      timestamp: new Date(),
+      content: 'mutable mango memory'
+    });
+    expect(appendResult.success).toBe(true);
+    if (!appendResult.success) return;
+
+    await expect(storeA.incrementAccessCount([appendResult.eventId])).resolves.toBeUndefined();
+    await expect(storeA.deleteSessionEvents('mutable-session')).resolves.toBe(1);
+    await expect(storeA.keywordSearch('mango', 5)).resolves.toEqual([]);
+  });
 });