claude-memory-layer 1.0.30 → 1.0.32

package/tests/apps/stats-api-lightweight.test.ts

@@ -1,67 +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(),
-    getStats: vi.fn(),
-    getRecentEvents: vi.fn(),
-    getRetrievalTraceStats: vi.fn()
-  };
-
-  return {
-    service,
-    getServiceFromQuery: vi.fn(),
-    getLightweightServiceFromQuery: vi.fn(() => service)
-  };
-});
-
-vi.mock('../../src/apps/server/api/utils.js', () => ({
-  getServiceFromQuery: mocks.getServiceFromQuery,
-  getLightweightServiceFromQuery: mocks.getLightweightServiceFromQuery
-}));
-
-vi.mock('../../src/services/memory-service.js', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('../../src/services/memory-service.js')>();
-  return {
-    ...actual,
-    getMemoryServiceForProject: vi.fn(() => mocks.service)
-  };
-});
-
-const { statsRouter } = await import('../../src/server/api/stats.js');
-
-function createApp() {
-  const app = new Hono();
-  app.route('/api/stats', statsRouter);
-  return app;
-}
-
-describe('stats API lightweight read paths', () => {
-  beforeEach(() => {
-    mocks.service.initialize.mockReset().mockResolvedValue(undefined);
-    mocks.service.shutdown.mockReset().mockResolvedValue(undefined);
-    mocks.service.getStats.mockReset().mockResolvedValue({ totalEvents: 2, vectorCount: 0, levelStats: [] });
-    mocks.service.getRecentEvents.mockReset().mockResolvedValue([
-      { id: 'e1', eventType: 'user_prompt', sessionId: 's1', timestamp: new Date('2026-05-01T00:00:00.000Z'), content: 'prompt', metadata: {} },
-      { id: 'e2', eventType: 'agent_response', sessionId: 's1', timestamp: new Date('2026-05-01T00:01:00.000Z'), content: 'response', metadata: {} }
-    ]);
-    mocks.service.getRetrievalTraceStats.mockReset().mockResolvedValue({ totalQueries: 0, avgCandidateCount: 0, avgSelectedCount: 0, selectionRate: 0 });
-    mocks.getServiceFromQuery.mockClear();
-    mocks.getLightweightServiceFromQuery.mockClear();
-  });
-
-  it('GET /api/stats uses the lightweight read-only service instead of full initialization service', async () => {
-    const res = await createApp().request('/api/stats?project=abc12345');
-
-    expect(res.status).toBe(200);
-    const body = await res.json();
-    expect(body.storage).toEqual({ eventCount: 2, vectorCount: 0 });
-    expect(body.sessions).toEqual({ total: 1 });
-    expect(mocks.getLightweightServiceFromQuery).toHaveBeenCalledTimes(1);
-    expect(mocks.getServiceFromQuery).not.toHaveBeenCalled();
-    expect(mocks.service.initialize).toHaveBeenCalledTimes(1);
-    expect(mocks.service.shutdown).toHaveBeenCalledTimes(1);
-  });
-});

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

@@ -1,140 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import * as vm from 'node:vm';
-
-class TestElement {
-  innerHTML = '';
-  textContent = '';
-  style: Record<string, string> = {};
-  disabled = false;
-  classList = { add() {}, remove() {}, toggle() {} };
-  dataset: Record<string, string> = {};
-  options: unknown[] = [];
-  addEventListener() {}
-  querySelectorAll() { return []; }
-  appendChild() {}
-}
-
-function loadDashboardWithElements(elements: Record<string, TestElement>) {
-  const dashboardDir = join(process.cwd(), 'src/apps/dashboard/assets/js');
-  const source = ['state.js', 'views.js', 'disclosure.js']
-    .map(file => readFileSync(join(dashboardDir, file), 'utf-8'))
-    .join('\n');
-  const context = {
-    console,
-    URL,
-    fetch: async () => ({ ok: true, json: async () => ({}) }),
-    window: { location: { origin: 'http://localhost:37777' } },
-    document: {
-      addEventListener() {},
-      getElementById(id: string) { return elements[id] ?? null; },
-      querySelectorAll() { return []; },
-      querySelector() { return null; },
-      createElement() { return new TestElement(); }
-    },
-    setTimeout,
-    clearTimeout
-  };
-
-  vm.runInNewContext(
-    `${source}\n;globalThis.__dashboardTestHooks = { state, renderDisclosureResults, renderDisclosureDrilldown };`,
-    context
-  );
-  return (context as unknown as { __dashboardTestHooks: {
-    state: Record<string, any>;
-    renderDisclosureResults: () => void;
-    renderDisclosureDrilldown: () => void;
-  }}).__dashboardTestHooks;
-}
-
-describe('dashboard retrieval disclosure provenance output', () => {
-  it('renders shared search results with source/project/topics provenance', () => {
-    const elements = { 'disclosure-results': new TestElement() };
-    const hooks = loadDashboardWithElements(elements);
-
-    hooks.state.isDisclosureLoading = false;
-    hooks.state.disclosureSelectedId = 'shared:shared-1';
-    hooks.state.disclosureMeta = { total: 1, usedVector: true, usedKeyword: true, fallbackApplied: false };
-    hooks.state.disclosureResults = [
-      {
-        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']
-        }
-      }
-    ];
-
-    hooks.renderDisclosureResults();
-
-    const html = elements['disclosure-results'].innerHTML;
-    expect(html).toContain('shared:shared-1');
-    expect(html).toContain('Shared checkout troubleshooting');
-    expect(html).toContain('sourceProjectHash');
-    expect(html).toContain('project-a');
-    expect(html).toContain('topics');
-    expect(html).toContain('checkout');
-  });
-
-  it('renders shared drilldown with explicit source metadata and no fake raw event', () => {
-    const elements = { 'disclosure-drilldown': new TestElement() };
-    const hooks = loadDashboardWithElements(elements);
-
-    hooks.state.disclosureSelectedId = 'shared:shared-1';
-    hooks.state.disclosureExpansion = {
-      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\nSolution: clear cache and retry'
-    };
-    hooks.state.disclosureSource = {
-      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'
-      }
-    };
-
-    hooks.renderDisclosureDrilldown();
-
-    const html = elements['disclosure-drilldown'].innerHTML;
-    expect(html).toContain('shared_troubleshooting');
-    expect(html).toContain('Shared source provenance');
-    expect(html).toContain('sourceProjectHash');
-    expect(html).toContain('project-a');
-    expect(html).toContain('rootCause');
-    expect(html).toContain('stale cache');
-    expect(html).toContain('solution');
-    expect(html).toContain('clear cache and retry');
-    expect(html).toContain('No local raw events for this shared source.');
-  });
-});

package/tests/core/bootstrap-organizer.test.ts

@@ -1,111 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import * as fs from 'node:fs/promises';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { execSync } from 'node:child_process';
-import { bootstrapKnowledgeBase } from '../../src/services/bootstrap-organizer.js';
-
-async function makeTempRepo(): Promise<string> {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'cml-bootstrap-'));
-  execSync('git init', { cwd: root, stdio: 'ignore' });
-  execSync('git config user.email test@example.com', { cwd: root, stdio: 'ignore' });
-  execSync('git config user.name test-bot', { cwd: root, stdio: 'ignore' });
-
-  await fs.mkdir(path.join(root, 'src'), { recursive: true });
-  await fs.mkdir(path.join(root, 'tests'), { recursive: true });
-
-  await fs.writeFile(path.join(root, 'src', 'index.ts'), 'export const hello = () => "world";\n', 'utf8');
-  await fs.writeFile(path.join(root, 'src', 'worker.ts'), 'export const runWorker = () => true;\n', 'utf8');
-  await fs.writeFile(path.join(root, 'tests', 'index.test.ts'), 'describe("x", () => {});\n', 'utf8');
-
-  execSync('git add .', { cwd: root, stdio: 'ignore' });
-  execSync('git commit -m "feat: initial project scaffolding"', { cwd: root, stdio: 'ignore' });
-
-  await fs.writeFile(path.join(root, 'src', 'worker.ts'), 'export const runWorker = () => "ok";\n', 'utf8');
-  execSync('git add src/worker.ts', { cwd: root, stdio: 'ignore' });
-  execSync('git commit -m "refactor: stabilize worker return type"', { cwd: root, stdio: 'ignore' });
-
-  return root;
-}
-
-describe('bootstrapKnowledgeBase', () => {
-  it('generates structured bootstrap outputs with metadata', async () => {
-    const repo = await makeTempRepo();
-    const outDir = path.join(repo, '.generated-kb');
-
-    const result = await bootstrapKnowledgeBase({
-      repoPath: repo,
-      outDir,
-      since: '365 days ago',
-      maxCommits: 50
-    });
-
-    expect(result.fileCount).toBeGreaterThan(0);
-    expect(result.commitCount).toBeGreaterThan(0);
-
-    const expected = [
-      path.join(outDir, 'overview', 'overview.md'),
-      path.join(outDir, 'modules', 'src.md'),
-      path.join(outDir, 'decisions', 'decisions.md'),
-      path.join(outDir, 'timeline', 'timeline.md'),
-      path.join(outDir, 'glossary', 'glossary.md'),
-      path.join(outDir, 'sources', 'manifest.md'),
-      path.join(outDir, 'sources', 'manifest.json')
-    ];
-
-    for (const file of expected) {
-      const stat = await fs.stat(file);
-      expect(stat.isFile()).toBe(true);
-    }
-
-    const overview = await fs.readFile(path.join(outDir, 'overview', 'overview.md'), 'utf8');
-    expect(overview).toContain('deterministicPipeline: true');
-    expect(overview).toContain('- confidence:');
-    expect(overview).toContain('- source:');
-
-    const decisions = await fs.readFile(path.join(outDir, 'decisions', 'decisions.md'), 'utf8');
-    expect(decisions).toContain('commit:');
-
-    const manifestJson = JSON.parse(await fs.readFile(path.join(outDir, 'sources', 'manifest.json'), 'utf8')) as {
-      deterministicPipeline: boolean;
-      outputs: string[];
-    };
-    expect(manifestJson.deterministicPipeline).toBe(true);
-    expect(manifestJson.outputs.length).toBeGreaterThan(0);
-  });
-
-  it('supports incremental bootstrap mode with manifest baseline', async () => {
-    const repo = await makeTempRepo();
-    const outDir = path.join(repo, '.generated-kb');
-
-    await bootstrapKnowledgeBase({
-      repoPath: repo,
-      outDir,
-      since: '365 days ago',
-      maxCommits: 50,
-      incremental: false
-    });
-
-    await fs.writeFile(path.join(repo, 'src', 'index.ts'), 'export const hello = () => "world2";\n', 'utf8');
-    execSync('git add src/index.ts', { cwd: repo, stdio: 'ignore' });
-    execSync('git commit -m "feat: change index output"', { cwd: repo, stdio: 'ignore' });
-
-    const result = await bootstrapKnowledgeBase({
-      repoPath: repo,
-      outDir,
-      maxCommits: 50,
-      incremental: true
-    });
-
-    expect(result.commitCount).toBeGreaterThan(0);
-
-    const manifestJson = JSON.parse(await fs.readFile(path.join(outDir, 'sources', 'manifest.json'), 'utf8')) as {
-      mode: string;
-      options?: { incremental?: boolean };
-      stats?: { modulesGenerated?: number };
-    };
-    expect(manifestJson.mode).toBe('incremental');
-    expect(manifestJson.options?.incremental).toBe(true);
-    expect((manifestJson.stats?.modulesGenerated ?? 0)).toBeGreaterThan(0);
-  });
-});

package/tests/core/canonical-key.test.ts

@@ -1,101 +0,0 @@
-/**
- * Tests for canonical key functions
- */
-
-import { describe, it, expect } from 'vitest';
-import {
-  makeCanonicalKey,
-  isSameCanonicalKey,
-  makeDedupeKey,
-  hashContent
-} from '../../src/core/canonical-key.js';
-
-describe('makeCanonicalKey', () => {
-  it('should normalize to lowercase', () => {
-    expect(makeCanonicalKey('Hello World')).toBe('hello world');
-  });
-
-  it('should remove punctuation', () => {
-    expect(makeCanonicalKey('Hello, World!')).toBe('hello world');
-  });
-
-  it('should normalize unicode (NFKC)', () => {
-    // Full-width characters should be normalized
-    expect(makeCanonicalKey('Ｈｅｌｌｏ')).toBe('hello');
-  });
-
-  it('should collapse whitespace', () => {
-    expect(makeCanonicalKey('hello   world')).toBe('hello world');
-    expect(makeCanonicalKey('hello\n\nworld')).toBe('hello world');
-    expect(makeCanonicalKey('  hello  world  ')).toBe('hello world');
-  });
-
-  it('should add project context when provided', () => {
-    const key = makeCanonicalKey('test', { project: 'myproject' });
-    expect(key).toBe('myproject::test');
-  });
-
-  it('should truncate long keys with MD5 suffix', () => {
-    const longTitle = 'a'.repeat(300);
-    const key = makeCanonicalKey(longTitle);
-    expect(key.length).toBeLessThanOrEqual(200);
-    expect(key).toMatch(/_[a-f0-9]{8}$/);
-  });
-});
-
-describe('isSameCanonicalKey', () => {
-  it('should return true for equivalent strings', () => {
-    expect(isSameCanonicalKey('Hello World', 'hello world')).toBe(true);
-    expect(isSameCanonicalKey('Hello, World!', 'hello world')).toBe(true);
-    expect(isSameCanonicalKey('  hello   world  ', 'hello world')).toBe(true);
-  });
-
-  it('should return false for different strings', () => {
-    expect(isSameCanonicalKey('hello', 'world')).toBe(false);
-    expect(isSameCanonicalKey('hello world', 'world hello')).toBe(false);
-  });
-});
-
-describe('makeDedupeKey', () => {
-  it('should create unique keys for different content', () => {
-    const key1 = makeDedupeKey('content1', 'session1');
-    const key2 = makeDedupeKey('content2', 'session1');
-    expect(key1).not.toBe(key2);
-  });
-
-  it('should create unique keys for different sessions', () => {
-    const key1 = makeDedupeKey('content', 'session1');
-    const key2 = makeDedupeKey('content', 'session2');
-    expect(key1).not.toBe(key2);
-  });
-
-  it('should create same key for same content and session', () => {
-    const key1 = makeDedupeKey('content', 'session');
-    const key2 = makeDedupeKey('content', 'session');
-    expect(key1).toBe(key2);
-  });
-
-  it('should include session ID prefix', () => {
-    const key = makeDedupeKey('content', 'session123');
-    expect(key.startsWith('session123:')).toBe(true);
-  });
-});
-
-describe('hashContent', () => {
-  it('should return consistent hash', () => {
-    const hash1 = hashContent('test content');
-    const hash2 = hashContent('test content');
-    expect(hash1).toBe(hash2);
-  });
-
-  it('should return different hash for different content', () => {
-    const hash1 = hashContent('content1');
-    const hash2 = hashContent('content2');
-    expect(hash1).not.toBe(hash2);
-  });
-
-  it('should return 64-character hex string (SHA-256)', () => {
-    const hash = hashContent('test');
-    expect(hash).toMatch(/^[a-f0-9]{64}$/);
-  });
-});

package/tests/core/codex-session-history-importer-validation.test.ts

@@ -1,185 +0,0 @@
-import { mkdtempSync, rmSync, utimesSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-import { createCodexSessionHistoryImporter, validateCodexSessions } from '../../src/services/codex-session-history-importer.js';
-
-const tempDirs: string[] = [];
-
-function tempDir() {
-  const dir = mkdtempSync(join(tmpdir(), 'cml-codex-validation-'));
-  tempDirs.push(dir);
-  return dir;
-}
-
-function writeJsonl(filePath: string, records: Array<string | Record<string, unknown>>) {
-  writeFileSync(
-    filePath,
-    records.map((record) => typeof record === 'string' ? record : JSON.stringify(record)).join('\n') + '\n',
-    'utf8'
-  );
-}
-
-afterEach(() => {
-  for (const dir of tempDirs.splice(0)) {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-describe('Codex session validation replay', () => {
-  it('dry-runs matching sessions by cwd without exposing transcript content', async () => {
-    const sessionsDir = tempDir();
-    const projectA = join(sessionsDir, 'project-a');
-    const projectB = join(sessionsDir, 'project-b');
-
-    writeJsonl(join(sessionsDir, 'rollout-2026-05-05T00-00-00-session-a.jsonl'), [
-      { type: 'session_meta', payload: { id: 'session-a', cwd: projectA, timestamp: '2026-05-05T00:00:00.000Z' } },
-      { type: 'response_item', timestamp: '2026-05-05T00:00:01.000Z', payload: { type: 'message', role: 'user', content: [{ type: 'input_text', text: 'please implement the Codex validation replay flow' }] } },
-      { type: 'response_item', timestamp: '2026-05-05T00:00:02.000Z', payload: { type: 'function_call', name: 'shell', arguments: '{}' } },
-      { type: 'response_item', timestamp: '2026-05-05T00:00:03.000Z', payload: { type: 'message', role: 'assistant', content: [{ type: 'output_text', text: 'validated answer that should never appear in aggregate reports' }] } },
-      { type: 'response_item', timestamp: '2026-05-05T00:00:04.000Z', payload: { type: 'message', role: 'assistant', content: [] } },
-      '{not valid json'
-    ]);
-
-    writeJsonl(join(sessionsDir, 'rollout-2026-05-05T00-00-00-session-b.jsonl'), [
-      { type: 'session_meta', payload: { id: 'session-b', cwd: projectB } },
-      { type: 'response_item', timestamp: '2026-05-05T00:01:01.000Z', payload: { type: 'message', role: 'user', content: [{ type: 'input_text', text: 'this should not match project a' }] } }
-    ]);
-
-    writeJsonl(join(sessionsDir, 'rollout-2026-05-05T00-00-00-session-missing-cwd.jsonl'), [
-      { type: 'session_meta', payload: { id: 'session-missing-cwd' } },
-      { type: 'response_item', timestamp: '2026-05-05T00:02:01.000Z', payload: { type: 'message', role: 'user', content: [{ type: 'input_text', text: 'missing cwd should be scanned but not project matched' }] } }
-    ]);
-
-    const report = await validateCodexSessions({ sessionsDir, projectPath: projectA });
-
-    expect(report.dryRun).toBe(true);
-    expect(report.willMutate).toBe(false);
-    expect(report.source.sessionsDir).toBe(sessionsDir);
-    expect(report.source.projectPath).toBe(projectA);
-    expect(report.totals.sessionsScanned).toBe(3);
-    expect(report.totals.sessionsMatched).toBe(1);
-    expect(report.totals.userMessages).toBe(1);
-    expect(report.totals.assistantMessages).toBe(1);
-    expect(report.totals.messagesNormalized).toBe(2);
-    expect(report.totals.turnsNormalized).toBe(1);
-    expect(report.totals.skippedUnsupportedRecords).toBe(1);
-    expect(report.totals.emptyAssistantMessages).toBe(1);
-    expect(report.totals.malformedLines).toBe(1);
-    expect(report.totals.missingProjectCwd).toBe(1);
-    expect(report.topProjects[0]).toMatchObject({ sessions: 1, userMessages: 1, assistantMessages: 1 });
-
-    const serialized = JSON.stringify(report);
-    expect(serialized).not.toContain('please implement the Codex validation replay flow');
-    expect(serialized).not.toContain('validated answer that should never appear');
-    expect(serialized).not.toContain('this should not match project a');
-  });
-
-  it('summarizes all sessions and counts malformed, unsupported, empty, and truncated content', async () => {
-    const sessionsDir = tempDir();
-    const projectA = join(sessionsDir, 'project-a');
-    const largeAssistantContent = 'A'.repeat(12_050);
-
-    writeJsonl(join(sessionsDir, 'rollout-2026-05-05T00-00-00-session-a.jsonl'), [
-      { type: 'session_meta', payload: { id: 'session-a', cwd: projectA } },
-      { type: 'response_item', timestamp: '2026-05-05T00:00:01.000Z', payload: { type: 'message', role: 'user', content: [{ type: 'input_text', text: 'normalize all Codex sessions' }] } },
-      { type: 'response_item', timestamp: '2026-05-05T00:00:02.000Z', payload: { type: 'message', role: 'assistant', content: [{ type: 'output_text', text: largeAssistantContent }] } },
-      { type: 'response_item', timestamp: '2026-05-05T00:00:03.000Z', payload: { type: 'message', role: 'assistant', content: [{ type: 'output_text', text: '' }] } },
-      { type: 'response_item', timestamp: '2026-05-05T00:00:04.000Z', payload: { type: 'reasoning', summary: [] } },
-      'not-json'
-    ]);
-
-    writeJsonl(join(sessionsDir, 'rollout-2026-05-05T00-00-00-session-unknown.jsonl'), [
-      { type: 'session_meta', payload: { id: 'session-unknown' } },
-      { type: 'response_item', timestamp: '2026-05-05T00:01:01.000Z', payload: { type: 'message', role: 'user', content: 'string content from real-world Codex JSONL' } }
-    ]);
-
-    const report = await validateCodexSessions({ sessionsDir, maxContentChars: 10_000 });
-
-    expect(report.totals.sessionsScanned).toBe(2);
-    expect(report.totals.sessionsMatched).toBe(2);
-    expect(report.totals.userMessages).toBe(2);
-    expect(report.totals.assistantMessages).toBe(1);
-    expect(report.totals.messagesNormalized).toBe(3);
-    expect(report.totals.turnsNormalized).toBe(2);
-    expect(report.totals.truncatedMessages).toBe(1);
-    expect(report.totals.emptyAssistantMessages).toBe(1);
-    expect(report.totals.skippedUnsupportedRecords).toBe(1);
-    expect(report.totals.malformedLines).toBe(1);
-    expect(report.totals.missingProjectCwd).toBe(1);
-    expect(report.topProjects).toHaveLength(2);
-    expect(report.warnings.some((warning) => warning.includes('missing cwd'))).toBe(true);
-  });
-
-  it('imports only the most recently modified matching Codex session when sessionLimit is set', async () => {
-    const sessionsDir = tempDir();
-    const projectA = join(sessionsDir, 'project-a');
-    const oldFile = join(sessionsDir, 'rollout-2026-05-05T00-00-00-session-old.jsonl');
-    const latestFile = join(sessionsDir, 'rollout-2026-05-05T00-10-00-session-latest.jsonl');
-
-    writeJsonl(oldFile, [
-      { type: 'session_meta', payload: { id: 'session-old', cwd: projectA } },
-      { type: 'response_item', timestamp: '2026-05-05T00:00:01.000Z', payload: { type: 'message', role: 'user', content: 'old Codex project session should not be imported now' } }
-    ]);
-    writeJsonl(latestFile, [
-      { type: 'session_meta', payload: { id: 'session-latest', cwd: projectA } },
-      { type: 'response_item', timestamp: '2026-05-05T00:10:01.000Z', payload: { type: 'message', role: 'user', content: 'latest Codex project session should be imported now' } }
-    ]);
-    utimesSync(oldFile, new Date('2026-05-05T00:00:00.000Z'), new Date('2026-05-05T00:00:00.000Z'));
-    utimesSync(latestFile, new Date('2026-05-05T00:10:00.000Z'), new Date('2026-05-05T00:10:00.000Z'));
-
-    const memoryService = {
-      startSession: vi.fn(async (_sessionId: string, _projectPath?: string) => undefined),
-      endSession: vi.fn(async (_sessionId: string) => undefined),
-      deleteSessionEvents: vi.fn(async (_sessionId: string) => 0),
-      storeUserPrompt: vi.fn(async () => ({ success: true, isDuplicate: false })),
-      storeAgentResponse: vi.fn(async () => ({ success: true, isDuplicate: false }))
-    };
-    const importer = createCodexSessionHistoryImporter(memoryService as never, { sessionsDir });
-
-    const result = await importer.importProject(projectA, { sessionLimit: 1 });
-
-    expect(result.totalSessions).toBe(1);
-    expect(memoryService.startSession).toHaveBeenCalledTimes(1);
-    expect(memoryService.startSession).toHaveBeenCalledWith('session-latest', projectA);
-    expect(memoryService.storeUserPrompt).toHaveBeenCalledTimes(1);
-  });
-
-  it('applies Codex import limit across selected matching sessions', async () => {
-    const sessionsDir = tempDir();
-    const projectA = join(sessionsDir, 'project-a');
-    const oldFile = join(sessionsDir, 'rollout-2026-05-05T00-00-00-session-old.jsonl');
-    const latestFile = join(sessionsDir, 'rollout-2026-05-05T00-10-00-session-latest.jsonl');
-
-    writeJsonl(oldFile, [
-      { type: 'session_meta', payload: { id: 'session-old', cwd: projectA } },
-      { type: 'response_item', timestamp: '2026-05-05T00:00:01.000Z', payload: { type: 'message', role: 'user', content: 'old prompt should remain outside the global Codex import limit' } },
-      { type: 'response_item', timestamp: '2026-05-05T00:00:02.000Z', payload: { type: 'message', role: 'assistant', content: 'old assistant should remain outside the global Codex import limit' } }
-    ]);
-    writeJsonl(latestFile, [
-      { type: 'session_meta', payload: { id: 'session-latest', cwd: projectA } },
-      { type: 'response_item', timestamp: '2026-05-05T00:10:01.000Z', payload: { type: 'message', role: 'user', content: 'latest prompt should be imported first' } },
-      { type: 'response_item', timestamp: '2026-05-05T00:10:02.000Z', payload: { type: 'message', role: 'assistant', content: 'latest assistant should be imported first' } }
-    ]);
-    utimesSync(oldFile, new Date('2026-05-05T00:00:00.000Z'), new Date('2026-05-05T00:00:00.000Z'));
-    utimesSync(latestFile, new Date('2026-05-05T00:10:00.000Z'), new Date('2026-05-05T00:10:00.000Z'));
-
-    const memoryService = {
-      startSession: vi.fn(async (_sessionId: string, _projectPath?: string) => undefined),
-      endSession: vi.fn(async (_sessionId: string) => undefined),
-      deleteSessionEvents: vi.fn(async (_sessionId: string) => 0),
-      storeUserPrompt: vi.fn(async () => ({ success: true, isDuplicate: false })),
-      storeAgentResponse: vi.fn(async () => ({ success: true, isDuplicate: false }))
-    };
-    const importer = createCodexSessionHistoryImporter(memoryService as never, { sessionsDir });
-
-    const result = await importer.importProject(projectA, { sessionLimit: 2, limit: 2 });
-
-    expect(result.totalSessions).toBe(1);
-    expect(memoryService.startSession).toHaveBeenCalledTimes(1);
-    expect(memoryService.startSession).toHaveBeenCalledWith('session-latest', projectA);
-    expect(memoryService.storeUserPrompt).toHaveBeenCalledTimes(1);
-    expect(memoryService.storeAgentResponse).toHaveBeenCalledTimes(1);
-  });
-});