claude-memory-layer 1.0.31 → 1.0.33

package/tests/core/session-history-importer-filter.test.ts

@@ -1,78 +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 {
-  isClaudeLocalCommandArtifact,
-  isWorthStoringPrompt,
-  SessionHistoryImporter,
-  type ImportResult
-} from '../../src/services/session-history-importer.js';
-
-const tempDirs: string[] = [];
-
-function tempDir() {
-  const dir = mkdtempSync(join(tmpdir(), 'cml-session-importer-'));
-  tempDirs.push(dir);
-  return dir;
-}
-
-function makeImportResult(overrides: Partial<ImportResult> = {}): ImportResult {
-  return {
-    totalSessions: 1,
-    totalMessages: 1,
-    importedPrompts: 1,
-    importedResponses: 0,
-    skippedDuplicates: 0,
-    errors: [],
-    ...overrides
-  };
-}
-
-afterEach(() => {
-  for (const dir of tempDirs.splice(0)) {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-describe('session history importer prompt filtering', () => {
-  it('drops Claude local-command artifacts that dilute retrieval quality', () => {
-    const artifact = `<command-name>/model</command-name>\n<local-command-stdout>Using model opus</local-command-stdout>`;
-
-    expect(isClaudeLocalCommandArtifact(artifact)).toBe(true);
-    expect(isWorthStoringPrompt(artifact)).toBe(false);
-  });
-
-  it('keeps substantive imported user prompts', () => {
-    expect(isWorthStoringPrompt('이 프로젝트에서 memory retrieval 구조를 더 가볍게 개선해줘')).toBe(true);
-  });
-
-  it('imports only the most recently modified matching Claude session when sessionLimit is set', async () => {
-    const dir = tempDir();
-    const older = join(dir, 'older.jsonl');
-    const newest = join(dir, 'newest.jsonl');
-    const oldest = join(dir, 'oldest.jsonl');
-    for (const filePath of [older, newest, oldest]) {
-      writeFileSync(filePath, '{}\n', 'utf8');
-    }
-    utimesSync(oldest, new Date('2026-05-01T00:00:00.000Z'), new Date('2026-05-01T00:00:00.000Z'));
-    utimesSync(older, new Date('2026-05-02T00:00:00.000Z'), new Date('2026-05-02T00:00:00.000Z'));
-    utimesSync(newest, new Date('2026-05-03T00:00:00.000Z'), new Date('2026-05-03T00:00:00.000Z'));
-
-    const importer = new SessionHistoryImporter({} as never) as SessionHistoryImporter & {
-      findProjectDirs: ReturnType<typeof vi.fn>;
-      findSessionFiles: ReturnType<typeof vi.fn>;
-      importSessionFile: ReturnType<typeof vi.fn>;
-    };
-    importer.findProjectDirs = vi.fn(async () => [dir]);
-    importer.findSessionFiles = vi.fn(async () => [older, newest, oldest]);
-    importer.importSessionFile = vi.fn(async () => makeImportResult());
-
-    const result = await importer.importProject('/repo/current', { sessionLimit: 1 });
-
-    expect(result.totalSessions).toBe(1);
-    expect(importer.importSessionFile).toHaveBeenCalledTimes(1);
-    expect(importer.importSessionFile).toHaveBeenCalledWith(newest, expect.objectContaining({ sessionLimit: 1 }));
-  });
-});

package/tests/core/session-qrels.test.ts

@@ -1,250 +0,0 @@
-import { mkdir, writeFile } from 'node:fs/promises';
-import * as path from 'node:path';
-import { tmpdir } from 'node:os';
-
-import { describe, expect, it } from 'vitest';
-
-import {
-  buildSessionQrelsFixtureFromJsonl,
-  collectClaudeSessionJsonlFiles,
-  summarizeSessionQrelsFixture
-} from '../../src/core/session-qrels.js';
-
-describe('session qrels fixture generation', () => {
-  it('turns Claude-style user/assistant session turns into replay qrels', () => {
-    const jsonl = [
-      JSON.stringify({
-        type: 'user',
-        sessionId: 's1',
-        message: { role: 'user', content: 'retrieval benchmark should report nDCG and precision together' },
-        timestamp: '2026-05-05T00:00:00.000Z'
-      }),
-      JSON.stringify({
-        type: 'assistant',
-        sessionId: 's1',
-        message: { role: 'assistant', content: [{ type: 'text', text: 'Use graded relevance qrels and report nDCG@k beside Precision@k and Recall@k.' }] },
-        timestamp: '2026-05-05T00:01:00.000Z'
-      }),
-      JSON.stringify({
-        type: 'user',
-        sessionId: 's1',
-        message: { role: 'user', content: '<command-name>/model</command-name>\n<local-command-stdout>opus</local-command-stdout>' }
-      }),
-      JSON.stringify({
-        type: 'assistant',
-        sessionId: 's1',
-        message: { role: 'assistant', content: 'This local command result must not become a benchmark qrel.' }
-      }),
-      JSON.stringify({
-        type: 'user',
-        sessionId: 's1',
-        message: { role: 'user', content: [{ type: 'text', text: 'fast search CLI should avoid embedding startup for qrels smoke tests' }] }
-      }),
-      JSON.stringify({
-        type: 'assistant',
-        sessionId: 's1',
-        message: { role: 'assistant', content: 'Fast search benchmark fixtures should stay lightweight and deterministic.' }
-      })
-    ].join('\n');
-
-    const fixture = buildSessionQrelsFixtureFromJsonl(jsonl, {
-      name: 'session-qrels-test',
-      ks: [1, 3]
-    });
-
-    expect(fixture.name).toBe('session-qrels-test');
-    expect(fixture.ks).toEqual([1, 3]);
-    expect(fixture.queries).toHaveLength(2);
-    expect(fixture.memories).toHaveLength(2);
-    expect(fixture.queries[0]).toMatchObject({
-      queryId: 'q-s1-1',
-      query: 'retrieval benchmark should report nDCG and precision together',
-      expectedIds: ['m-s1-1'],
-      expectedRelevance: { 'm-s1-1': 2 }
-    });
-    expect(fixture.memories[0]).toMatchObject({
-      id: 'm-s1-1',
-      content: 'Use graded relevance qrels and report nDCG@k beside Precision@k and Recall@k.',
-      sourceSessionId: 's1'
-    });
-    expect(fixture.queries.map((query) => query.query)).not.toContain('opus');
-  });
-
-  it('pairs pending prompts independently per session id', () => {
-    const jsonl = [
-      JSON.stringify({
-        type: 'user',
-        sessionId: 's1',
-        message: { role: 'user', content: 'session one asks about retrieval replay metrics' }
-      }),
-      JSON.stringify({
-        type: 'user',
-        sessionId: 's2',
-        message: { role: 'user', content: 'session two asks about qrels generation safety' }
-      }),
-      JSON.stringify({
-        type: 'assistant',
-        sessionId: 's1',
-        message: { role: 'assistant', content: 'Session one answer explains nDCG replay metrics.' }
-      }),
-      JSON.stringify({
-        type: 'assistant',
-        sessionId: 's2',
-        message: { role: 'assistant', content: 'Session two answer explains qrels generation safety.' }
-      })
-    ].join('\n');
-
-    const fixture = buildSessionQrelsFixtureFromJsonl(jsonl);
-
-    expect(fixture.queries.map((query) => [query.queryId, query.query])).toEqual([
-      ['q-s1-1', 'session one asks about retrieval replay metrics'],
-      ['q-s2-1', 'session two asks about qrels generation safety']
-    ]);
-    expect(fixture.memories.map((memory) => [memory.id, memory.content])).toEqual([
-      ['m-s1-1', 'Session one answer explains nDCG replay metrics.'],
-      ['m-s2-1', 'Session two answer explains qrels generation safety.']
-    ]);
-  });
-
-  it('adds known-answer labels and explicit no-match qrels', () => {
-    const jsonl = [
-      JSON.stringify({
-        type: 'user',
-        sessionId: 's-known',
-        message: { role: 'user', content: 'how should replay qrels record known answer fixtures' }
-      }),
-      JSON.stringify({
-        type: 'assistant',
-        sessionId: 's-known',
-        message: { role: 'assistant', content: 'Known-answer qrels should keep the expected assistant answer tied to the expected memory id.' }
-      })
-    ].join('\n');
-
-    const fixture = buildSessionQrelsFixtureFromJsonl(jsonl, {
-      noMatchQueries: [
-        {
-          queryId: 'q-negative-empty-result',
-          query: 'unanswered moon cheese deployment question',
-          forbiddenIds: ['m-s-known-1'],
-          sourceSessionId: 's-known'
-        }
-      ]
-    });
-
-    expect(fixture.queries).toHaveLength(2);
-    expect(fixture.queries[0]).toMatchObject({
-      queryId: 'q-s-known-1',
-      expectation: 'match',
-      expectedIds: ['m-s-known-1'],
-      knownAnswer: 'Known-answer qrels should keep the expected assistant answer tied to the expected memory id.'
-    });
-    expect(fixture.queries[1]).toMatchObject({
-      queryId: 'q-negative-empty-result',
-      query: 'unanswered moon cheese deployment question',
-      expectation: 'no_match',
-      expectedIds: [],
-      expectedRelevance: {},
-      forbiddenIds: ['m-s-known-1'],
-      sourceSessionId: 's-known'
-    });
-
-    const summary = summarizeSessionQrelsFixture(fixture);
-    expect(summary).toMatchObject({
-      queryCount: 2,
-      positiveQueryCount: 1,
-      noMatchQueryCount: 1,
-      knownAnswerCount: 1
-    });
-  });
-
-  it('can redact raw session text when generating shareable qrels metadata', () => {
-    const jsonl = [
-      JSON.stringify({
-        type: 'user',
-        sessionId: 'sensitive',
-        message: { role: 'user', content: 'SECRET customer project prompt should not leak' }
-      }),
-      JSON.stringify({
-        type: 'assistant',
-        sessionId: 'sensitive',
-        message: { role: 'assistant', content: 'SECRET implementation answer should not leak' }
-      })
-    ].join('\n');
-
-    const fixture = buildSessionQrelsFixtureFromJsonl(jsonl, { redactContent: true });
-    const serialized = JSON.stringify(fixture);
-
-    expect(serialized).not.toContain('SECRET');
-    expect(fixture.queries[0]).toMatchObject({
-      queryId: 'q-sensitive-1',
-      query: '[redacted query q-sensitive-1]',
-      expectedIds: ['m-sensitive-1']
-    });
-    expect(fixture.memories[0]).toMatchObject({
-      id: 'm-sensitive-1',
-      content: '[redacted memory m-sensitive-1]'
-    });
-  });
-
-  it('summarizes generated qrels without leaking raw prompt or memory content', () => {
-    const jsonl = [
-      JSON.stringify({
-        type: 'user',
-        sessionId: 'sensitive',
-        message: { role: 'user', content: 'SECRET customer retrieval question with enough words' }
-      }),
-      JSON.stringify({
-        type: 'assistant',
-        sessionId: 'sensitive',
-        message: { role: 'assistant', content: 'SECRET assistant answer that should stay out of reports' }
-      })
-    ].join('\n');
-    const fixture = buildSessionQrelsFixtureFromJsonl(jsonl, {
-      name: 'private-real-session-qrels',
-      ks: [1, 3, 10],
-      sourceFileCount: 2,
-      rawContentIncluded: true
-    });
-
-    const summary = summarizeSessionQrelsFixture(fixture);
-    const serialized = JSON.stringify(summary);
-
-    expect(summary).toMatchObject({
-      name: 'private-real-session-qrels',
-      queryCount: 1,
-      memoryCount: 1,
-      sourceSessionCount: 1,
-      sourceFileCount: 2,
-      rawContentIncluded: true,
-      ks: [1, 3, 10]
-    });
-    expect(summary.perSession).toEqual([
-      {
-        sourceSessionId: 'sensitive',
-        queryCount: 1,
-        memoryCount: 1,
-        firstTurnIndex: 1,
-        lastTurnIndex: 1
-      }
-    ]);
-    expect(serialized).not.toContain('SECRET');
-  });
-
-  it('collects Claude JSONL sessions recursively while excluding subagents by default', async () => {
-    const root = path.join(tmpdir(), `session-qrels-${process.pid}-${Date.now()}`);
-    const projectDir = path.join(root, 'project-a');
-    const subagentDir = path.join(projectDir, 'subagents');
-    await mkdir(subagentDir, { recursive: true });
-    await writeFile(path.join(projectDir, 'top.jsonl'), '{}\n', 'utf8');
-    await writeFile(path.join(subagentDir, 'agent.jsonl'), '{}\n', 'utf8');
-    await writeFile(path.join(projectDir, 'notes.txt'), 'ignore', 'utf8');
-
-    await expect(collectClaudeSessionJsonlFiles(root)).resolves.toEqual([
-      path.join(projectDir, 'top.jsonl')
-    ]);
-    await expect(collectClaudeSessionJsonlFiles(root, { includeSubagents: true })).resolves.toEqual([
-      path.join(subagentDir, 'agent.jsonl'),
-      path.join(projectDir, 'top.jsonl')
-    ]);
-  });
-});

package/tests/core/sqlite-event-store-replication.test.ts

@@ -1,127 +0,0 @@
-/**
- * Tests for SQLiteEventStore replication helpers used by Mongo sync.
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-
-import { SQLiteEventStore } from '../../src/core/sqlite-event-store.js';
-
-describe('SQLiteEventStore replication helpers', () => {
-  let tempDir: string;
-  let storeA: SQLiteEventStore;
-  let storeB: SQLiteEventStore;
-
-  beforeEach(async () => {
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-memory-layer-test-'));
-    storeA = new SQLiteEventStore(path.join(tempDir, 'a.sqlite'));
-    storeB = new SQLiteEventStore(path.join(tempDir, 'b.sqlite'));
-    await storeA.initialize();
-    await storeB.initialize();
-  });
-
-  afterEach(() => {
-    try { storeA.close(); } catch {}
-    try { storeB.close(); } catch {}
-    fs.rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  it('getEventsSinceRowid returns incremental batches in insertion order', async () => {
-    const sessionId = 'session-1';
-
-    await storeA.append({ eventType: 'user_prompt', sessionId, timestamp: new Date(), content: 'a' });
-    await storeA.append({ eventType: 'user_prompt', sessionId, timestamp: new Date(), content: 'b' });
-    await storeA.append({ eventType: 'user_prompt', sessionId, timestamp: new Date(), content: 'c' });
-
-    const batch1 = await storeA.getEventsSinceRowid(0, 10);
-    expect(batch1).toHaveLength(3);
-    expect(batch1.map(x => x.event.content)).toEqual(['a', 'b', 'c']);
-
-    // rowid should be strictly increasing
-    expect(batch1[0].rowid).toBeLessThan(batch1[1].rowid);
-    expect(batch1[1].rowid).toBeLessThan(batch1[2].rowid);
-
-    const lastRowid = batch1[2].rowid;
-
-    await storeA.append({ eventType: 'user_prompt', sessionId, timestamp: new Date(), content: 'd' });
-
-    const batch2 = await storeA.getEventsSinceRowid(lastRowid, 10);
-    expect(batch2).toHaveLength(1);
-    expect(batch2[0].event.content).toBe('d');
-  });
-
-  it('importEvents preserves stable IDs and is idempotent via dedupeKey', async () => {
-    const sessionId = 'session-2';
-    const appendRes = await storeA.append({
-      eventType: 'user_prompt',
-      sessionId,
-      timestamp: new Date(),
-      content: 'hello world'
-    });
-
-    expect(appendRes.success).toBe(true);
-    const sourceEvent = await storeA.getEvent(appendRes.eventId!);
-    expect(sourceEvent).not.toBeNull();
-
-    const imported1 = await storeB.importEvents([sourceEvent!]);
-    expect(imported1.inserted).toBe(1);
-    expect(imported1.skipped).toBe(0);
-
-    const importedEvent = await storeB.getEvent(sourceEvent!.id);
-    expect(importedEvent?.content).toBe('hello world');
-
-    // Importing again should be a no-op
-    const imported2 = await storeB.importEvents([sourceEvent!]);
-    expect(imported2.inserted).toBe(0);
-    expect(imported2.skipped).toBe(1);
-
-    // append() should treat it as duplicate due to event_dedup entry
-    const dup = await storeB.append({
-      eventType: 'user_prompt',
-      sessionId,
-      timestamp: new Date(),
-      content: 'hello world'
-    });
-    expect(dup.success).toBe(true);
-    expect(dup.isDuplicate).toBe(true);
-    expect(dup.eventId).toBe(sourceEvent!.id);
-  });
-
-  it('keeps FTS event_id populated after deleteSessionEvents recreates triggers', async () => {
-    await storeA.append({ eventType: 'user_prompt', sessionId: 'delete-me', timestamp: new Date(), content: 'temporary kiwi memory' });
-    await storeA.append({ eventType: 'user_prompt', sessionId: 'keep-me', timestamp: new Date(), content: 'persistent pineapple memory' });
-
-    await expect(storeA.deleteSessionEvents('delete-me')).resolves.toBe(1);
-
-    const appendAfterTriggerRecreation = await storeA.append({
-      eventType: 'user_prompt',
-      sessionId: 'keep-me',
-      timestamp: new Date(),
-      content: 'fresh dragonfruit memory'
-    });
-    expect(appendAfterTriggerRecreation.success).toBe(true);
-
-    await expect(storeA.rebuildFtsIndex()).resolves.toBe(2);
-    const results = await storeA.keywordSearch('dragonfruit', 5);
-
-    expect(results.map((result) => result.event.content)).toEqual(['fresh dragonfruit memory']);
-  });
-
-  it('supports event updates and deletes on a fresh FTS table before manual rebuild', async () => {
-    const appendResult = await storeA.append({
-      eventType: 'user_prompt',
-      sessionId: 'mutable-session',
-      timestamp: new Date(),
-      content: 'mutable mango memory'
-    });
-    expect(appendResult.success).toBe(true);
-    if (!appendResult.success) return;
-
-    await expect(storeA.incrementAccessCount([appendResult.eventId])).resolves.toBeUndefined();
-    await expect(storeA.deleteSessionEvents('mutable-session')).resolves.toBe(1);
-    await expect(storeA.keywordSearch('mango', 5)).resolves.toEqual([]);
-  });
-});
-

package/tests/core/summary-deriver.test.ts

@@ -1,66 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { SummaryDeriver } from '../../src/core/derive/summary-deriver.js';
-import type { MemoryEvent } from '../../src/core/types.js';
-
-function event(overrides: Partial<MemoryEvent>): MemoryEvent {
-  return {
-    id: '11111111-1111-4111-8111-111111111111',
-    eventType: 'user_prompt',
-    sessionId: 'session-1',
-    timestamp: new Date('2026-04-30T00:00:00.000Z'),
-    content: 'default content',
-    canonicalKey: 'default-content',
-    dedupeKey: 'session-1:default-content',
-    metadata: {},
-    ...overrides
-  };
-}
-
-describe('SummaryDeriver', () => {
-  it('derives the legacy rule-based session summary from events', () => {
-    const deriver = new SummaryDeriver();
-
-    const result = deriver.deriveSessionSummary([
-      event({ id: '11111111-1111-4111-8111-111111111111', eventType: 'user_prompt', content: '첫 번째 작업 요청\n자세한 설명', timestamp: new Date('2026-04-30T01:00:00.000Z') }),
-      event({ id: '22222222-2222-4222-8222-222222222222', eventType: 'agent_response', content: '응답', timestamp: new Date('2026-04-30T01:01:00.000Z') }),
-      event({ id: '33333333-3333-4333-8333-333333333333', eventType: 'tool_observation', content: '{}', timestamp: new Date('2026-04-30T01:02:00.000Z'), metadata: { toolName: 'terminal', exitCode: 1 } }),
-      event({ id: '44444444-4444-4444-8444-444444444444', eventType: 'tool_observation', content: '{}', timestamp: new Date('2026-04-30T01:03:00.000Z'), metadata: { toolName: 'terminal', exitCode: 0 } }),
-      event({ id: '55555555-5555-4555-8555-555555555555', eventType: 'tool_observation', content: '{}', timestamp: new Date('2026-04-30T01:04:00.000Z'), metadata: { toolName: 'read_file', success: false } }),
-      event({ id: '66666666-6666-4666-8666-666666666666', eventType: 'user_prompt', content: '두 번째 요청', timestamp: new Date('2026-04-30T01:05:00.000Z') })
-    ]);
-
-    expect(result).toEqual({
-      text: '[2026-04-30] 2턴 세션. 주요 작업: 첫 번째 작업 요청 자세한 설명. 사용 툴: terminal, read_file. 오류 2건 발생',
-      metadata: { generated: 'rule-based', eventCount: 6 }
-    });
-  });
-
-  it('returns null for too-short sessions and sessions that already have summaries', () => {
-    const deriver = new SummaryDeriver();
-
-    expect(deriver.deriveSessionSummary([
-      event({ id: '11111111-1111-4111-8111-111111111111' }),
-      event({ id: '22222222-2222-4222-8222-222222222222', eventType: 'agent_response' })
-    ])).toBeNull();
-
-    expect(deriver.deriveSessionSummary([
-      event({ id: '33333333-3333-4333-8333-333333333333' }),
-      event({ id: '44444444-4444-4444-8444-444444444444', eventType: 'agent_response' }),
-      event({ id: '55555555-5555-4555-8555-555555555555', eventType: 'session_summary', content: 'already summarized' })
-    ])).toBeNull();
-  });
-
-  it('limits the first prompt preview to keep summaries compact', () => {
-    const deriver = new SummaryDeriver();
-    const longPrompt = `${'a'.repeat(140)}\nextra`;
-
-    const result = deriver.deriveSessionSummary([
-      event({ id: '11111111-1111-4111-8111-111111111111', content: longPrompt }),
-      event({ id: '22222222-2222-4222-8222-222222222222', eventType: 'agent_response', content: '응답' }),
-      event({ id: '33333333-3333-4333-8333-333333333333', eventType: 'tool_observation', content: '{}', metadata: { toolName: 'terminal' } })
-    ]);
-
-    expect(result?.text).toBe(`[2026-04-30] 1턴 세션. 주요 작업: ${'a'.repeat(120)}. 사용 툴: terminal`);
-  });
-});

package/tests/extensions/embedder-warning-suppression.test.ts

@@ -1,84 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-
-import {
-  DEFAULT_EMBEDDING_MODEL,
-  Embedder,
-  createEmbeddingBackendUnavailableError,
-  isKnownBenignTransformersWarning,
-  isMissingTransformersDependencyError,
-  withSuppressedKnownTransformersWarnings
-} from '../../src/extensions/vector/embedder.js';
-import { ConfigSchema } from '../../src/core/types.js';
-
-describe('Embedder warning suppression', () => {
-  it('uses a CPU-friendly multilingual Korean-capable default embedding model', () => {
-    expect(DEFAULT_EMBEDDING_MODEL).toBe('Xenova/multilingual-e5-small');
-    expect(new Embedder().getModelName()).toBe(DEFAULT_EMBEDDING_MODEL);
-
-    const parsedConfig = ConfigSchema.parse({});
-    expect(parsedConfig.embedding.model).toBe(DEFAULT_EMBEDDING_MODEL);
-    expect(parsedConfig.embedding.openaiModel).toBe(DEFAULT_EMBEDDING_MODEL);
-  });
-
-  it('turns missing required @huggingface/transformers errors into actionable install guidance', () => {
-    const missingBackendError = Object.assign(
-      new Error("Cannot find package '@huggingface/transformers' imported from /tmp/dist/cli/index.js"),
-      { code: 'ERR_MODULE_NOT_FOUND' }
-    );
-
-    expect(isMissingTransformersDependencyError(missingBackendError)).toBe(true);
-    expect(isMissingTransformersDependencyError(new Error('network failure'))).toBe(false);
-
-    const friendly = createEmbeddingBackendUnavailableError(missingBackendError);
-    expect(friendly.message).toContain('Required embedding backend is not installed');
-    expect(friendly.message).toContain('Claude Memory Layer requires @huggingface/transformers');
-    expect(friendly.message).toContain('ONNXRUNTIME_NODE_INSTALL_CUDA=skip npm install -g claude-memory-layer@latest');
-    expect(friendly.message).toContain('ONNXRUNTIME_NODE_INSTALL_CUDA=skip npm install --no-save --no-package-lock --omit=dev @huggingface/transformers@3.8.1');
-    expect(friendly.cause).toBe(missingBackendError);
-  });
-
-  it('recognizes known benign transformer warnings', () => {
-    expect(isKnownBenignTransformersWarning('Unknown model class "eurobert", attempting to construct from base class.')).toBe(true);
-    expect(isKnownBenignTransformersWarning('dtype not specified for "model". Using the default dtype (fp32).')).toBe(true);
-    expect(isKnownBenignTransformersWarning('serious model load failure')).toBe(false);
-  });
-
-  it('suppresses known transformer warnings but keeps unrelated warnings', async () => {
-    const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
-
-    await withSuppressedKnownTransformersWarnings(async () => {
-      console.warn('Unknown model class "eurobert", attempting to construct from base class.');
-      console.warn('dtype not specified for "model". Using the default dtype (fp32).');
-      console.warn('serious model load failure');
-    });
-
-    expect(warn).toHaveBeenCalledTimes(1);
-    expect(warn).toHaveBeenCalledWith('serious model load failure');
-    warn.mockRestore();
-  });
-
-  it('restores console.warn only after overlapping suppressions complete', async () => {
-    const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
-    const originalWarn = console.warn;
-    let releaseFirst!: () => void;
-    let releaseSecond!: () => void;
-
-    const first = withSuppressedKnownTransformersWarnings(async () => {
-      await new Promise<void>((resolve) => { releaseFirst = resolve; });
-    });
-    const suppressedWarn = console.warn;
-    const second = withSuppressedKnownTransformersWarnings(async () => {
-      await new Promise<void>((resolve) => { releaseSecond = resolve; });
-    });
-
-    expect(console.warn).toBe(suppressedWarn);
-    releaseFirst();
-    await first;
-    expect(console.warn).toBe(suppressedWarn);
-
-    releaseSecond();
-    await second;
-    expect(console.warn).toBe(originalWarn);
-    warn.mockRestore();
-  });
-});

package/tests/extensions/endless-memory-extension-boundary.test.ts

@@ -1,17 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { describe, expect, it } from 'vitest';
-
-import { createEndlessMemoryServices as createFromExtension } from '../../src/extensions/endless-memory/index.js';
-import { createEndlessMemoryServices as createFromCompat } from '../../src/core/engine/endless-memory-services.js';
-
-describe('endless-memory extension boundary', () => {
-  it('keeps endless memory implementation under extensions with an engine compatibility re-export', () => {
-    const compatSource = readFileSync('src/core/engine/endless-memory-services.ts', 'utf8');
-    const memoryServiceSource = readFileSync('src/services/memory-service.ts', 'utf8');
-
-    expect(createFromCompat).toBe(createFromExtension);
-    expect(compatSource).toContain("../../extensions/endless-memory/index.js");
-    expect(memoryServiceSource).not.toContain("../core/engine/endless-memory-services.js");
-    expect(memoryServiceSource).toContain("../extensions/endless-memory/index.js");
-  });
-});