claude-memory-layer 1.0.30 → 1.0.32

package/tests/core/memory-ingest-service.test.ts

@@ -1,296 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-
-import { MemoryIngestService } from '../../src/core/engine/memory-ingest-service.js';
-import type { AppendResult, MemoryEvent, MemoryEventInput, ToolObservationPayload } from '../../src/core/types.js';
-
-function event(overrides: Partial<MemoryEvent>): MemoryEvent {
-  return {
-    id: '11111111-1111-4111-8111-111111111111',
-    eventType: 'user_prompt',
-    sessionId: 'session-1',
-    timestamp: new Date('2026-04-30T00:00:00.000Z'),
-    content: 'default content',
-    canonicalKey: 'default-content',
-    dedupeKey: 'session-1:default-content',
-    metadata: {},
-    ...overrides
-  };
-}
-
-interface CreateServiceOptions {
-  eventsBySession?: Record<string, MemoryEvent[]>;
-  projectHash?: string | null;
-  projectPath?: string | null;
-  appendResult?: AppendResult;
-}
-
-function createService(options: CreateServiceOptions = {}) {
-  const eventsBySession = options.eventsBySession ?? {};
-  const appended: MemoryEventInput[] = [];
-  const initialize = vi.fn(async () => {});
-  const store = {
-    upsertSession: vi.fn(async () => {}),
-    getSessionEvents: vi.fn(async (sessionId: string) => eventsBySession[sessionId] ?? []),
-    getSessionsWithoutSummary: vi.fn(async () => Object.keys(eventsBySession)),
-    append: vi.fn(async (input: MemoryEventInput): Promise<AppendResult> => {
-      appended.push(input);
-      return options.appendResult ?? { success: true, eventId: `event-${appended.length}`, isDuplicate: false };
-    }),
-    enqueueForEmbedding: vi.fn(async (_eventId: string, _content: string) => {})
-  };
-  const markdownMirror = {
-    append: vi.fn(async (_input: MemoryEventInput, _eventId?: string) => {})
-  };
-  const createToolEmbedding = vi.fn((payload: ToolObservationPayload) => `${payload.toolName}:${payload.success}`);
-
-  return {
-    service: new MemoryIngestService({
-      initialize,
-      eventStore: store,
-      markdownMirror,
-      createToolEmbedding,
-      getProjectHash: () => options.projectHash ?? null,
-      getProjectPath: () => options.projectPath ?? null
-    }),
-    initialize,
-    store,
-    markdownMirror,
-    createToolEmbedding,
-    appended
-  };
-}
-
-describe('MemoryIngestService ingest pipeline', () => {
-  it('normalizes metadata, runs interceptors, appends, enqueues embeddings, and mirrors successful events', async () => {
-    const { service, store, markdownMirror, appended } = createService({
-      projectHash: 'project-hash-1',
-      projectPath: '/workspace/project'
-    });
-    const stages: string[] = [];
-
-    service.registerIngestBefore((context) => {
-      stages.push(`${context.stage}:${context.operation}`);
-      expect(context.sessionId).toBe('session-1');
-      expect(context.event.metadata).toMatchObject({
-        ingest: { operation: 'user_prompt', pipeline: 'default' },
-        scope: {
-          project: { hash: 'project-hash-1', path: '/workspace/project' },
-          turn: { id: 'turn-1' }
-        },
-        tags: ['user:alice', 'legacy', 'proj:project-hash-1']
-      });
-    });
-    service.registerIngestAfter((context) => {
-      stages.push(`${context.stage}:${context.operation}`);
-      expect(context.event).toBe(appended[0]);
-    });
-
-    const result = await service.storeUserPrompt('session-1', 'remember this', {
-      scope: { turn: { id: 'turn-1' } },
-      tags: [' user:alice ', 'bad:tag', 'legacy']
-    });
-
-    expect(result).toEqual({ success: true, eventId: 'event-1', isDuplicate: false });
-    expect(store.append).toHaveBeenCalledOnce();
-    expect(appended[0]).toMatchObject({
-      eventType: 'user_prompt',
-      sessionId: 'session-1',
-      content: 'remember this',
-      metadata: {
-        ingest: { operation: 'user_prompt', pipeline: 'default' },
-        scope: {
-          project: { hash: 'project-hash-1', path: '/workspace/project' },
-          turn: { id: 'turn-1' }
-        },
-        tags: ['user:alice', 'legacy', 'proj:project-hash-1']
-      }
-    });
-    expect((appended[0].metadata as Record<string, unknown>).ingest).toMatchObject({
-      ts: expect.any(String)
-    });
-    expect(store.enqueueForEmbedding).toHaveBeenCalledWith('event-1', 'remember this');
-    expect(markdownMirror.append).toHaveBeenCalledWith(appended[0], 'event-1');
-    expect(stages).toEqual(['before:user_prompt', 'after:user_prompt']);
-  });
-
-  it('does not enqueue embeddings or mirror duplicate append results', async () => {
-    const { service, store, markdownMirror } = createService({
-      appendResult: { success: true, eventId: 'duplicate-event', isDuplicate: true }
-    });
-
-    await expect(service.storeAgentResponse('session-1', 'duplicate response')).resolves.toEqual({
-      success: true,
-      eventId: 'duplicate-event',
-      isDuplicate: true
-    });
-
-    expect(store.enqueueForEmbedding).not.toHaveBeenCalled();
-    expect(markdownMirror.append).not.toHaveBeenCalled();
-  });
-
-  it('keeps markdown mirror failures non-breaking after a successful append', async () => {
-    const { service, store, markdownMirror } = createService();
-    markdownMirror.append.mockRejectedValueOnce(new Error('mirror is read-only'));
-
-    await expect(service.storeSessionSummary('session-1', 'summary')).resolves.toEqual({
-      success: true,
-      eventId: 'event-1',
-      isDuplicate: false
-    });
-
-    expect(store.enqueueForEmbedding).toHaveBeenCalledWith('event-1', 'summary');
-    expect(markdownMirror.append).toHaveBeenCalledOnce();
-  });
-
-  it('runs error interceptors and skips side effects when append returns a failure result', async () => {
-    const { service, store, markdownMirror } = createService({
-      appendResult: { success: false, error: 'sqlite append failed' }
-    });
-    const stages: string[] = [];
-    const errors: Error[] = [];
-    service.registerIngestAfter((context) => {
-      stages.push(context.stage);
-    });
-    service.registerIngestOnError((context) => {
-      stages.push(context.stage);
-      errors.push(context.error!);
-      expect(context.operation).toBe('agent_response');
-      expect(context.event.eventType).toBe('agent_response');
-    });
-
-    await expect(service.storeAgentResponse('session-1', 'failed append')).resolves.toEqual({
-      success: false,
-      error: 'sqlite append failed'
-    });
-
-    expect(errors.map((error) => error.message)).toEqual(['sqlite append failed']);
-    expect(stages).toEqual(['error']);
-    expect(store.enqueueForEmbedding).not.toHaveBeenCalled();
-    expect(markdownMirror.append).not.toHaveBeenCalled();
-  });
-
-  it('runs error interceptors and skips side effects when append throws', async () => {
-    const { service, store, markdownMirror } = createService();
-    const error = new Error('sqlite unavailable');
-    store.append.mockRejectedValueOnce(error);
-    const errors: Error[] = [];
-    service.registerIngestOnError((context) => {
-      errors.push(context.error!);
-      expect(context.stage).toBe('error');
-      expect(context.operation).toBe('tool_observation');
-      expect(context.event.eventType).toBe('tool_observation');
-    });
-
-    await expect(service.storeToolObservation('session-1', {
-      toolName: 'terminal',
-      success: false,
-      metadata: { turnId: 'turn-2' },
-      output: 'failed'
-    })).rejects.toThrow('sqlite unavailable');
-
-    expect(errors).toEqual([error]);
-    expect(store.enqueueForEmbedding).not.toHaveBeenCalled();
-    expect(markdownMirror.append).not.toHaveBeenCalled();
-  });
-});
-
-describe('MemoryIngestService session summary generation', () => {
-  it('generates the legacy rule-based summary and stores it through the ingest pipeline', async () => {
-    const { service, initialize, store, appended } = createService({
-      eventsBySession: {
-        'session-1': [
-          event({ id: '11111111-1111-4111-8111-111111111111', eventType: 'user_prompt', content: '첫 번째 작업 요청\n자세한 설명', timestamp: new Date('2026-04-30T01:00:00.000Z') }),
-          event({ id: '22222222-2222-4222-8222-222222222222', eventType: 'agent_response', content: '응답', timestamp: new Date('2026-04-30T01:01:00.000Z') }),
-          event({ id: '33333333-3333-4333-8333-333333333333', eventType: 'tool_observation', content: '{}', timestamp: new Date('2026-04-30T01:02:00.000Z'), metadata: { toolName: 'terminal', exitCode: 1 } }),
-          event({ id: '44444444-4444-4444-8444-444444444444', eventType: 'tool_observation', content: '{}', timestamp: new Date('2026-04-30T01:03:00.000Z'), metadata: { toolName: 'terminal', exitCode: 0 } }),
-          event({ id: '55555555-5555-4555-8555-555555555555', eventType: 'user_prompt', content: '두 번째 요청', timestamp: new Date('2026-04-30T01:04:00.000Z') })
-        ]
-      }
-    });
-
-    await service.generateSessionSummary('session-1');
-
-    expect(initialize).toHaveBeenCalledOnce();
-    expect(store.getSessionEvents).toHaveBeenCalledWith('session-1');
-    expect(appended).toHaveLength(1);
-    expect(store.enqueueForEmbedding).toHaveBeenCalledWith(
-      'event-1',
-      '[2026-04-30] 2턴 세션. 주요 작업: 첫 번째 작업 요청 자세한 설명. 사용 툴: terminal. 오류 1건 발생'
-    );
-    expect(appended[0]).toMatchObject({
-      eventType: 'session_summary',
-      sessionId: 'session-1',
-      content: '[2026-04-30] 2턴 세션. 주요 작업: 첫 번째 작업 요청 자세한 설명. 사용 툴: terminal. 오류 1건 발생',
-      metadata: {
-        ingest: { operation: 'session_summary', pipeline: 'default' },
-        generated: 'rule-based',
-        eventCount: 5
-      }
-    });
-  });
-
-  it('does not create another summary for too-short or already summarized sessions', async () => {
-    const { service, appended } = createService({
-      eventsBySession: {
-        short: [
-          event({ id: '11111111-1111-4111-8111-111111111111', sessionId: 'short' }),
-          event({ id: '22222222-2222-4222-8222-222222222222', sessionId: 'short', eventType: 'agent_response' })
-        ],
-        summarized: [
-          event({ id: '33333333-3333-4333-8333-333333333333', sessionId: 'summarized' }),
-          event({ id: '44444444-4444-4444-8444-444444444444', sessionId: 'summarized', eventType: 'agent_response' }),
-          event({ id: '55555555-5555-4555-8555-555555555555', sessionId: 'summarized', eventType: 'session_summary', content: 'already summarized' })
-        ]
-      }
-    });
-
-    await service.generateSessionSummary('short');
-    await service.generateSessionSummary('summarized');
-
-    expect(appended).toEqual([]);
-  });
-
-  it('backfills only missing summary candidates and keeps failures non-critical', async () => {
-    const { service, store, appended } = createService({
-      eventsBySession: {
-        candidate: [
-          event({ id: '11111111-1111-4111-8111-111111111111', sessionId: 'candidate', eventType: 'user_prompt', content: '분석 작업' }),
-          event({ id: '22222222-2222-4222-8222-222222222222', sessionId: 'candidate', eventType: 'agent_response', content: '응답' }),
-          event({ id: '33333333-3333-4333-8333-333333333333', sessionId: 'candidate', eventType: 'tool_observation', content: '{}', metadata: { toolName: 'read_file' } })
-        ],
-        tooShort: [
-          event({ id: '44444444-4444-4444-8444-444444444444', sessionId: 'tooShort', eventType: 'user_prompt' })
-        ],
-        broken: [
-          event({ id: '55555555-5555-4555-8555-555555555555', sessionId: 'broken', eventType: 'user_prompt' }),
-          event({ id: '66666666-6666-4666-8666-666666666666', sessionId: 'broken', eventType: 'agent_response' }),
-          event({ id: '77777777-7777-4777-8777-777777777777', sessionId: 'broken', eventType: 'tool_observation' })
-        ]
-      }
-    });
-    store.getSessionsWithoutSummary.mockResolvedValueOnce(['candidate', 'tooShort', 'broken']);
-    store.getSessionEvents.mockImplementation(async (sessionId: string) => {
-      if (sessionId === 'broken') throw new Error('corrupt session');
-      return (store as any).__eventsBySession?.[sessionId] ?? [];
-    });
-    (store as any).__eventsBySession = {
-      candidate: [
-        event({ id: '11111111-1111-4111-8111-111111111111', sessionId: 'candidate', eventType: 'user_prompt', content: '분석 작업' }),
-        event({ id: '22222222-2222-4222-8222-222222222222', sessionId: 'candidate', eventType: 'agent_response', content: '응답' }),
-        event({ id: '33333333-3333-4333-8333-333333333333', sessionId: 'candidate', eventType: 'tool_observation', content: '{}', metadata: { toolName: 'read_file' } })
-      ],
-      tooShort: [
-        event({ id: '44444444-4444-4444-8444-444444444444', sessionId: 'tooShort', eventType: 'user_prompt' })
-      ]
-    };
-
-    await expect(service.backfillMissingSummaries('current-session', 7)).resolves.toBeUndefined();
-
-    expect(store.getSessionsWithoutSummary).toHaveBeenCalledWith('current-session', 7);
-    expect(store.getSessionEvents).toHaveBeenCalledWith('candidate');
-    expect(store.getSessionEvents).toHaveBeenCalledWith('tooShort');
-    expect(store.getSessionEvents).toHaveBeenCalledWith('broken');
-    expect(appended).toHaveLength(1);
-    expect(appended[0].sessionId).toBe('candidate');
-  });
-});

package/tests/core/memory-query-service.test.ts

@@ -1,129 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-
-import { MemoryQueryService } from '../../src/core/engine/memory-query-service.js';
-import type { MemoryEvent } from '../../src/core/types.js';
-
-function event(overrides: Partial<MemoryEvent> = {}): MemoryEvent {
-  return {
-    id: '11111111-1111-4111-8111-111111111111',
-    eventType: 'user_prompt',
-    sessionId: 'session-1',
-    timestamp: new Date('2026-05-02T00:00:00.000Z'),
-    content: 'default content',
-    canonicalKey: 'default-content',
-    dedupeKey: 'session-1:default-content',
-    metadata: {},
-    ...overrides
-  };
-}
-
-function createService() {
-  const initialize = vi.fn(async () => {});
-  const events = [event()];
-  const turn = {
-    turnId: 'turn-1',
-    events,
-    startedAt: new Date('2026-05-02T00:00:00.000Z'),
-    promptPreview: 'default content',
-    eventCount: 1,
-    toolCount: 0,
-    hasResponse: false
-  };
-  const outboxStats = {
-    embedding: { pending: 1, processing: 2, failed: 3, total: 6 },
-    vector: { pending: 4, processing: 5, failed: 6, total: 15 }
-  };
-  const queryStore = {
-    keywordSearch: vi.fn(async () => [{ event: events[0], rank: -0.5 }]),
-    getSessionEvents: vi.fn(async () => events),
-    getRecentEvents: vi.fn(async () => events),
-    rebuildFtsIndex: vi.fn(async () => 7),
-    getOutboxStats: vi.fn(async () => outboxStats),
-    getEventsByLevel: vi.fn(async () => events),
-    getEventLevel: vi.fn(async () => 'working'),
-    getSessionTurns: vi.fn(async () => [turn]),
-    getEventsByTurn: vi.fn(async () => events),
-    countSessionTurns: vi.fn(async () => 11),
-    backfillTurnIds: vi.fn(async () => 13),
-    deleteSessionEvents: vi.fn(async () => 17)
-  };
-  const vectorStore = {
-    count: vi.fn(async () => 19)
-  };
-  const graduation = {
-    getStats: vi.fn(async () => [{ level: 'working', count: 23 }])
-  };
-
-  return {
-    service: new MemoryQueryService(initialize, queryStore, { vectorStore, graduation }),
-    initialize,
-    queryStore,
-    vectorStore,
-    graduation,
-    events,
-    turn,
-    outboxStats
-  };
-}
-
-describe('MemoryQueryService', () => {
-  it('delegates read and maintenance methods through the initialized store boundary', async () => {
-    const { service, initialize, queryStore, events, turn, outboxStats } = createService();
-
-    await expect(service.rebuildFtsIndex()).resolves.toBe(7);
-    await expect(service.getOutboxStats()).resolves.toEqual(outboxStats);
-    await expect(service.getEventsByLevel('working', { limit: 2, offset: 3 })).resolves.toEqual(events);
-    await expect(service.getEventLevel('event-1')).resolves.toBe('working');
-    await expect(service.getSessionTurns('session-1', { limit: 5, offset: 8 })).resolves.toEqual([turn]);
-    await expect(service.getEventsByTurn('turn-1')).resolves.toEqual(events);
-    await expect(service.countSessionTurns('session-1')).resolves.toBe(11);
-    await expect(service.backfillTurnIds()).resolves.toBe(13);
-    await expect(service.deleteSessionEvents('session-1')).resolves.toBe(17);
-
-    expect(initialize).toHaveBeenCalledTimes(9);
-    expect(queryStore.rebuildFtsIndex).toHaveBeenCalledOnce();
-    expect(queryStore.getOutboxStats).toHaveBeenCalledOnce();
-    expect(queryStore.getEventsByLevel).toHaveBeenCalledWith('working', { limit: 2, offset: 3 });
-    expect(queryStore.getEventLevel).toHaveBeenCalledWith('event-1');
-    expect(queryStore.getSessionTurns).toHaveBeenCalledWith('session-1', { limit: 5, offset: 8 });
-    expect(queryStore.getEventsByTurn).toHaveBeenCalledWith('turn-1');
-    expect(queryStore.countSessionTurns).toHaveBeenCalledWith('session-1');
-    expect(queryStore.backfillTurnIds).toHaveBeenCalledOnce();
-    expect(queryStore.deleteSessionEvents).toHaveBeenCalledWith('session-1');
-  });
-
-  it('composes memory statistics from event, vector, and graduation stores', async () => {
-    const { service, initialize, queryStore, vectorStore, graduation } = createService();
-
-    await expect(service.getStats()).resolves.toEqual({
-      totalEvents: 1,
-      vectorCount: 19,
-      levelStats: [{ level: 'working', count: 23 }]
-    });
-
-    expect(initialize).toHaveBeenCalledOnce();
-    expect(queryStore.getRecentEvents).toHaveBeenCalledWith(10000);
-    expect(vectorStore.count).toHaveBeenCalledOnce();
-    expect(graduation.getStats).toHaveBeenCalledOnce();
-  });
-
-  it('keeps lightweight read methods usable with only the narrow query store', async () => {
-    const initialize = vi.fn(async () => {});
-    const events = [event({ id: '22222222-2222-4222-8222-222222222222' })];
-    const queryStore = {
-      keywordSearch: vi.fn(async () => [{ event: events[0], rank: -0.5 }]),
-      getSessionEvents: vi.fn(async () => events),
-      getRecentEvents: vi.fn(async () => events)
-    };
-    const service = new MemoryQueryService(initialize, queryStore);
-
-    await expect(service.keywordSearch('query', { topK: 3 })).resolves.toEqual([{ event: events[0], score: 1 }]);
-    await expect(service.getSessionHistory('session-1')).resolves.toBe(events);
-    await expect(service.getRecentEvents(2)).resolves.toBe(events);
-
-    expect(initialize).toHaveBeenCalledTimes(3);
-    expect(queryStore.keywordSearch).toHaveBeenCalledWith('query', 3);
-    expect(queryStore.getSessionEvents).toHaveBeenCalledWith('session-1');
-    expect(queryStore.getRecentEvents).toHaveBeenCalledWith(2);
-  });
-});

package/tests/core/memory-runtime-service.test.ts

@@ -1,201 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import {
-  createMemoryRuntimeService,
-  type MemoryRuntimeServicesFactories
-} from '../../src/core/engine/memory-runtime-service.js';
-import type { EventStore } from '../../src/core/event-store.js';
-import type { Embedder } from '../../src/core/embedder.js';
-import type { GraduationPipeline } from '../../src/core/graduation.js';
-import type { Retriever } from '../../src/core/retriever.js';
-import type { VectorStore } from '../../src/core/vector-store.js';
-
-function makeHarness(options?: { readOnly?: boolean; lightweightMode?: boolean; embeddingOnly?: boolean }) {
-  const calls: string[] = [];
-  const eventStore = { marker: 'event-store' } as unknown as EventStore;
-  const vectorStore = {
-    initialize: async () => { calls.push('vector.initialize'); }
-  } as unknown as VectorStore;
-  const embedder = {
-    initialize: async () => { calls.push('embedder.initialize'); }
-  } as unknown as Embedder;
-  const graduation = {
-    marker: 'graduation',
-    recordAccess: (eventId: string, sessionId: string, confidence: number = 1.0) => {
-      calls.push(`graduation.recordAccess:${eventId}:${sessionId}:${confidence}`);
-    }
-  } as unknown as GraduationPipeline;
-  const retriever = {
-    setGraduationPipeline: (pipeline: GraduationPipeline) => {
-      calls.push(pipeline === graduation ? 'retriever.setGraduationPipeline' : 'retriever.setGraduationPipeline:unknown');
-    }
-  } as unknown as Retriever;
-
-  const vectorWorker = {
-    start: () => { calls.push('vectorWorker.start'); },
-    stop: () => { calls.push('vectorWorker.stop'); },
-    processAll: async () => {
-      calls.push('vectorWorker.processAll');
-      return 3;
-    }
-  };
-  const graduationWorker = {
-    start: () => { calls.push('graduationWorker.start'); },
-    stop: () => { calls.push('graduationWorker.stop'); },
-    forceRun: async () => {
-      calls.push('graduationWorker.forceRun');
-      return { evaluated: 2, graduated: 1, byLevel: { L0: 1 } };
-    }
-  };
-
-  const factories: MemoryRuntimeServicesFactories = {
-    createVectorWorker: (receivedEventStore, receivedVectorStore, receivedEmbedder) => {
-      calls.push(
-        receivedEventStore === eventStore && receivedVectorStore === vectorStore && receivedEmbedder === embedder
-          ? 'createVectorWorker'
-          : 'createVectorWorker:unknown'
-      );
-      return vectorWorker as unknown as ReturnType<NonNullable<MemoryRuntimeServicesFactories['createVectorWorker']>>;
-    },
-    createGraduationWorker: (receivedEventStore, receivedGraduation) => {
-      calls.push(
-        receivedEventStore === eventStore && receivedGraduation === graduation
-          ? 'createGraduationWorker'
-          : 'createGraduationWorker:unknown'
-      );
-      return graduationWorker as unknown as ReturnType<NonNullable<MemoryRuntimeServicesFactories['createGraduationWorker']>>;
-    }
-  };
-
-  const service = createMemoryRuntimeService({
-    sqliteStore: {
-      initialize: async () => { calls.push('sqlite.initialize'); },
-      close: async () => { calls.push('sqlite.close'); }
-    },
-    eventStore,
-    vectorStore,
-    embedder,
-    retriever,
-    graduation,
-    endlessMemoryServices: {
-      initializeFromSavedMode: async () => { calls.push('endless.initializeFromSavedMode'); },
-      shutdown: () => { calls.push('endless.shutdown'); }
-    },
-    sharedMemoryServices: {
-      initialize: async () => { calls.push('shared.initialize'); },
-      close: async () => { calls.push('shared.close'); }
-    },
-    readOnly: options?.readOnly ?? false,
-    lightweightMode: options?.lightweightMode ?? false,
-    embeddingOnly: options?.embeddingOnly ?? false,
-    factories
-  });
-
-  return { service, calls, vectorWorker };
-}
-
-describe('createMemoryRuntimeService', () => {
-  it('initializes only sqlite in lightweight mode and keeps initialize idempotent', async () => {
-    const harness = makeHarness({ lightweightMode: true });
-
-    await harness.service.initialize();
-    await harness.service.initialize();
-
-    expect(harness.service.isInitialized()).toBe(true);
-    expect(harness.calls).toEqual(['sqlite.initialize']);
-    await expect(harness.service.processPendingEmbeddings()).resolves.toBe(0);
-    await expect(harness.service.forceGraduation()).resolves.toEqual({ evaluated: 0, graduated: 0, byLevel: {} });
-  });
-
-  it('records memory access through the graduation pipeline without initializing runtime workers', () => {
-    const harness = makeHarness();
-
-    harness.service.recordMemoryAccess('event-1', 'session-2', 0.42);
-
-    expect(harness.service.isInitialized()).toBe(false);
-    expect(harness.calls).toEqual(['graduation.recordAccess:event-1:session-2:0.42']);
-  });
-
-  it('starts vector and graduation workers plus writable lifecycle services by default', async () => {
-    const harness = makeHarness();
-
-    await harness.service.initialize();
-
-    expect(harness.calls).toEqual([
-      'sqlite.initialize',
-      'vector.initialize',
-      'embedder.initialize',
-      'createVectorWorker',
-      'vectorWorker.start',
-      'retriever.setGraduationPipeline',
-      'createGraduationWorker',
-      'graduationWorker.start',
-      'endless.initializeFromSavedMode',
-      'shared.initialize'
-    ]);
-    expect(harness.service.getVectorWorker()).toBe(harness.vectorWorker);
-    await expect(harness.service.processPendingEmbeddings()).resolves.toBe(3);
-    await expect(harness.service.forceGraduation()).resolves.toEqual({ evaluated: 2, graduated: 1, byLevel: { L0: 1 } });
-  });
-
-  it('skips workers and write lifecycle services in read-only mode', async () => {
-    const harness = makeHarness({ readOnly: true });
-
-    await harness.service.initialize();
-
-    expect(harness.calls).toEqual([
-      'sqlite.initialize',
-      'vector.initialize',
-      'embedder.initialize'
-    ]);
-    expect(harness.service.getVectorWorker()).toBeNull();
-  });
-
-  it('embedding-only mode starts vector worker but skips graduation worker', async () => {
-    const harness = makeHarness({ embeddingOnly: true });
-
-    await harness.service.initialize();
-
-    expect(harness.calls).toEqual([
-      'sqlite.initialize',
-      'vector.initialize',
-      'embedder.initialize',
-      'createVectorWorker',
-      'vectorWorker.start',
-      'endless.initializeFromSavedMode',
-      'shared.initialize'
-    ]);
-    await expect(harness.service.forceGraduation()).resolves.toEqual({ evaluated: 0, graduated: 0, byLevel: {} });
-  });
-
-  it('returns a fresh empty graduation result when no graduation worker exists', async () => {
-    const harness = makeHarness({ embeddingOnly: true });
-    await harness.service.initialize();
-
-    const first = await harness.service.forceGraduation();
-    first.byLevel.L0 = 99;
-    first.evaluated = 99;
-
-    const second = await harness.service.forceGraduation();
-
-    expect(second).toEqual({ evaluated: 0, graduated: 0, byLevel: {} });
-    expect(second).not.toBe(first);
-    expect(second.byLevel).not.toBe(first.byLevel);
-  });
-
-  it('shuts down workers and backing services in the historical MemoryService order', async () => {
-    const harness = makeHarness();
-    await harness.service.initialize();
-    harness.calls.length = 0;
-
-    await harness.service.shutdown();
-
-    expect(harness.calls).toEqual([
-      'graduationWorker.stop',
-      'endless.shutdown',
-      'vectorWorker.stop',
-      'shared.close',
-      'sqlite.close'
-    ]);
-  });
-});