claude-memory-layer 1.0.31 → 1.0.32

package/tests/core/memory-service-composition.test.ts

@@ -1,192 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-
-import {
-  createMemoryServiceComposition,
-  type MemoryServiceCompositionFactories
-} from '../../src/core/engine/memory-service-composition.js';
-import type { SharedStoreConfig, ToolObservationPayload } from '../../src/core/types.js';
-
-const sharedStoreConfig: SharedStoreConfig = {
-  enabled: true,
-  autoPromote: true,
-  searchShared: true,
-  minConfidenceForPromotion: 0.8,
-  sharedStoragePath: '~/shared-memory'
-};
-
-describe('createMemoryServiceComposition', () => {
-  it('wires engine, endless, shared, runtime, and embedding maintenance services for MemoryService', async () => {
-    const initialize = vi.fn(async () => undefined);
-    let projectHash: string | null = 'project-hash-1';
-    let projectPath: string | null = '/repo/project';
-
-    const sqliteStore = {
-      clearEmbeddingOutbox: vi.fn(async () => undefined),
-      getEventsPage: vi.fn(async () => [{ id: 'event-1', content: 'event content' }]),
-      enqueueForEmbedding: vi.fn(async () => undefined)
-    };
-    const vectorStore = { name: 'vector-store' };
-    const embedder = { getModelName: vi.fn(() => 'test-embedding-model') };
-    const retriever = { setSharedStores: vi.fn() };
-    const graduation = { name: 'graduation' };
-    const ingestService = { name: 'ingest' };
-    const queryService = { name: 'query' };
-    const retrievalOrchestrator = { name: 'retrieval-orchestrator' };
-    const retrievalDisclosureService = { name: 'retrieval-disclosure' };
-    const retrievalAnalyticsService = { name: 'retrieval-analytics' };
-    const endlessMemoryServices = { name: 'endless-memory' };
-    const sharedMemoryServices = {
-      isEnabled: vi.fn(() => true),
-      getEntryForDisclosure: vi.fn(async (entryId: string) => ({ id: entryId }))
-    };
-    const runtimeService = { getVectorWorker: vi.fn(() => ({ name: 'vector-worker' })) };
-    const embeddingMaintenanceService = { getEmbeddingModelName: vi.fn(() => 'maintenance-model') };
-
-    const factories: MemoryServiceCompositionFactories = {
-      expandPath: vi.fn((targetPath: string) => targetPath.replace('~', '/home/test')),
-      createToolObservationEmbedding: vi.fn((toolName: string) => `embedding:${toolName}`),
-      createMemoryEngineServices: vi.fn(() => ({
-        storagePath: '/expanded/storage',
-        sqliteStore,
-        vectorStore,
-        embedder,
-        matcher: { name: 'matcher' },
-        retriever,
-        retrievalOrchestrator,
-        retrievalDisclosureService,
-        retrievalAnalyticsService,
-        graduation,
-        mdMirror: { name: 'md-mirror' },
-        ingestService,
-        queryService
-      }) as any),
-      createEndlessMemoryServices: vi.fn(() => endlessMemoryServices as any),
-      createSharedMemoryServices: vi.fn(() => sharedMemoryServices as any),
-      createMemoryRuntimeService: vi.fn(() => runtimeService as any),
-      createEmbeddingMaintenanceService: vi.fn(() => embeddingMaintenanceService as any)
-    };
-
-    const composition = createMemoryServiceComposition({
-      config: {
-        storagePath: '~/memory-store',
-        embeddingModel: 'explicit-model',
-        readOnly: true,
-        lightweightMode: true,
-        embeddingOnly: true,
-        projectHash,
-        projectPath,
-        sharedStoreConfig
-      },
-      defaultSharedStoragePath: '/default/shared',
-      initialize,
-      getProjectHash: () => projectHash,
-      getProjectPath: () => projectPath,
-      factories
-    });
-
-    expect(factories.expandPath).toHaveBeenCalledWith('~/memory-store');
-    expect(factories.createMemoryEngineServices).toHaveBeenCalledWith(expect.objectContaining({
-      storagePath: '/home/test/memory-store',
-      readOnly: true,
-      embeddingModel: 'explicit-model',
-      cwd: '/repo/project',
-      initialize,
-      getProjectHash: expect.any(Function),
-      getProjectPath: expect.any(Function),
-      hasSharedStore: expect.any(Function),
-      sharedStore: expect.objectContaining({ get: expect.any(Function) }),
-      createToolObservationEmbedding: expect.any(Function)
-    }));
-
-    const engineOptions = vi.mocked(factories.createMemoryEngineServices).mock.calls[0][0];
-    expect(engineOptions.createToolObservationEmbedding({
-      toolName: 'Read',
-      metadata: { path: 'README.md' },
-      success: true
-    } as ToolObservationPayload)).toBe('embedding:Read');
-    expect(factories.createToolObservationEmbedding).toHaveBeenCalledWith(
-      'Read',
-      { path: 'README.md' },
-      true
-    );
-
-    expect(factories.createEndlessMemoryServices).toHaveBeenCalledWith({
-      eventStore: sqliteStore,
-      configStore: sqliteStore,
-      initialize
-    });
-    expect(factories.createSharedMemoryServices).toHaveBeenCalledWith({
-      config: sharedStoreConfig,
-      defaultSharedStoragePath: '/default/shared',
-      readOnly: true,
-      expandPath: expect.any(Function),
-      embedder,
-      retriever
-    });
-    expect(factories.createMemoryRuntimeService).toHaveBeenCalledWith(expect.objectContaining({
-      sqliteStore,
-      eventStore: sqliteStore,
-      vectorStore,
-      embedder,
-      retriever,
-      graduation,
-      endlessMemoryServices,
-      sharedMemoryServices,
-      readOnly: true,
-      lightweightMode: true,
-      embeddingOnly: true
-    }));
-    expect(factories.createEmbeddingMaintenanceService).toHaveBeenCalledWith(expect.objectContaining({
-      storagePath: '/home/test/memory-store',
-      initialize,
-      getEmbeddingModelName: expect.any(Function),
-      vectorStore,
-      eventStore: expect.objectContaining({
-        clearEmbeddingOutbox: expect.any(Function),
-        getEventsPage: expect.any(Function),
-        enqueueForEmbedding: expect.any(Function)
-      }),
-      getVectorWorker: expect.any(Function)
-    }));
-
-    const embeddingOptions = vi.mocked(factories.createEmbeddingMaintenanceService).mock.calls[0][0];
-    expect(embeddingOptions.getEmbeddingModelName()).toBe('test-embedding-model');
-    expect(embeddingOptions.getVectorWorker()).toEqual({ name: 'vector-worker' });
-    await embeddingOptions.eventStore.clearEmbeddingOutbox();
-    await expect(embeddingOptions.eventStore.getEventsPage(10, 0)).resolves.toEqual([
-      { id: 'event-1', content: 'event content' }
-    ]);
-    await embeddingOptions.eventStore.enqueueForEmbedding('event-1', 'event content');
-    expect(sqliteStore.clearEmbeddingOutbox).toHaveBeenCalled();
-    expect(sqliteStore.getEventsPage).toHaveBeenCalledWith(10, 0);
-    expect(sqliteStore.enqueueForEmbedding).toHaveBeenCalledWith('event-1', 'event content');
-
-    expect(await engineOptions.sharedStore?.get('shared-1')).toEqual({ id: 'shared-1' });
-    expect(engineOptions.hasSharedStore()).toBe(true);
-    projectHash = 'project-hash-2';
-    projectPath = '/repo/other';
-    expect(engineOptions.getProjectHash()).toBe('project-hash-2');
-    expect(engineOptions.getProjectPath?.()).toBe('/repo/other');
-
-    expect(composition).toMatchObject({
-      storagePath: '/home/test/memory-store',
-      readOnly: true,
-      lightweightMode: true,
-      embeddingOnly: true,
-      sqliteStore,
-      vectorStore,
-      embedder,
-      retriever,
-      retrievalOrchestrator,
-      retrievalDisclosureService,
-      retrievalAnalyticsService,
-      graduation,
-      ingestService,
-      queryService,
-      endlessMemoryServices,
-      sharedMemoryServices,
-      runtimeService,
-      embeddingMaintenanceService
-    });
-  });
-});

package/tests/core/memory-service-config.test.ts

@@ -1,41 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import {
-  DEFAULT_ENABLED_SHARED_STORE_CONFIG as CONFIG_DEFAULT_ENABLED_SHARED_STORE_CONFIG,
-  DISABLED_SHARED_STORE_CONFIG as CONFIG_DISABLED_SHARED_STORE_CONFIG,
-  DEFAULT_SHARED_STORAGE_PATH as CONFIG_DEFAULT_SHARED_STORAGE_PATH
-} from '../../src/services/memory-service-config.js';
-import {
-  DEFAULT_ENABLED_SHARED_STORE_CONFIG as FACADE_DEFAULT_ENABLED_SHARED_STORE_CONFIG,
-  DISABLED_SHARED_STORE_CONFIG as FACADE_DISABLED_SHARED_STORE_CONFIG
-} from '../../src/services/memory-service.js';
-
-/**
- * MemoryService should stay a thin compatibility facade. Shared defaults are
- * owned by memory-service-config so registries can import them without pulling
- * in the MemoryService class and creating a service-locator cycle.
- */
-describe('memory-service-config', () => {
-  it('owns disabled shared-store defaults while memory-service preserves the public export', () => {
-    expect(CONFIG_DISABLED_SHARED_STORE_CONFIG).toMatchObject({
-      enabled: false,
-      autoPromote: false,
-      searchShared: false,
-      minConfidenceForPromotion: 0.8
-    });
-    expect(CONFIG_DISABLED_SHARED_STORE_CONFIG.sharedStoragePath).toContain('.claude-code');
-    expect(CONFIG_DISABLED_SHARED_STORE_CONFIG.sharedStoragePath).toContain('shared');
-    expect(FACADE_DISABLED_SHARED_STORE_CONFIG).toBe(CONFIG_DISABLED_SHARED_STORE_CONFIG);
-  });
-
-  it('owns enabled shared-store defaults while memory-service preserves the public export', () => {
-    expect(CONFIG_DEFAULT_ENABLED_SHARED_STORE_CONFIG).toEqual({
-      enabled: true,
-      autoPromote: true,
-      searchShared: true,
-      minConfidenceForPromotion: 0.8,
-      sharedStoragePath: CONFIG_DEFAULT_SHARED_STORAGE_PATH
-    });
-    expect(FACADE_DEFAULT_ENABLED_SHARED_STORE_CONFIG).toBe(CONFIG_DEFAULT_ENABLED_SHARED_STORE_CONFIG);
-  });
-});

package/tests/core/memory-service-facade.test.ts

@@ -1,30 +0,0 @@
-import { mkdtemp } from 'fs/promises';
-import * as os from 'os';
-import * as path from 'path';
-
-import { describe, expect, it } from 'vitest';
-
-import {
-  DISABLED_SHARED_STORE_CONFIG,
-  MemoryService
-} from '../../src/services/memory-service.js';
-
-describe('MemoryService facade delegation', () => {
-  it('reads the embedding model name through the embedding maintenance facade', async () => {
-    const storagePath = await mkdtemp(path.join(os.tmpdir(), 'memory-service-facade-'));
-    const service = new MemoryService({
-      storagePath,
-      sharedStoreConfig: DISABLED_SHARED_STORE_CONFIG
-    });
-    const serviceInternals = service as unknown as {
-      embedder: { getModelName(): string };
-      embeddingMaintenanceService: { getEmbeddingModelName(): string };
-    };
-    serviceInternals.embedder = { getModelName: () => 'direct-embedder-model' };
-    serviceInternals.embeddingMaintenanceService = {
-      getEmbeddingModelName: () => 'maintenance-facade-model'
-    };
-
-    expect(service.getEmbeddingModelName()).toBe('maintenance-facade-model');
-  });
-});

package/tests/core/memory-service-registry.test.ts

@@ -1,206 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { describe, expect, it } from 'vitest';
-
-import { createMemoryServiceRegistry } from '../../src/services/memory-service-registry.js';
-import type { SharedStoreConfig } from '../../src/core/types.js';
-
-interface FakeService {
-  config: Record<string, unknown>;
-}
-
-const disabledSharedStoreConfig: SharedStoreConfig = {
-  enabled: false,
-  autoPromote: false,
-  searchShared: false,
-  minConfidenceForPromotion: 0.8,
-  sharedStoragePath: '/home/test/.claude-code/memory/shared'
-};
-
-function createRegistry(sessionProject?: { projectHash: string; projectPath: string }) {
-  const createdConfigs: Array<Record<string, unknown>> = [];
-  const registry = createMemoryServiceRegistry<FakeService>({
-    createService: (config) => {
-      createdConfigs.push(config as unknown as Record<string, unknown>);
-      return { config: config as unknown as Record<string, unknown> };
-    },
-    hashProjectPath: (projectPath) => `hash:${projectPath}`,
-    getProjectStoragePath: (projectPath) => `/storage/${projectPath}`,
-    getSessionProject: (sessionId) => sessionId === 'known-session' ? sessionProject ?? null : null,
-    homedir: () => '/home/test',
-    disabledSharedStoreConfig
-  });
-
-  return { registry, createdConfigs };
-}
-
-describe('createMemoryServiceRegistry', () => {
-  it('stays independent from the MemoryService facade to avoid service-locator cycles', () => {
-    const source = readFileSync('src/services/memory-service-registry.ts', 'utf8');
-
-    expect(source).not.toContain("from './memory-service.js'");
-    expect(source).not.toContain('from "./memory-service.js"');
-  });
-
-  it('caches the default writable service with global storage and disabled shared store', () => {
-    const { registry, createdConfigs } = createRegistry();
-
-    const first = registry.getDefaultMemoryService();
-    const second = registry.getDefaultMemoryService();
-
-    expect(first).toBe(second);
-    expect(createdConfigs).toHaveLength(1);
-    expect(first.config).toMatchObject({
-      storagePath: '~/.claude-code/memory',
-      analyticsEnabled: false,
-      sharedStoreConfig: disabledSharedStoreConfig
-    });
-  });
-
-  it('creates fresh read-only services to avoid holding locks', () => {
-    const { registry, createdConfigs } = createRegistry();
-
-    const first = registry.getReadOnlyMemoryService();
-    const second = registry.getReadOnlyMemoryService();
-
-    expect(first).not.toBe(second);
-    expect(createdConfigs).toHaveLength(2);
-    expect(first.config).toMatchObject({
-      storagePath: '~/.claude-code/memory',
-      readOnly: true,
-      analyticsEnabled: false,
-      sharedStoreConfig: disabledSharedStoreConfig
-    });
-  });
-
-  it('caches project services by project hash and preserves project scope config', () => {
-    const { registry, createdConfigs } = createRegistry();
-
-    const first = registry.getMemoryServiceForProject('/workspace/app');
-    const second = registry.getMemoryServiceForProject('/workspace/app');
-
-    expect(first).toBe(second);
-    expect(createdConfigs).toHaveLength(1);
-    expect(first.config).toMatchObject({
-      storagePath: '/storage//workspace/app',
-      projectHash: 'hash:/workspace/app',
-      projectPath: '/workspace/app',
-      analyticsEnabled: false,
-      sharedStoreConfig: disabledSharedStoreConfig
-    });
-  });
-
-  it('preserves the first shared store config for cached project services', () => {
-    const { registry, createdConfigs } = createRegistry();
-    const firstSharedConfig: SharedStoreConfig = {
-      ...disabledSharedStoreConfig,
-      enabled: true,
-      searchShared: true,
-      sharedStoragePath: '/shared/first'
-    };
-    const laterSharedConfig: SharedStoreConfig = {
-      ...disabledSharedStoreConfig,
-      enabled: true,
-      autoPromote: true,
-      sharedStoragePath: '/shared/later'
-    };
-
-    const first = registry.getMemoryServiceForProject('/workspace/app', firstSharedConfig);
-    const second = registry.getMemoryServiceForProject('/workspace/app', laterSharedConfig);
-
-    expect(second).toBe(first);
-    expect(createdConfigs).toHaveLength(1);
-    expect(first.config.sharedStoreConfig).toBe(firstSharedConfig);
-    expect(first.config.sharedStoreConfig).not.toBe(laterSharedConfig);
-  });
-
-  it('resolves session services from the session registry and falls back to global service', () => {
-    const { registry } = createRegistry({
-      projectHash: 'registered-hash',
-      projectPath: '/workspace/registered'
-    });
-
-    const projectService = registry.getMemoryServiceForSession('known-session');
-    const directService = registry.getMemoryServiceForProject('/workspace/registered');
-    const fallbackService = registry.getMemoryServiceForSession('unknown-session');
-
-    expect(projectService).toBe(directService);
-    expect(fallbackService).toBe(registry.getDefaultMemoryService());
-  });
-
-  it('keeps registry methods safe when callers destructure a custom registry', () => {
-    const { registry } = createRegistry({
-      projectHash: 'registered-hash',
-      projectPath: '/workspace/registered'
-    });
-    const {
-      getDefaultMemoryService,
-      getMemoryServiceForProject,
-      getMemoryServiceForSession
-    } = registry;
-
-    const projectService = getMemoryServiceForSession('known-session');
-    const directService = getMemoryServiceForProject('/workspace/registered');
-    const fallbackService = getMemoryServiceForSession('unknown-session');
-
-    expect(projectService).toBe(directService);
-    expect(fallbackService).toBe(getDefaultMemoryService());
-  });
-
-  it('caches lightweight services separately for project and global sessions', () => {
-    const { registry } = createRegistry({
-      projectHash: 'registered-hash',
-      projectPath: '/workspace/registered'
-    });
-
-    const projectService = registry.getLightweightMemoryService('known-session');
-    const sameProjectService = registry.getLightweightMemoryService('known-session');
-    const globalService = registry.getLightweightMemoryService('unknown-session');
-
-    expect(projectService).toBe(sameProjectService);
-    expect(projectService).not.toBe(globalService);
-    expect(projectService.config).toMatchObject({
-      storagePath: '/storage//workspace/registered',
-      projectHash: 'registered-hash',
-      projectPath: '/workspace/registered',
-      lightweightMode: true,
-      analyticsEnabled: false,
-      sharedStoreConfig: disabledSharedStoreConfig
-    });
-    expect(globalService.config).toMatchObject({
-      storagePath: '/home/test/.claude-code/memory',
-      lightweightMode: true,
-      analyticsEnabled: false,
-      sharedStoreConfig: disabledSharedStoreConfig
-    });
-  });
-
-  it('caches lightweight project services for CLI read paths without reusing the full project service', () => {
-    const { registry, createdConfigs } = createRegistry();
-
-    const fullProjectService = registry.getMemoryServiceForProject('/workspace/app');
-    const lightweightProjectService = registry.getLightweightMemoryServiceForProject('/workspace/app');
-    const sameLightweightProjectService = registry.getLightweightMemoryServiceForProject('/workspace/app');
-
-    expect(lightweightProjectService).toBe(sameLightweightProjectService);
-    expect(lightweightProjectService).not.toBe(fullProjectService);
-    expect(createdConfigs).toHaveLength(2);
-    expect(lightweightProjectService.config).toMatchObject({
-      storagePath: '/storage//workspace/app',
-      projectHash: 'hash:/workspace/app',
-      projectPath: '/workspace/app',
-      lightweightMode: true,
-      analyticsEnabled: false,
-      sharedStoreConfig: disabledSharedStoreConfig
-    });
-  });
-
-  it('creates uncached services through the explicit factory facade', () => {
-    const { registry } = createRegistry();
-
-    const first = registry.createMemoryService({ storagePath: '/tmp/a' });
-    const second = registry.createMemoryService({ storagePath: '/tmp/a' });
-
-    expect(first).not.toBe(second);
-    expect(first.config).toMatchObject({ storagePath: '/tmp/a' });
-  });
-});

package/tests/core/product-validation-matrix.test.ts

@@ -1,61 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import {
-  getProductValidationMatrixSummary,
-  productValidationMatrix,
-  renderProductValidationMatrixMarkdown
-} from '../../src/core/product-validation-matrix.js';
-
-const requiredSurfaces = [
-  'claude.adapter.import',
-  'claude.adapter.search',
-  'claude.adapter.disclosure',
-  'codex.adapter.scan',
-  'codex.adapter.import',
-  'codex.adapter.replay',
-  'hermes.adapter.scan',
-  'hermes.adapter.import',
-  'hermes.adapter.replay',
-  'mcp.context.pack',
-  'mcp.project.timeline',
-  'mcp.source.ref',
-  'cli.api.reporting',
-  'safety.dryRun'
-];
-
-describe('product validation matrix', () => {
-  it('covers the product-level validation surfaces with requirements and evidence', () => {
-    const surfaceIds = new Set(productValidationMatrix.map((surface) => surface.id));
-
-    for (const id of requiredSurfaces) {
-      expect(surfaceIds.has(id), `missing surface ${id}`).toBe(true);
-    }
-
-    for (const surface of productValidationMatrix) {
-      expect(surface.title).toBeTruthy();
-      expect(surface.requirements.length, `${surface.id} requirements`).toBeGreaterThan(0);
-      expect(surface.evidence.length, `${surface.id} evidence`).toBeGreaterThan(0);
-      expect(['ready', 'covered', 'partial', 'planned']).toContain(surface.status);
-    }
-  });
-
-  it('summarizes and renders a stable reporting-friendly matrix', () => {
-    const summary = getProductValidationMatrixSummary(productValidationMatrix);
-    expect(summary.totalSurfaces).toBeGreaterThanOrEqual(requiredSurfaces.length);
-    expect(summary.surfacesByArea.codex).toBeGreaterThanOrEqual(3);
-    expect(summary.surfacesByArea.hermes).toBeGreaterThanOrEqual(3);
-    expect(summary.surfacesByArea.mcp).toBeGreaterThanOrEqual(3);
-    expect(summary.surfacesByArea.claude).toBeGreaterThanOrEqual(3);
-    expect(summary.evidenceCount).toBeGreaterThanOrEqual(requiredSurfaces.length);
-
-    const markdown = renderProductValidationMatrixMarkdown(productValidationMatrix);
-    expect(markdown).toContain('# Product Validation Matrix');
-    expect(markdown).toContain('Codex adapter replay');
-    expect(markdown).toContain('Hermes adapter replay');
-    expect(markdown).toContain('MCP context pack');
-    expect(markdown).toContain('MCP source reference');
-    expect(markdown).toContain('Safety / dry-run');
-    expect(markdown).toContain('tests/core/codex-session-history-importer-validation.test.ts');
-    expect(markdown).toContain('tests/core/hermes-session-history-importer-validation.test.ts');
-  });
-});

package/tests/core/project-registry.test.ts

@@ -1,78 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import * as fs from 'node:fs/promises';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import {
-  getProjectStoragePath,
-  hashProjectPath,
-  normalizeProjectPath,
-  resolveProjectStoragePath
-} from '../../src/core/registry/project-path.js';
-
-describe('project-path registry utilities', () => {
-  it('normalizes paths and generates stable hashes', async () => {
-    const root = await fs.mkdtemp(path.join(os.tmpdir(), 'cml-project-path-'));
-    const projectDir = path.join(root, 'project');
-    await fs.mkdir(projectDir, { recursive: true });
-
-    const hashA = hashProjectPath(projectDir);
-    const hashB = hashProjectPath(projectDir + '/');
-
-    const normalized = normalizeProjectPath(projectDir + '/');
-
-    expect(normalized.endsWith('/project')).toBe(true);
-    expect(hashA).toBe(hashB);
-    expect(hashA).toMatch(/^[a-f0-9]{8}$/);
-  });
-
-  it('resolves storage paths for both project paths and explicit hashes', async () => {
-    const root = await fs.mkdtemp(path.join(os.tmpdir(), 'cml-storage-path-'));
-    const projectDir = path.join(root, 'project');
-    await fs.mkdir(projectDir, { recursive: true });
-
-    const projectHash = hashProjectPath(projectDir);
-    const storageFromPath = getProjectStoragePath(projectDir);
-    const storageFromResolverPath = resolveProjectStoragePath(projectDir);
-    const storageFromResolverHash = resolveProjectStoragePath(projectHash);
-
-    expect(storageFromPath).toBe(storageFromResolverPath);
-    expect(storageFromResolverHash).toContain(path.join('.claude-code', 'memory', 'projects', projectHash));
-  });
-});
-
-describe('session registry utilities', () => {
-  afterEach(() => {
-    vi.resetModules();
-    vi.doUnmock('os');
-  });
-
-  it('registers and loads project mapping from the isolated home directory', async () => {
-    const tempHome = await fs.mkdtemp(path.join(os.tmpdir(), 'cml-home-'));
-    const projectDir = path.join(tempHome, 'workspace', 'project');
-    await fs.mkdir(projectDir, { recursive: true });
-
-    vi.doMock('os', async () => {
-      const actual = await vi.importActual<typeof import('os')>('os');
-      return {
-        ...actual,
-        homedir: () => tempHome
-      };
-    });
-
-    const registryModule = await import('../../src/core/registry/session-registry.js');
-
-    registryModule.registerSession('session-123', projectDir);
-    const projectInfo = registryModule.getSessionProject('session-123');
-
-    expect(projectInfo).not.toBeNull();
-    expect(projectInfo?.projectPath.endsWith('/workspace/project')).toBe(true);
-    expect(projectInfo?.projectHash).toBe(hashProjectPath(projectDir));
-
-    const registryPath = path.join(tempHome, '.claude-code', 'memory', 'session-registry.json');
-    const saved = JSON.parse(await fs.readFile(registryPath, 'utf8')) as {
-      sessions: Record<string, { projectPath: string }>;
-    };
-
-    expect(saved.sessions['session-123']?.projectPath.endsWith('/workspace/project')).toBe(true);
-  });
-});