claude-memory-layer 1.0.31 → 1.0.32

package/tests/apps/codex-validation-output.test.ts

@@ -1,100 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { formatCodexValidationReport } from '../../src/apps/cli/codex-validation-output.js';
-import type { CodexSessionValidationReport } from '../../src/services/codex-session-history-importer.js';
-
-function makeReport(): CodexSessionValidationReport {
-  return {
-    generatedAt: '2026-05-05T12:00:00.000Z',
-    dryRun: true,
-    willMutate: false,
-    source: {
-      sessionsDir: '/tmp/codex-sessions',
-      projectPath: '/tmp/project-a',
-      projectFilterApplied: true,
-      sourcePaths: ['/tmp/codex-sessions']
-    },
-    limits: {
-      sessionLimit: 10,
-      maxContentChars: 10_000
-    },
-    totals: {
-      sessionsScanned: 3,
-      sessionsMatched: 2,
-      filesRead: 2,
-      recordsRead: 9,
-      messagesNormalized: 4,
-      turnsNormalized: 2,
-      userMessages: 2,
-      assistantMessages: 2,
-      malformedLines: 1,
-      skippedUnsupportedRecords: 2,
-      emptyAssistantMessages: 1,
-      truncatedMessages: 1,
-      missingProjectCwd: 1,
-      warnings: 2
-    },
-    topProjects: [
-      {
-        projectHash: 'abc12345',
-        pathLabel: '/tmp/project-a',
-        sessions: 2,
-        messagesNormalized: 4,
-        turnsNormalized: 2,
-        userMessages: 2,
-        assistantMessages: 2,
-        malformedLines: 1,
-        skippedUnsupportedRecords: 2,
-        truncatedMessages: 1,
-        emptyAssistantMessages: 1
-      }
-    ],
-    sessions: [
-      {
-        sessionId: 'session-a',
-        filePath: '/tmp/codex-sessions/session-a.jsonl',
-        projectHash: 'abc12345',
-        pathLabel: '/tmp/project-a',
-        matched: true,
-        recordsRead: 9,
-        messagesNormalized: 4,
-        turnsNormalized: 2,
-        userMessages: 2,
-        assistantMessages: 2,
-        malformedLines: 1,
-        skippedUnsupportedRecords: 2,
-        emptyAssistantMessages: 1,
-        truncatedMessages: 1,
-        missingProjectCwd: false,
-        warnings: ['sample warning']
-      }
-    ],
-    warnings: ['1 session(s) missing cwd', '1 malformed JSONL line(s) skipped']
-  };
-}
-
-describe('Codex validation CLI output helpers', () => {
-  it('formats JSON reports without transcript text', () => {
-    const json = formatCodexValidationReport(makeReport(), 'json');
-    const parsed = JSON.parse(json) as CodexSessionValidationReport;
-
-    expect(parsed.dryRun).toBe(true);
-    expect(parsed.willMutate).toBe(false);
-    expect(parsed.totals.sessionsScanned).toBe(3);
-    expect(json).not.toContain('please implement');
-    expect(json).not.toContain('assistant response');
-  });
-
-  it('formats markdown totals, top projects, and safety status', () => {
-    const markdown = formatCodexValidationReport(makeReport(), 'markdown');
-
-    expect(markdown).toContain('# Codex dry-run validation report');
-    expect(markdown).toContain('Dry-run: yes');
-    expect(markdown).toContain('Sessions scanned: 3');
-    expect(markdown).toContain('Sessions matched: 2');
-    expect(markdown).toContain('Malformed lines: 1');
-    expect(markdown).toContain('Skipped/unsupported records: 2');
-    expect(markdown).toContain('abc12345');
-    expect(markdown).toContain('/tmp/project-a');
-  });
-});

package/tests/apps/hermes-import-runner.test.ts

@@ -1,99 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import type { ImportResult } from '../../src/services/session-history-importer.js';
-
-const { runHermesImportOnce } = await import('../../src/apps/cli/hermes-import-runner.js');
-
-function makeImportResult(overrides: Partial<ImportResult> = {}): ImportResult {
-  return {
-    totalSessions: 1,
-    totalMessages: 2,
-    importedPrompts: 1,
-    importedResponses: 1,
-    skippedDuplicates: 0,
-    errors: [],
-    ...overrides
-  };
-}
-
-function makeService() {
-  return {
-    initialize: vi.fn(async () => undefined),
-    shutdown: vi.fn(async () => undefined),
-    processPendingEmbeddings: vi.fn(async () => 2),
-    ensureEmbeddingModelForImport: vi.fn(async () => ({ changed: false, previousModel: null, currentModel: 'test', enqueued: 0 }))
-  };
-}
-
-describe('Hermes import runner', () => {
-  let projectService: ReturnType<typeof makeService>;
-  let globalService: ReturnType<typeof makeService>;
-  let importer: {
-    importProject: ReturnType<typeof vi.fn>;
-    importAll: ReturnType<typeof vi.fn>;
-    importSession: ReturnType<typeof vi.fn>;
-  };
-  let deps: Parameters<typeof runHermesImportOnce>[1];
-
-  beforeEach(() => {
-    projectService = makeService();
-    globalService = makeService();
-    importer = {
-      importProject: vi.fn(async () => makeImportResult()),
-      importAll: vi.fn(async () => makeImportResult({ totalSessions: 3 })),
-      importSession: vi.fn(async () => makeImportResult())
-    };
-    deps = {
-      cwd: () => '/repo/current',
-      getDefaultMemoryService: vi.fn(() => globalService as never),
-      getMemoryServiceForProject: vi.fn(() => projectService as never),
-      createImporter: vi.fn(() => importer as never),
-      onProgress: vi.fn()
-    };
-  });
-
-  it('imports the current project from Hermes state.db into the project-scoped memory service', async () => {
-    const outcome = await runHermesImportOnce({ stateDb: '/tmp/hermes-state.db', limit: '9', sessionLimit: '1' }, deps);
-
-    expect(deps?.getMemoryServiceForProject).toHaveBeenCalledWith('/repo/current');
-    expect(deps?.getDefaultMemoryService).not.toHaveBeenCalled();
-    expect(deps?.createImporter).toHaveBeenCalledWith(projectService, { stateDbPath: '/tmp/hermes-state.db' });
-    expect(projectService.initialize).toHaveBeenCalledTimes(1);
-    expect(projectService.ensureEmbeddingModelForImport).toHaveBeenCalledWith({ autoMigrate: true });
-    expect(importer.importProject).toHaveBeenCalledWith('/repo/current', expect.objectContaining({
-      projectPath: '/repo/current',
-      limit: 9,
-      sessionLimit: 1,
-      onProgress: deps?.onProgress
-    }));
-    expect(projectService.processPendingEmbeddings).toHaveBeenCalledTimes(1);
-    expect(projectService.shutdown).toHaveBeenCalledTimes(1);
-    expect(outcome).toMatchObject({ mode: 'project', storageScope: 'project', embedCount: 2 });
-  });
-
-  it('uses global storage only for explicit all-session imports without a project', async () => {
-    const outcome = await runHermesImportOnce({ all: true, processEmbeddings: false }, deps);
-
-    expect(deps?.getDefaultMemoryService).toHaveBeenCalledTimes(1);
-    expect(deps?.getMemoryServiceForProject).not.toHaveBeenCalled();
-    expect(importer.importAll).toHaveBeenCalledWith(expect.objectContaining({ force: undefined }));
-    expect(globalService.processPendingEmbeddings).not.toHaveBeenCalled();
-    expect(globalService.shutdown).toHaveBeenCalledTimes(1);
-    expect(outcome).toMatchObject({ mode: 'all', storageScope: 'global', embedCount: 0 });
-  });
-
-  it('imports a single Hermes session into the selected project scope', async () => {
-    await runHermesImportOnce({ project: '/repo/selected', session: '20260505_010203_abcd1234', force: true }, deps);
-
-    expect(deps?.getMemoryServiceForProject).toHaveBeenCalledWith('/repo/selected');
-    expect(importer.importSession).toHaveBeenCalledWith('20260505_010203_abcd1234', expect.objectContaining({
-      projectPath: '/repo/selected',
-      force: true
-    }));
-  });
-
-  it('rejects non-decimal integer limits instead of partially parsing them', async () => {
-    await expect(runHermesImportOnce({ limit: '1foo' }, deps)).rejects.toThrow('Invalid --limit');
-    await expect(runHermesImportOnce({ sessionLimit: '1.5' }, deps)).rejects.toThrow('Invalid --session-limit');
-    await expect(runHermesImportOnce({ sessionLimit: '1e2' }, deps)).rejects.toThrow('Invalid --session-limit');
-  });
-});

package/tests/apps/mcp-install-command.test.ts

@@ -1,59 +0,0 @@
-import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, describe, expect, it } from 'vitest';
-import {
-  getDefaultClaudeDesktopConfigPath,
-  installMcpServerConfig,
-  readJsonConfig,
-  saveJsonConfig
-} from '../../src/apps/cli/mcp-install.js';
-
-const tempDirs: string[] = [];
-
-function tempDir() {
-  const dir = mkdtempSync(join(tmpdir(), 'cml-mcp-install-'));
-  tempDirs.push(dir);
-  return dir;
-}
-
-afterEach(() => {
-  for (const dir of tempDirs.splice(0)) {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-describe('MCP install command helpers', () => {
-  it('resolves the Claude Desktop config path per platform', () => {
-    expect(getDefaultClaudeDesktopConfigPath('darwin', {}, '/Users/me')).toBe('/Users/me/Library/Application Support/Claude/claude_desktop_config.json');
-    expect(getDefaultClaudeDesktopConfigPath('linux', {}, '/home/me')).toBe('/home/me/.config/claude/claude_desktop_config.json');
-    expect(getDefaultClaudeDesktopConfigPath('win32', { APPDATA: 'C:/Users/me/AppData/Roaming' }, 'C:/Users/me')).toBe('C:/Users/me/AppData/Roaming/Claude/claude_desktop_config.json');
-  });
-
-  it('adds claude-memory-layer MCP server while preserving existing config', () => {
-    const config = installMcpServerConfig(
-      { mcpServers: { existing: { command: 'node', args: ['server.js'] } }, other: true },
-      { serverName: 'claude-memory-layer', command: 'claude-memory-layer-mcp', args: [] }
-    );
-
-    expect(config).toEqual({
-      mcpServers: {
-        existing: { command: 'node', args: ['server.js'] },
-        'claude-memory-layer': { command: 'claude-memory-layer-mcp', args: [] }
-      },
-      other: true
-    });
-  });
-
-  it('atomically writes config files and creates parent directories', () => {
-    const configPath = join(tempDir(), 'Claude', 'claude_desktop_config.json');
-    saveJsonConfig(configPath, installMcpServerConfig({}, { serverName: 'code-memory', command: 'node', args: ['dist/mcp/index.js'] }));
-
-    expect(readJsonConfig(configPath)).toEqual({
-      mcpServers: {
-        'code-memory': { command: 'node', args: ['dist/mcp/index.js'] }
-      }
-    });
-    expect(readFileSync(configPath, 'utf8')).toContain('"mcpServers"');
-  });
-});

package/tests/apps/package-build-entrypoints.test.ts

@@ -1,30 +0,0 @@
-import { readFileSync } from 'node:fs';
-
-import { describe, expect, it } from 'vitest';
-
-interface PackageJson {
-  main: string;
-  bin: Record<string, string>;
-}
-
-describe('package build entrypoints', () => {
-  it('builds the root package main declared in package.json', () => {
-    const pkg = JSON.parse(readFileSync('package.json', 'utf-8')) as PackageJson;
-    const buildScript = readFileSync('scripts/build.ts', 'utf-8');
-
-    expect(pkg.main).toBe('dist/index.js');
-    expect(buildScript).toContain("entryPoints: ['src/index.ts']");
-    expect(buildScript).toContain("outfile: 'dist/index.js'");
-  });
-
-  it('keeps MCP package bin wiring covered by the build script', () => {
-    const pkg = JSON.parse(readFileSync('package.json', 'utf-8')) as PackageJson;
-    const lock = JSON.parse(readFileSync('package-lock.json', 'utf-8')) as { packages: Record<string, { bin?: Record<string, string> }> };
-    const buildScript = readFileSync('scripts/build.ts', 'utf-8');
-
-    expect(pkg.bin['claude-memory-layer-mcp']).toBe('dist/mcp/index.js');
-    expect(lock.packages[''].bin).toMatchObject(pkg.bin);
-    expect(buildScript).toContain("entryPoints: ['src/mcp/index.ts']");
-    expect(buildScript).toContain("outfile: 'dist/mcp/index.js'");
-  });
-});

package/tests/apps/postinstall-embedding-backend.test.ts

@@ -1,185 +0,0 @@
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { createRequire } from 'node:module';
-
-import { describe, expect, it } from 'vitest';
-
-const require = createRequire(import.meta.url);
-
-type SpawnCall = {
-  cmd: string;
-  args: string[];
-  env: NodeJS.ProcessEnv;
-};
-
-type PostinstallEmbeddingBackend = {
-  EMBEDDING_BACKEND_PACKAGE: string;
-  parseCudaMajor(output: string): number | null;
-  isSkipRequested(env: NodeJS.ProcessEnv): boolean;
-  shouldAttemptAutoInstall(input: {
-    platform: NodeJS.Platform;
-    arch: string;
-    cudaMajor: number | null;
-    transformersAvailable: boolean;
-    skipRequested: boolean;
-  }): boolean;
-  createRepairEnv(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
-  createNpmInstallArgs(): string[];
-  runPostinstall(input?: {
-    rootDir?: string;
-    env?: NodeJS.ProcessEnv;
-    platform?: NodeJS.Platform;
-    arch?: string;
-    execFileSyncImpl?: () => string;
-    spawnSyncImpl?: (cmd: string, args: string[], options: { env: NodeJS.ProcessEnv }) => { status: number };
-    log?: () => void;
-    warn?: () => void;
-  }): { attempted: boolean; success?: boolean; cudaMajor: number | null; transformersAvailable: boolean; skipRequested: boolean };
-};
-
-function loadPostinstallModule(): PostinstallEmbeddingBackend {
-  return require('../../scripts/postinstall-embedding-backend.cjs') as PostinstallEmbeddingBackend;
-}
-
-describe('embedding backend postinstall repair', () => {
-  it('requires the embedding backend at install time and registers a broken-install repair hook', () => {
-    const pkg = JSON.parse(readFileSync('package.json', 'utf-8')) as {
-      scripts: Record<string, string>;
-      dependencies?: Record<string, string>;
-      optionalDependencies?: Record<string, string>;
-    };
-
-    expect(pkg.dependencies).toMatchObject({
-      '@huggingface/transformers': '^3.8.1'
-    });
-    expect(pkg.optionalDependencies ?? {}).not.toHaveProperty('@huggingface/transformers');
-    expect(pkg.scripts.postinstall).toBe('node scripts/postinstall-embedding-backend.cjs');
-  });
-
-  it('only skips required-backend repair when the explicit repair guards are set', () => {
-    const postinstall = loadPostinstallModule();
-
-    expect(postinstall.isSkipRequested({ CLAUDE_MEMORY_LAYER_SKIP_EMBEDDING_POSTINSTALL: '1' })).toBe(true);
-    expect(postinstall.isSkipRequested({ CLAUDE_MEMORY_LAYER_EMBEDDING_POSTINSTALL_REPAIR: '1' })).toBe(true);
-    expect(postinstall.isSkipRequested({ npm_config_optional: 'false' })).toBe(false);
-    expect(postinstall.isSkipRequested({ npm_config_omit: 'optional' })).toBe(false);
-  });
-
-  it('detects CUDA major version from nvcc output', () => {
-    const postinstall = loadPostinstallModule();
-
-    expect(postinstall.parseCudaMajor('Cuda compilation tools, release 11.8, V11.8.89')).toBe(11);
-    expect(postinstall.parseCudaMajor('Cuda compilation tools, release 12.4, V12.4.131')).toBe(12);
-    expect(postinstall.parseCudaMajor('nvcc: NVIDIA (R) Cuda compiler driver')).toBeNull();
-  });
-
-  it('auto-installs a missing embedding backend for Linux x64 even when CUDA cannot be detected', () => {
-    const postinstall = loadPostinstallModule();
-
-    expect(postinstall.shouldAttemptAutoInstall({
-      platform: 'linux',
-      arch: 'x64',
-      cudaMajor: 11,
-      transformersAvailable: false,
-      skipRequested: false
-    })).toBe(true);
-
-    expect(postinstall.shouldAttemptAutoInstall({
-      platform: 'linux',
-      arch: 'x64',
-      cudaMajor: null,
-      transformersAvailable: false,
-      skipRequested: false
-    })).toBe(true);
-
-    expect(postinstall.shouldAttemptAutoInstall({
-      platform: 'linux',
-      arch: 'x64',
-      cudaMajor: 12,
-      transformersAvailable: false,
-      skipRequested: false
-    })).toBe(true);
-
-    expect(postinstall.shouldAttemptAutoInstall({
-      platform: 'linux',
-      arch: 'x64',
-      cudaMajor: null,
-      transformersAvailable: true,
-      skipRequested: false
-    })).toBe(false);
-
-    expect(postinstall.shouldAttemptAutoInstall({
-      platform: 'linux',
-      arch: 'arm64',
-      cudaMajor: null,
-      transformersAvailable: false,
-      skipRequested: false
-    })).toBe(false);
-
-    expect(postinstall.shouldAttemptAutoInstall({
-      platform: 'darwin',
-      arch: 'x64',
-      cudaMajor: null,
-      transformersAvailable: false,
-      skipRequested: false
-    })).toBe(false);
-
-    expect(postinstall.shouldAttemptAutoInstall({
-      platform: 'linux',
-      arch: 'x64',
-      cudaMajor: null,
-      transformersAvailable: false,
-      skipRequested: true
-    })).toBe(false);
-  });
-
-  it('repairs missing transformers with CPU-only onnxruntime install settings', () => {
-    const postinstall = loadPostinstallModule();
-
-    expect(postinstall.createRepairEnv({})).toMatchObject({
-      ONNXRUNTIME_NODE_INSTALL_CUDA: 'skip',
-      CLAUDE_MEMORY_LAYER_EMBEDDING_POSTINSTALL_REPAIR: '1'
-    });
-    expect(postinstall.createNpmInstallArgs()).toEqual([
-      'install',
-      '--no-save',
-      '--no-package-lock',
-      '--omit=dev',
-      postinstall.EMBEDDING_BACKEND_PACKAGE
-    ]);
-  });
-
-  it('runs the repair command when Linux x64 is missing the required backend without detectable CUDA', () => {
-    const postinstall = loadPostinstallModule();
-    const rootDir = mkdtempSync(join(tmpdir(), 'cml-postinstall-test-'));
-    const calls: SpawnCall[] = [];
-
-    try {
-      writeFileSync(join(rootDir, 'package.json'), JSON.stringify({ name: 'claude-memory-layer-install-root' }));
-
-      const result = postinstall.runPostinstall({
-        rootDir,
-        env: {},
-        platform: 'linux',
-        arch: 'x64',
-        execFileSyncImpl: () => '',
-        spawnSyncImpl: (cmd, args, options) => {
-          calls.push({ cmd, args, env: options.env });
-          return { status: 0 };
-        },
-        log: () => undefined,
-        warn: () => undefined
-      });
-
-      expect(result).toMatchObject({ attempted: true, success: true, cudaMajor: null, transformersAvailable: false });
-      expect(calls).toHaveLength(1);
-      expect(calls[0]?.cmd).toBe('npm');
-      expect(calls[0]?.args).toEqual(postinstall.createNpmInstallArgs());
-      expect(calls[0]?.env.ONNXRUNTIME_NODE_INSTALL_CUDA).toBe('skip');
-      expect(calls[0]?.env.CLAUDE_MEMORY_LAYER_EMBEDDING_POSTINSTALL_REPAIR).toBe('1');
-    } finally {
-      rmSync(rootDir, { recursive: true, force: true });
-    }
-  });
-});

package/tests/apps/search-api-disclosure.test.ts

@@ -1,162 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { Hono } from 'hono';
-
-const mocks = vi.hoisted(() => {
-  const service = {
-    initialize: vi.fn(),
-    shutdown: vi.fn(),
-    retrieveMemories: vi.fn(),
-    searchDisclosure: vi.fn(),
-    expandDisclosure: vi.fn(),
-    sourceDisclosure: vi.fn()
-  };
-
-  const lightweightService = {
-    initialize: vi.fn(),
-    shutdown: vi.fn(),
-    searchDisclosure: vi.fn()
-  };
-
-  return {
-    service,
-    lightweightService,
-    getServiceFromQuery: vi.fn(() => service),
-    getLightweightServiceFromQuery: vi.fn(() => lightweightService)
-  };
-});
-
-vi.mock('../../src/apps/server/api/utils.js', () => ({
-  getServiceFromQuery: mocks.getServiceFromQuery,
-  getLightweightServiceFromQuery: mocks.getLightweightServiceFromQuery
-}));
-
-const { searchRouter } = await import('../../src/server/api/search.js');
-
-function createApp() {
-  const app = new Hono();
-  app.route('/api/search', searchRouter);
-  return app;
-}
-
-describe('search disclosure API', () => {
-  beforeEach(() => {
-    mocks.service.initialize.mockReset().mockResolvedValue(undefined);
-    mocks.service.shutdown.mockReset().mockResolvedValue(undefined);
-    mocks.service.retrieveMemories.mockReset();
-    mocks.service.searchDisclosure.mockReset();
-    mocks.service.expandDisclosure.mockReset();
-    mocks.service.sourceDisclosure.mockReset();
-    mocks.lightweightService.initialize.mockReset().mockResolvedValue(undefined);
-    mocks.lightweightService.shutdown.mockReset().mockResolvedValue(undefined);
-    mocks.lightweightService.searchDisclosure.mockReset();
-    mocks.getServiceFromQuery.mockClear();
-    mocks.getLightweightServiceFromQuery.mockClear();
-  });
-
-  it('POST /api/search/disclosure delegates to MemoryService.searchDisclosure', async () => {
-    const responseBody = {
-      results: [{ id: 'event:e1', resultType: 'source', snippet: 'checkout fix', score: 0.91, reasons: ['semantic_match'], sourceRef: 'event:e1' }],
-      meta: { total: 1, usedVector: true, usedKeyword: true, fallbackApplied: false }
-    };
-    mocks.service.searchDisclosure.mockResolvedValue(responseBody);
-
-    const res = await createApp().request('/api/search/disclosure?project=abc12345', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ query: 'checkout fix', options: { topK: 3, includeShared: true } })
-    });
-
-    expect(res.status).toBe(200);
-    expect(await res.json()).toEqual(responseBody);
-    expect(mocks.getServiceFromQuery).toHaveBeenCalledTimes(1);
-    expect(mocks.service.initialize).toHaveBeenCalledTimes(1);
-    expect(mocks.service.searchDisclosure).toHaveBeenCalledWith('checkout fix', { topK: 3, includeShared: true });
-    expect(mocks.service.shutdown).toHaveBeenCalledTimes(1);
-  });
-
-
-  it('POST /api/search/disclosure uses lightweight service for explicit fast search', async () => {
-    const responseBody = {
-      results: [{ id: 'event:e1', resultType: 'source', snippet: 'checkout fix', score: 0.91, reasons: ['keyword_match'], sourceRef: 'event:e1' }],
-      meta: { total: 1, usedVector: false, usedKeyword: true, fallbackApplied: false }
-    };
-    mocks.lightweightService.searchDisclosure.mockResolvedValue(responseBody);
-
-    const res = await createApp().request('/api/search/disclosure?project=abc12345', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ query: 'checkout fix', options: { topK: 3, strategy: 'fast', includeShared: true } })
-    });
-
-    expect(res.status).toBe(200);
-    expect(await res.json()).toEqual(responseBody);
-    expect(mocks.getLightweightServiceFromQuery).toHaveBeenCalledTimes(1);
-    expect(mocks.getServiceFromQuery).not.toHaveBeenCalled();
-    expect(mocks.lightweightService.initialize).toHaveBeenCalledTimes(1);
-    expect(mocks.lightweightService.searchDisclosure).toHaveBeenCalledWith('checkout fix', { topK: 3, strategy: 'fast', includeShared: true });
-    expect(mocks.lightweightService.shutdown).toHaveBeenCalledTimes(1);
-    expect(mocks.service.initialize).not.toHaveBeenCalled();
-    expect(mocks.service.searchDisclosure).not.toHaveBeenCalled();
-  });
-
-  it('POST /api/search/disclosure rejects missing query', async () => {
-    const res = await createApp().request('/api/search/disclosure', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ options: { topK: 3 } })
-    });
-
-    expect(res.status).toBe(400);
-    expect(await res.json()).toEqual({ error: 'Query is required' });
-    expect(mocks.getServiceFromQuery).not.toHaveBeenCalled();
-    expect(mocks.getLightweightServiceFromQuery).not.toHaveBeenCalled();
-    expect(mocks.service.searchDisclosure).not.toHaveBeenCalled();
-    expect(mocks.service.shutdown).not.toHaveBeenCalled();
-  });
-
-  it('GET /api/search/disclosure/:resultId/expand expands a disclosure result', async () => {
-    const responseBody = {
-      target: { id: 'event:e1', resultType: 'source', snippet: 'checkout fix', score: 1, reasons: ['continuity_link'] },
-      surroundingFacts: [],
-      relatedSources: [{ sourceRef: 'event:e1', sourceType: 'raw_event', eventIds: ['e1'] }]
-    };
-    mocks.service.expandDisclosure.mockResolvedValue(responseBody);
-
-    const res = await createApp().request('/api/search/disclosure/event:e1/expand?windowSize=2');
-
-    expect(res.status).toBe(200);
-    expect(await res.json()).toEqual(responseBody);
-    expect(mocks.service.initialize).not.toHaveBeenCalled();
-    expect(mocks.service.expandDisclosure).toHaveBeenCalledWith('event:e1', { windowSize: 2 });
-    expect(mocks.service.shutdown).toHaveBeenCalledTimes(1);
-  });
-
-  it('GET /api/search/disclosure/:resultId/source resolves a disclosure result source', async () => {
-    const responseBody = {
-      sourceRef: 'event:e1',
-      sourceType: 'raw_event',
-      eventIds: ['e1'],
-      rawEvents: [{ id: 'e1', content: 'checkout fix' }]
-    };
-    mocks.service.sourceDisclosure.mockResolvedValue(responseBody);
-
-    const res = await createApp().request('/api/search/disclosure/event:e1/source');
-
-    expect(res.status).toBe(200);
-    expect(await res.json()).toEqual(responseBody);
-    expect(mocks.service.initialize).not.toHaveBeenCalled();
-    expect(mocks.service.sourceDisclosure).toHaveBeenCalledWith('event:e1');
-    expect(mocks.service.shutdown).toHaveBeenCalledTimes(1);
-  });
-
-  it('GET /api/search/disclosure/:resultId/source returns 404 when source is missing', async () => {
-    mocks.service.sourceDisclosure.mockResolvedValue(null);
-
-    const res = await createApp().request('/api/search/disclosure/event:missing/source');
-
-    expect(res.status).toBe(404);
-    expect(await res.json()).toEqual({ error: 'Source not found' });
-    expect(mocks.service.initialize).not.toHaveBeenCalled();
-    expect(mocks.service.shutdown).toHaveBeenCalledTimes(1);
-  });
-});