claude-memory-layer 1.0.27 → 1.0.28

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

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

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

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

@@ -0,0 +1,140 @@
+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/{bootstrap-organizer.test.ts → core/bootstrap-organizer.test.ts}

@@ -3,7 +3,7 @@ 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';
+import { bootstrapKnowledgeBase } from '../../src/services/bootstrap-organizer.js';
 
 async function makeTempRepo(): Promise<string> {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), 'cml-bootstrap-'));

package/tests/{canonical-key.test.ts → core/canonical-key.test.ts}

@@ -8,7 +8,7 @@ import {
   isSameCanonicalKey,
   makeDedupeKey,
   hashContent
-} from '../src/core/canonical-key.js';
+} from '../../src/core/canonical-key.js';
 
 describe('makeCanonicalKey', () => {
   it('should normalize to lowercase', () => {

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

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

package/tests/{consolidation-worker.test.ts → core/consolidation-worker.test.ts}

@@ -1,7 +1,7 @@
 import { describe, it, expect } from 'vitest';
 
-import { ConsolidationWorker } from '../src/core/consolidation-worker.js';
-import type { EndlessModeConfig, MemoryEvent } from '../src/core/types.js';
+import { ConsolidationWorker } from '../../src/core/consolidation-worker.js';
+import type { EndlessModeConfig, MemoryEvent } from '../../src/core/types.js';
 
 function makeEvent(id: string, content: string, hoursAgo = 20): MemoryEvent {
   return {