claude-memory-layer 1.0.31 → 1.0.32

package/tests/adapters/claude/claude-transcript-reconstructor.test.ts

@@ -1,98 +0,0 @@
-import { mkdtemp, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { describe, expect, it } from 'vitest';
-import { readTranscriptTailEntries } from '../../../src/adapters/claude/transcript/transcript-reader.js';
-import {
-  extractAssistantTextMessages,
-  extractAssistantMessages,
-  generateSessionSummary
-} from '../../../src/adapters/claude/transcript/turn-reconstructor.js';
-
-describe('Claude transcript reader', () => {
-  it('reads JSONL transcript tail entries and skips malformed partial lines', async () => {
-    const dir = await mkdtemp(join(tmpdir(), 'cml-transcript-'));
-    const transcriptPath = join(dir, 'transcript.jsonl');
-    await writeFile(
-      transcriptPath,
-      [
-        '{"type":"user","message":{"content":"hello"}}',
-        'not-json',
-        'null',
-        '42',
-        '{"type":"assistant","message":{"content":[{"type":"text","text":"answer"}]}}'
-      ].join('\n'),
-      'utf8'
-    );
-
-    const entries = await readTranscriptTailEntries(transcriptPath);
-
-    expect(entries.map((entry) => entry.type)).toEqual(['user', 'assistant']);
-  });
-
-  it('skips a partial first line when tail reading starts mid-record', async () => {
-    const dir = await mkdtemp(join(tmpdir(), 'cml-transcript-'));
-    const transcriptPath = join(dir, 'transcript.jsonl');
-    const firstLine = `{"type":"user","message":{"content":"${'x'.repeat(500)}"}}`;
-    const secondLine = '{"type":"user","message":{"content":"recent question"}}';
-    const thirdLine = '{"type":"assistant","message":{"content":[{"type":"text","text":"recent answer"}]}}';
-    await writeFile(transcriptPath, [firstLine, secondLine, thirdLine].join('\n'), 'utf8');
-
-    const maxBytes = Buffer.byteLength(`${secondLine}\n${thirdLine}`) + 10;
-    const entries = await readTranscriptTailEntries(transcriptPath, { maxBytes });
-
-    expect(entries.map((entry) => entry.type)).toEqual(['user', 'assistant']);
-    expect(entries[0]?.message?.content).toBe('recent question');
-  });
-
-  it('returns an empty entry list for missing transcript files', async () => {
-    await expect(readTranscriptTailEntries('/tmp/non-existent-claude-transcript.jsonl')).resolves.toEqual([]);
-  });
-});
-
-describe('Claude turn reconstructor', () => {
-  it('extracts assistant text blocks and joins multi-part text content', async () => {
-    const messages = extractAssistantTextMessages([
-      { type: 'user', message: { content: 'ignored' } },
-      {
-        type: 'assistant',
-        message: {
-          content: [
-            { type: 'text', text: 'first' },
-            { type: 'tool_use', id: 'tool-1' },
-            { type: 'text', text: 'second' }
-          ]
-        }
-      },
-      { type: 'assistant', message: { content: [{ type: 'tool_use', id: 'tool-2' }] } }
-    ]);
-
-    expect(messages).toEqual(['first\nsecond']);
-  });
-
-  it('reads assistant text messages from a transcript file', async () => {
-    const dir = await mkdtemp(join(tmpdir(), 'cml-transcript-'));
-    const transcriptPath = join(dir, 'transcript.jsonl');
-    await writeFile(
-      transcriptPath,
-      '{"type":"assistant","message":{"content":[{"type":"text","text":"final answer"}]}}\n',
-      'utf8'
-    );
-
-    await expect(extractAssistantMessages(transcriptPath)).resolves.toEqual(['final answer']);
-  });
-
-  it('generates deterministic summaries from session events', () => {
-    const summary = generateSessionSummary([
-      { eventType: 'user_prompt', content: 'How should we refactor transcript parsing?' },
-      { eventType: 'agent_response', content: 'Move it behind adapter modules.' },
-      { eventType: 'tool_observation', content: 'ignored' }
-    ]);
-
-    expect(summary).toBe(
-      'Session with 1 user prompts and 1 responses.\n' +
-      'Topics discussed:\n' +
-      '- How should we refactor transcript parsing?'
-    );
-  });
-});

package/tests/adapters/claude-hook-prompt-injection-policy.test.ts

@@ -1,99 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { MemoryQueryService } from '../../src/core/engine/memory-query-service.js';
-import type { MemoryEvent } from '../../src/core/types.js';
-import {
-  filterHookInjectableMemories,
-  getHookInjectionPolicy,
-  summarizeHookInjectionConfidence,
-  type HookMemoryCandidate
-} from '../../src/adapters/claude/hooks/prompt-injection-policy.js';
-
-function event(id: string, content = 'low confidence keyword result'): MemoryEvent {
-  return {
-    id,
-    eventType: 'user_prompt',
-    sessionId: 'session-1',
-    timestamp: new Date('2026-05-02T00:00:00.000Z'),
-    content,
-    canonicalKey: `test/${id}`,
-    dedupeKey: `session-1:${id}`,
-    metadata: {}
-  };
-}
-
-describe('Claude hook prompt injection policy', () => {
-  it('filters low-confidence hook candidates before prompt injection', () => {
-    const candidates: HookMemoryCandidate[] = [
-      { id: 'low-semantic', type: 'agent_response', content: 'maybe related', score: 0.58, source: 'semantic' },
-      { id: 'low-keyword', type: 'user_prompt', content: 'weak keyword rescue', score: 0.49, source: 'keyword' },
-      { id: 'high-keyword', type: 'user_prompt', content: 'exact high-confidence keyword', score: 0.84, source: 'keyword' },
-      { id: 'high-semantic', type: 'session_summary', content: 'high semantic match', score: 0.76, source: 'semantic' }
-    ];
-
-    expect(filterHookInjectableMemories(candidates, getHookInjectionPolicy())).toEqual([
-      candidates[2],
-      candidates[3]
-    ]);
-    expect(summarizeHookInjectionConfidence(candidates)).toBe('high');
-    expect(summarizeHookInjectionConfidence([])).toBe('none');
-  });
-
-  it('limits injected hook memories by highest confidence rather than first passing candidate', () => {
-    const candidates: HookMemoryCandidate[] = [
-      { id: 'medium-first', type: 'session_summary', content: 'passes but weaker', score: 0.67, source: 'semantic' },
-      { id: 'best-later', type: 'user_prompt', content: 'best exact keyword', score: 0.93, source: 'keyword' },
-      { id: 'second-best-later', type: 'agent_response', content: 'strong semantic match', score: 0.88, source: 'semantic' }
-    ];
-
-    expect(filterHookInjectableMemories(candidates, { ...getHookInjectionPolicy(), maxMemories: 2 }))
-      .toEqual([candidates[1], candidates[2]]);
-  });
-
-  it('uses bounded hook policy thresholds so unsafe env overrides cannot inject weak memories', () => {
-    const policy = getHookInjectionPolicy({
-      CLAUDE_MEMORY_HOOK_INJECTION_MIN_SCORE: '-1',
-      CLAUDE_MEMORY_HOOK_SEMANTIC_MIN_SCORE: '2',
-      CLAUDE_MEMORY_HOOK_KEYWORD_MIN_SCORE: 'not-a-number',
-      CLAUDE_MEMORY_HOOK_FALLBACK_KEYWORD_MIN_SCORE: '-0.2',
-      CLAUDE_MEMORY_HOOK_MAX_INJECTED: '2'
-    } as NodeJS.ProcessEnv);
-
-    expect(policy).toEqual({
-      minScore: 0.65,
-      semanticMinScore: 0.65,
-      keywordMinScore: 0.7,
-      fallbackKeywordMinScore: 0.8,
-      maxMemories: 2
-    });
-
-    expect(filterHookInjectableMemories([
-      { id: 'weak-unknown', type: 'user_prompt', content: 'weak unknown source', score: 0.1, source: 'unknown' },
-      { id: 'fallback-too-weak', type: 'user_prompt', content: 'weak fallback', score: 0.79, source: 'keyword', fallback: true }
-    ], policy)).toEqual([]);
-  });
-
-  it('keeps regular CLI/query search behavior independent from hook injection policy', async () => {
-    const memory = event('regular-low');
-    const service = new MemoryQueryService(
-      async () => {},
-      {
-        keywordSearch: async () => [{ event: memory, rank: -0.5 }],
-        getSessionEvents: async () => [memory],
-        getRecentEvents: async () => [memory]
-      }
-    );
-
-    const regularResults = await service.keywordSearch('weak keyword rescue', { topK: 1, minScore: 0.2 });
-    expect(regularResults).toEqual([{ event: memory, score: 1 }]);
-
-    const hookCandidates: HookMemoryCandidate[] = regularResults.map((result) => ({
-      id: result.event.id,
-      type: result.event.eventType,
-      content: result.event.content,
-      score: 0.5,
-      source: 'keyword'
-    }));
-    expect(filterHookInjectableMemories(hookCandidates, getHookInjectionPolicy())).toEqual([]);
-  });
-});

package/tests/apps/app-layer-boundary.test.ts

@@ -1,48 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { describe, expect, it } from 'vitest';
-
-const apiModules = [
-  'chat',
-  'citations',
-  'events',
-  'health',
-  'projects',
-  'search',
-  'sessions',
-  'stats',
-  'turns',
-  'utils'
-];
-
-describe('app-layer entrypoint boundaries', () => {
-  it('keeps CLI implementation under src/apps/cli while preserving src/cli compatibility', () => {
-    const packageJson = JSON.parse(readFileSync('package.json', 'utf8')) as {
-      scripts?: Record<string, string>;
-    };
-    const buildScript = readFileSync('scripts/build.ts', 'utf8');
-    const cliCompatSource = readFileSync('src/cli/index.ts', 'utf8');
-    const cliDisclosureCompatSource = readFileSync('src/cli/retrieval-disclosure-output.ts', 'utf8');
-
-    expect(packageJson.scripts?.dev).toBe('tsx src/apps/cli/index.ts');
-    expect(buildScript).toContain("entryPoints: ['src/apps/cli/index.ts']");
-    expect(cliCompatSource).toContain("../apps/cli/index.js");
-    expect(cliDisclosureCompatSource).toContain("../apps/cli/retrieval-disclosure-output.js");
-  });
-
-  it('keeps server implementation under src/apps/server while preserving src/server compatibility', () => {
-    const buildScript = readFileSync('scripts/build.ts', 'utf8');
-    const serverCompatSource = readFileSync('src/server/index.ts', 'utf8');
-    const apiIndexCompatSource = readFileSync('src/server/api/index.ts', 'utf8');
-
-    expect(buildScript).toContain("entryPoints: ['src/apps/server/index.ts']");
-    expect(buildScript).toContain("entryPoints: ['src/apps/server/api/index.ts']");
-    expect(serverCompatSource).toContain("../apps/server/index.js");
-    expect(apiIndexCompatSource).toContain("../../apps/server/api/index.js");
-
-    for (const moduleName of apiModules) {
-      const compatPath = `src/server/api/${moduleName}.ts`;
-      expect(existsSync(compatPath), `${compatPath} should exist`).toBe(true);
-      expect(readFileSync(compatPath, 'utf8')).toContain(`../../apps/server/api/${moduleName}.js`);
-    }
-  });
-});

package/tests/apps/claude-settings-hooks.test.ts

@@ -1,107 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import {
-  buildHookCommand,
-  getHooksConfig,
-  mergePluginHooksIntoSettings,
-  removePluginHooksFromSettings,
-  type ClaudeSettingsWithHooks
-} from '../../src/apps/cli/claude-settings-hooks.js';
-
-describe('Claude Code hook settings helpers', () => {
-  it('quotes hook paths so plugin installs work when the path contains spaces', () => {
-    expect(buildHookCommand('/tmp/project with spaces/dist', 'user-prompt-submit.js'))
-      .toBe("node '/tmp/project with spaces/dist/hooks/user-prompt-submit.js'");
-
-    const complexCommand = buildHookCommand("/tmp/project with $dollars 'quotes' and `ticks`/dist", 'stop.js');
-    expect(complexCommand).toContain("'\\''quotes'\\''");
-    expect(complexCommand).toContain('$dollars');
-    expect(complexCommand).toContain('`ticks`');
-
-    expect(getHooksConfig('/tmp/project with spaces/dist').UserPromptSubmit?.[0].hooks[0].command)
-      .toBe("node '/tmp/project with spaces/dist/hooks/user-prompt-submit.js'");
-  });
-
-  it('merges plugin hooks without replacing unrelated hooks in the same categories', () => {
-    const settings: ClaudeSettingsWithHooks = {
-      theme: 'dark',
-      hooks: {
-        UserPromptSubmit: [
-          {
-            matcher: 'existing',
-            hooks: [{ type: 'command', command: 'node /other/plugin.js' }]
-          }
-        ],
-        Stop: [
-          {
-            matcher: 'old-plugin',
-            hooks: [{ type: 'command', command: 'node /old/claude-memory-layer/dist/hooks/stop.js' }]
-          }
-        ]
-      }
-    };
-
-    const merged = mergePluginHooksIntoSettings(settings, '/new/plugin dist');
-
-    expect(merged.theme).toBe('dark');
-    expect(merged.hooks?.UserPromptSubmit).toEqual([
-      {
-        matcher: 'existing',
-        hooks: [{ type: 'command', command: 'node /other/plugin.js' }]
-      },
-      {
-        matcher: '',
-        hooks: [{ type: 'command', command: "node '/new/plugin dist/hooks/user-prompt-submit.js'" }]
-      }
-    ]);
-    expect(merged.hooks?.Stop).toEqual([
-      {
-        matcher: '',
-        hooks: [{ type: 'command', command: "node '/new/plugin dist/hooks/stop.js'" }]
-      }
-    ]);
-  });
-
-  it('uninstall removes only claude-memory-layer hook commands and leaves other hooks intact', () => {
-    const settings: ClaudeSettingsWithHooks = {
-      hooks: {
-        SessionStart: [
-          {
-            matcher: 'keep-and-remove',
-            hooks: [
-              { type: 'command', command: 'node /opt/claude-memory-layer/dist/hooks/session-start.js' },
-              { type: 'command', command: 'node /other/session-start-helper.js' }
-            ]
-          }
-        ],
-        PostToolUse: [
-          {
-            matcher: 'keep',
-            hooks: [
-              { type: 'command', command: 'node /other/post-tool-use-helper.js' },
-              { type: 'command', command: 'node /other-plugin/hooks/post-tool-use.js' }
-            ]
-          }
-        ]
-      }
-    };
-
-    const removed = removePluginHooksFromSettings(settings, '/opt/claude-memory-layer/dist');
-
-    expect(removed.hooks?.SessionStart).toEqual([
-      {
-        matcher: 'keep-and-remove',
-        hooks: [{ type: 'command', command: 'node /other/session-start-helper.js' }]
-      }
-    ]);
-    expect(removed.hooks?.PostToolUse).toEqual([
-      {
-        matcher: 'keep',
-        hooks: [
-          { type: 'command', command: 'node /other/post-tool-use-helper.js' },
-          { type: 'command', command: 'node /other-plugin/hooks/post-tool-use.js' }
-        ]
-      }
-    ]);
-  });
-});

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

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

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