claude-memory-layer 1.0.26 → 1.0.28

package/tests/apps/cli-disclosure-output.test.ts

@@ -0,0 +1,212 @@
+import { describe, expect, it } from 'vitest';
+import {
+  formatDisclosureExpansion,
+  formatDisclosureSearch,
+  formatDisclosureSource,
+  formatPlainSearchResults
+} from '../../src/apps/cli/retrieval-disclosure-output.js';
+
+describe('retrieval disclosure CLI output', () => {
+  it('formats compact search envelopes with type badges, reasons, and source refs', () => {
+    const out = formatDisclosureSearch({
+      results: [
+        {
+          id: 'event:e1',
+          resultType: 'tool_evidence',
+          title: 'Tool evidence',
+          snippet: 'Applied checkout fix in src/cart.ts',
+          score: 0.91,
+          reasons: ['semantic_match', 'tool_followup'],
+          sourceRef: 'event:e1',
+          sessionId: 'session-1234567890'
+        }
+      ],
+      meta: {
+        total: 1,
+        usedVector: true,
+        usedKeyword: true,
+        fallbackApplied: false
+      }
+    });
+
+    expect(out).toContain('🔎 Progressive Search Results');
+    expect(out).toContain('Meta: total=1 vector=yes keyword=yes fallback=no');
+    expect(out).toContain('[tool_evidence] Tool evidence');
+    expect(out).toContain('event:e1');
+    expect(out).toContain('semantic_match, tool_followup');
+    expect(out).toContain('session-');
+  });
+
+  it('formats expand output with target, surrounding results, sources, and expanded context', () => {
+    const out = formatDisclosureExpansion({
+      target: {
+        id: 'event:e2',
+        resultType: 'source',
+        title: 'Agent response',
+        snippet: 'Use the disclosure API',
+        score: 1,
+        reasons: ['continuity_link'],
+        sourceRef: 'event:e2'
+      },
+      surroundingFacts: [
+        {
+          id: 'event:e1',
+          resultType: 'source',
+          snippet: 'Earlier user prompt',
+          score: 1,
+          reasons: ['continuity_link'],
+          sourceRef: 'event:e1'
+        }
+      ],
+      relatedSources: [{ sourceRef: 'event:e2', sourceType: 'raw_event', eventIds: ['e2'] }],
+      expandedContext: '[agent_response] Use the disclosure API'
+    });
+
+    expect(out).toContain('🧩 Expanded Retrieval Result');
+    expect(out).toContain('Target');
+    expect(out).toContain('Surrounding');
+    expect(out).toContain('Sources');
+    expect(out).toContain('[agent_response] Use the disclosure API');
+  });
+
+  it('formats shared disclosure provenance explicitly in expansion and source output', () => {
+    const expansionOut = formatDisclosureExpansion({
+      target: {
+        id: 'shared:shared-1',
+        resultType: 'rule',
+        title: 'Shared checkout troubleshooting',
+        snippet: 'clear cache and retry',
+        score: 0.88,
+        reasons: ['semantic_match'],
+        sourceRef: 'shared:shared-1',
+        metadata: {
+          sourceProjectHash: 'project-a',
+          sourceEntryId: 'e-shared',
+          topics: ['checkout']
+        }
+      },
+      relatedSources: [
+        {
+          sourceRef: 'shared:shared-1',
+          sourceType: 'shared_troubleshooting',
+          eventIds: [],
+          metadata: {
+            sourceProjectHash: 'project-a',
+            sourceEntryId: 'e-shared',
+            topics: ['checkout']
+          }
+        }
+      ],
+      expandedContext: '[shared_troubleshooting] Shared checkout troubleshooting\nRoot cause: stale cache'
+    });
+
+    const sourceOut = formatDisclosureSource({
+      sourceRef: 'shared:shared-1',
+      sourceType: 'shared_troubleshooting',
+      eventIds: [],
+      rawEvents: [],
+      metadata: {
+        sourceProjectHash: 'project-a',
+        sourceEntryId: 'e-shared',
+        topics: ['checkout'],
+        rootCause: 'stale cache',
+        solution: 'clear cache and retry'
+      }
+    });
+
+    expect(expansionOut).toContain('shared_troubleshooting');
+    expect(expansionOut).toContain('sourceProjectHash: project-a');
+    expect(expansionOut).toContain('topics: checkout');
+    expect(sourceOut).toContain('Shared Metadata');
+    expect(sourceOut).toContain('rootCause: stale cache');
+    expect(sourceOut).toContain('No local raw events for this shared source.');
+  });
+
+  it('formats source output with source type, event ids, and raw event previews', () => {
+    const out = formatDisclosureSource({
+      sourceRef: 'event:e3',
+      sourceType: 'raw_event',
+      eventIds: ['e3'],
+      rawEvents: [
+        {
+          id: 'e3',
+          sessionId: 'session-1',
+          eventType: 'user_prompt',
+          content: 'Show source details',
+          canonicalKey: 'canonical/e3',
+          dedupeKey: 'session-1:e3',
+          timestamp: new Date('2026-02-24T00:00:00.000Z'),
+          metadata: {}
+        }
+      ]
+    });
+
+    expect(out).toContain('📎 Retrieval Source');
+    expect(out).toContain('sourceType: raw_event');
+    expect(out).toContain('eventIds: e3');
+    expect(out).toContain('[user_prompt] Show source details');
+  });
+
+  it('formats plain search output with shared memories when includeShared is used', () => {
+    const out = formatPlainSearchResults({
+      memories: [
+        {
+          event: {
+            id: 'e1',
+            sessionId: 'session-1234567890',
+            eventType: 'agent_response',
+            content: 'Local checkout fix details',
+            canonicalKey: 'canonical/e1',
+            dedupeKey: 'session-1234567890:e1',
+            timestamp: new Date('2026-02-24T00:00:00.000Z'),
+            metadata: {}
+          },
+          score: 0.91
+        }
+      ],
+      matchResult: {
+        match: {
+          event: {
+            id: 'e1',
+            sessionId: 'session-1234567890',
+            eventType: 'agent_response',
+            content: 'Local checkout fix details',
+            canonicalKey: 'canonical/e1',
+            dedupeKey: 'session-1234567890:e1',
+            timestamp: new Date('2026-02-24T00:00:00.000Z'),
+            metadata: {}
+          },
+          score: 0.91
+        },
+        confidence: 'high'
+      },
+      totalTokens: 10,
+      context: 'Local checkout fix details',
+      sharedMemories: [
+        {
+          entryId: 'shared-1',
+          sourceProjectHash: 'project-a',
+          sourceEntryId: 'e-shared',
+          title: 'Shared checkout troubleshooting',
+          symptoms: ['checkout fails'],
+          rootCause: 'stale cache',
+          solution: 'clear cache and retry',
+          topics: ['checkout'],
+          confidence: 0.88,
+          usageCount: 3,
+          promotedAt: new Date('2026-02-23T00:00:00.000Z'),
+          createdAt: new Date('2026-02-23T00:00:00.000Z')
+        }
+      ]
+    });
+
+    expect(out).toContain('📚 Search Results');
+    expect(out).toContain('Total local memories found: 1');
+    expect(out).toContain('Shared memories found: 1');
+    expect(out).toContain('🌐 Shared Memories');
+    expect(out).toContain('Shared checkout troubleshooting');
+    expect(out).toContain('Source: shared:shared-1');
+    expect(out).toContain('Project: project-a');
+    expect(out).toContain('Solution: clear cache and retry');
+  });
+});

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

@@ -0,0 +1,99 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { ImportResult } from '../../src/services/session-history-importer.js';
+
+const { runCodexImportOnce } = await import('../../src/apps/cli/codex-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('Codex import runner', () => {
+  let projectService: ReturnType<typeof makeService>;
+  let globalService: ReturnType<typeof makeService>;
+  let importer: {
+    importProject: ReturnType<typeof vi.fn>;
+    importAll: ReturnType<typeof vi.fn>;
+    importSessionFile: ReturnType<typeof vi.fn>;
+  };
+  let deps: Parameters<typeof runCodexImportOnce>[1];
+
+  beforeEach(() => {
+    projectService = makeService();
+    globalService = makeService();
+    importer = {
+      importProject: vi.fn(async () => makeImportResult()),
+      importAll: vi.fn(async () => makeImportResult({ totalSessions: 3 })),
+      importSessionFile: 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 Codex sessions into the project-scoped memory service', async () => {
+    const outcome = await runCodexImportOnce({ sessionsDir: '/tmp/codex-sessions', limit: '9', sessionLimit: '1' }, deps);
+
+    expect(deps?.getMemoryServiceForProject).toHaveBeenCalledWith('/repo/current');
+    expect(deps?.getDefaultMemoryService).not.toHaveBeenCalled();
+    expect(deps?.createImporter).toHaveBeenCalledWith(projectService, { sessionsDir: '/tmp/codex-sessions' });
+    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 runCodexImportOnce({ 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 Codex session file into the selected project scope', async () => {
+    await runCodexImportOnce({ project: '/repo/selected', session: '/tmp/session.jsonl', force: true }, deps);
+
+    expect(deps?.getMemoryServiceForProject).toHaveBeenCalledWith('/repo/selected');
+    expect(importer.importSessionFile).toHaveBeenCalledWith('/tmp/session.jsonl', expect.objectContaining({
+      projectPath: '/repo/selected',
+      force: true
+    }));
+  });
+
+  it('rejects non-decimal integer limits instead of partially parsing them', async () => {
+    await expect(runCodexImportOnce({ limit: '1foo' }, deps)).rejects.toThrow('Invalid --limit');
+    await expect(runCodexImportOnce({ sessionLimit: '1.5' }, deps)).rejects.toThrow('Invalid --session-limit');
+    await expect(runCodexImportOnce({ sessionLimit: '1e2' }, deps)).rejects.toThrow('Invalid --session-limit');
+  });
+});

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

@@ -0,0 +1,100 @@
+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

@@ -0,0 +1,99 @@
+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

@@ -0,0 +1,59 @@
+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

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