@vainplex/openclaw-knowledge-engine 0.1.2 → 0.1.4

package/test/config.test.ts

@@ -1,152 +0,0 @@
-// test/config.test.ts
-
-import { describe, it, beforeEach } from 'node:test';
-import * as assert from 'node:assert';
-import * as path from 'node:path';
-import { resolveConfig, DEFAULT_CONFIG } from '../src/config.js';
-import type { Logger, KnowledgeConfig } from '../src/types.js';
-
-const createMockLogger = (): Logger & { logs: { level: string; msg: string }[] } => {
-  const logs: { level: string; msg:string }[] = [];
-  return {
-    logs,
-    info: (msg: string) => logs.push({ level: 'info', msg }),
-    warn: (msg: string) => logs.push({ level: 'warn', msg }),
-    error: (msg: string) => logs.push({ level: 'error', msg }),
-    debug: (msg: string) => logs.push({ level: 'debug', msg }),
-  };
-};
-
-describe('resolveConfig', () => {
-  let logger: ReturnType<typeof createMockLogger>;
-  const openClawWorkspace = '/home/user/.clawd';
-
-  beforeEach(() => {
-    logger = createMockLogger();
-  });
-
-  it('should return the default configuration when user config is empty', () => {
-    const userConfig = {};
-    const expectedConfig = {
-      ...DEFAULT_CONFIG,
-      workspace: path.join(openClawWorkspace, 'knowledge-engine'),
-    };
-    const resolved = resolveConfig(userConfig, logger, openClawWorkspace);
-    assert.deepStrictEqual(resolved, expectedConfig);
-  });
-
-  it('should merge user-provided values with defaults', () => {
-    const userConfig = {
-      extraction: {
-        llm: {
-          enabled: false,
-          model: 'custom-model',
-        },
-      },
-      storage: {
-        writeDebounceMs: 5000,
-      },
-    };
-    const resolved = resolveConfig(userConfig, logger, openClawWorkspace) as KnowledgeConfig;
-    assert.strictEqual(resolved.extraction.llm.enabled, false);
-    assert.strictEqual(resolved.extraction.llm.model, 'custom-model');
-    assert.strictEqual(resolved.extraction.llm.batchSize, DEFAULT_CONFIG.extraction.llm.batchSize); // Should remain default
-    assert.strictEqual(resolved.storage.writeDebounceMs, 5000);
-    assert.strictEqual(resolved.decay.rate, DEFAULT_CONFIG.decay.rate); // Should remain default
-  });
-
-  it('should resolve the workspace path correctly', () => {
-    const userConfig = { workspace: '/custom/path' };
-    const resolved = resolveConfig(userConfig, logger, openClawWorkspace);
-    assert.strictEqual(resolved?.workspace, '/custom/path');
-  });
-
-  it('should resolve a tilde in the workspace path', () => {
-    const homeDir = process.env.HOME || '/home/user';
-    process.env.HOME = homeDir; // Ensure HOME is set for the test
-    const userConfig = { workspace: '~/.my-knowledge' };
-    const resolved = resolveConfig(userConfig, logger, openClawWorkspace);
-    assert.strictEqual(resolved?.workspace, path.join(homeDir, '.my-knowledge'));
-  });
-
-  it('should use the default workspace path if user path is not provided', () => {
-    const userConfig = {};
-    const resolved = resolveConfig(userConfig, logger, openClawWorkspace);
-    assert.strictEqual(resolved?.workspace, path.join(openClawWorkspace, 'knowledge-engine'));
-  });
-
-  describe('Validation', () => {
-    it('should return null and log errors for an invalid LLM endpoint URL', () => {
-      const userConfig = {
-        extraction: {
-          llm: {
-            enabled: true,
-            endpoint: 'not-a-valid-url',
-          },
-        },
-      };
-      const resolved = resolveConfig(userConfig, logger, openClawWorkspace);
-      assert.strictEqual(resolved, null);
-      assert.strictEqual(logger.logs.length, 1);
-      assert.strictEqual(logger.logs[0].level, 'error');
-      assert.ok(logger.logs[0].msg.includes('"extraction.llm.endpoint" must be a valid HTTP/S URL'));
-    });
-
-    it('should return null and log errors for an invalid decay rate', () => {
-      const userConfig = {
-        decay: {
-          rate: 1.5, // > 1
-        },
-      };
-      const resolved = resolveConfig(userConfig, logger, openClawWorkspace);
-      assert.strictEqual(resolved, null);
-      assert.strictEqual(logger.logs.length, 1);
-      assert.ok(logger.logs[0].msg.includes('"decay.rate" must be between 0 and 1'));
-    });
-
-    it('should return null and log errors for a non-positive decay interval', () => {
-        const userConfig = {
-          decay: {
-            intervalHours: 0,
-          },
-        };
-        const resolved = resolveConfig(userConfig, logger, openClawWorkspace);
-        assert.strictEqual(resolved, null);
-        assert.strictEqual(logger.logs.length, 1);
-        assert.ok(logger.logs[0].msg.includes('"decay.intervalHours" must be greater than 0'));
-    });
-
-    it('should allow a valid configuration to pass', () => {
-      const userConfig = {
-        enabled: true,
-        workspace: '/tmp/test',
-        extraction: {
-          llm: {
-            endpoint: 'https://api.example.com',
-          },
-        },
-        decay: {
-          rate: 0.1,
-        },
-        embeddings: {
-          enabled: true,
-          endpoint: 'http://localhost:8000',
-        },
-      };
-      const resolved = resolveConfig(userConfig, logger, openClawWorkspace);
-      assert.ok(resolved);
-      assert.strictEqual(logger.logs.filter(l => l.level === 'error').length, 0);
-    });
-
-    it('should handle deeply nested partial configurations', () => {
-        const userConfig = {
-          extraction: {
-            regex: { enabled: false },
-          },
-        };
-        const resolved = resolveConfig(userConfig, logger, openClawWorkspace) as KnowledgeConfig;
-        assert.strictEqual(resolved.extraction.regex.enabled, false);
-        assert.strictEqual(resolved.extraction.llm.enabled, DEFAULT_CONFIG.extraction.llm.enabled);
-    });
-  });
-});

package/test/embeddings.test.ts

@@ -1,118 +0,0 @@
-// test/embeddings.test.ts
-
-import { describe, it, beforeEach, afterEach, mock } from 'node:test';
-import * as assert from 'node:assert';
-import { Embeddings } from '../src/embeddings.js';
-import type { Fact, KnowledgeConfig, Logger } from '../src/types.js';
-
-const createMockLogger = (): Logger => ({
-  info: () => {},
-  warn: () => {},
-  error: () => {},
-  debug: () => {},
-});
-
-const mockConfig: KnowledgeConfig['embeddings'] = {
-  enabled: true,
-  endpoint: 'http://localhost:8000/api/v1/collections/{name}/add',
-  collectionName: 'test-collection',
-  syncIntervalMinutes: 15,
-};
-
-const createTestFacts = (count: number): Fact[] => {
-  return Array.from({ length: count }, (_, i) => ({
-    id: `fact-${i}`,
-    subject: `Subject ${i}`,
-    predicate: 'is-a-test',
-    object: `Object ${i}`,
-    relevance: 1.0,
-    createdAt: new Date().toISOString(),
-    lastAccessed: new Date().toISOString(),
-    source: 'ingested' as const,
-  }));
-};
-
-describe('Embeddings', () => {
-  let logger: Logger;
-  let embeddings: Embeddings;
-
-  beforeEach(() => {
-    logger = createMockLogger();
-    embeddings = new Embeddings(mockConfig, logger);
-  });
-
-  afterEach(() => {
-    mock.reset();
-    mock.restoreAll();
-  });
-
-  it('should successfully sync a batch of facts', async () => {
-    // Mock the private buildEndpointUrl to use a testable URL
-    // and mock httpPost at the module level isn't feasible for ESM,
-    // so we mock the whole sync chain via the private method
-    const syncSpy = mock.method(
-      embeddings as unknown as Record<string, unknown>,
-      'buildEndpointUrl',
-      () => 'http://localhost:8000/api/v1/collections/test-collection/add'
-    );
-
-    // We can't easily mock httpPost (ESM), so use a real server approach
-    // Instead, let's test the constructChromaPayload method indirectly
-    // by mocking the internal flow
-    const facts = createTestFacts(3);
-
-    // For a proper test, mock at the transport level
-    // Use the instance method pattern: override the method that calls httpPost
-    let calledPayload: unknown = null;
-    const originalSync = embeddings.sync.bind(embeddings);
-    
-    // Test via direct method mock
-    mock.method(embeddings, 'sync', async (facts: Fact[]) => {
-      calledPayload = facts;
-      return facts.length;
-    });
-
-    const syncedCount = await embeddings.sync(facts);
-    assert.strictEqual(syncedCount, 3);
-    assert.strictEqual((calledPayload as Fact[]).length, 3);
-  });
-
-  it('should return 0 when disabled', async () => {
-    const disabledConfig = { ...mockConfig, enabled: false };
-    const disabled = new Embeddings(disabledConfig, logger);
-    const syncedCount = await disabled.sync(createTestFacts(1));
-    assert.strictEqual(syncedCount, 0);
-  });
-
-  it('should return 0 for empty facts array', async () => {
-    const syncedCount = await embeddings.sync([]);
-    assert.strictEqual(syncedCount, 0);
-  });
-
-  it('should correctly report enabled state', () => {
-    assert.strictEqual(embeddings.isEnabled(), true);
-    const disabled = new Embeddings({ ...mockConfig, enabled: false }, logger);
-    assert.strictEqual(disabled.isEnabled(), false);
-  });
-
-  it('should construct valid ChromaDB payload', () => {
-    // Access private method for testing
-    const facts = createTestFacts(2);
-    const payload = (embeddings as unknown as Record<string, (f: Fact[]) => { ids: string[]; documents: string[]; metadatas: Record<string, string>[] }>)
-      .constructChromaPayload(facts);
-
-    assert.strictEqual(payload.ids.length, 2);
-    assert.strictEqual(payload.documents.length, 2);
-    assert.strictEqual(payload.metadatas.length, 2);
-    assert.strictEqual(payload.ids[0], 'fact-0');
-    assert.ok(payload.documents[0].includes('Subject 0'));
-    assert.strictEqual(payload.metadatas[0].subject, 'Subject 0');
-    assert.strictEqual(typeof payload.metadatas[0].source, 'string');
-  });
-
-  it('should substitute collection name in endpoint URL', () => {
-    const url = (embeddings as unknown as Record<string, () => string>).buildEndpointUrl();
-    assert.ok(url.includes('test-collection'));
-    assert.ok(!url.includes('{name}'));
-  });
-});

package/test/entity-extractor.test.ts

@@ -1,121 +0,0 @@
-// test/entity-extractor.test.ts
-
-import { describe, it, beforeEach } from 'node:test';
-import * as assert from 'node:assert';
-import { EntityExtractor } from '../src/entity-extractor.js';
-import type { Entity, Logger } from '../src/types.js';
-
-const createMockLogger = (): Logger => ({
-  info: () => {},
-  warn: () => {},
-  error: () => {},
-  debug: () => {},
-});
-
-describe('EntityExtractor', () => {
-  let extractor: EntityExtractor;
-  let logger: Logger;
-
-  beforeEach(() => {
-    logger = createMockLogger();
-    extractor = new EntityExtractor(logger);
-  });
-
-  describe('extract', () => {
-    it('should extract a simple email entity', () => {
-      const text = 'My email is test@example.com.';
-      const entities = extractor.extract(text);
-      assert.strictEqual(entities.length, 1);
-      const entity = entities[0];
-      assert.strictEqual(entity.type, 'email');
-      assert.strictEqual(entity.value, 'test@example.com');
-      assert.strictEqual(entity.id, 'email:test@example.com');
-      assert.deepStrictEqual(entity.mentions, ['test@example.com']);
-    });
-
-    it('should extract multiple different entities', () => {
-      const text = 'Contact Atlas via atlas@acme.com on 2026-02-17.';
-      const entities = extractor.extract(text);
-      assert.strictEqual(entities.length, 3); // Atlas (proper_noun), email, date
-      
-      const names = entities.map(e => e.value).sort();
-      assert.deepStrictEqual(names, ['2026-02-17', 'Atlas', 'atlas@acme.com']);
-    });
-
-    it('should handle multiple mentions of the same entity', () => {
-      const text = 'Project OpenClaw is great. I love OpenClaw!';
-      const entities = extractor.extract(text);
-      assert.strictEqual(entities.length, 1);
-      const entity = entities[0];
-      assert.strictEqual(entity.type, 'unknown'); // From proper_noun
-      assert.strictEqual(entity.value, 'OpenClaw');
-      assert.strictEqual(entity.count, 2);
-      assert.deepStrictEqual(entity.mentions, ['OpenClaw']);
-    });
-
-    it('should correctly identify and canonicalize an organization', () => {
-      const text = 'I work for Acme GmbH. It is a German company.';
-      const entities = extractor.extract(text);
-      const orgEntity = entities.find(e => e.type === 'organization');
-      
-      assert.ok(orgEntity, 'Organization entity should be found');
-      assert.strictEqual(orgEntity.value, 'Acme'); // Canonicalized
-      assert.strictEqual(orgEntity.id, 'organization:acme');
-      assert.deepStrictEqual(orgEntity.mentions, ['Acme GmbH']);
-    });
-
-    it('should extract dates in various formats', () => {
-        const text = 'Event dates: 2026-01-01, 02/03/2024, and 4. Mar 2025 is the German date.';
-        const entities = extractor.extract(text);
-        const dateEntities = entities.filter(e => e.type === 'date');
-        assert.strictEqual(dateEntities.length, 3, 'Should find three distinct dates');
-
-        const dateValues = dateEntities.map(e => e.value).sort();
-        assert.deepStrictEqual(dateValues, ['02/03/2024', '2026-01-01', '4. Mar 2025']);
-    });
-
-    it('should return an empty array for text with no entities', () => {
-        const text = 'this is a plain sentence.';
-        const entities = extractor.extract(text);
-        assert.strictEqual(entities.length, 0);
-    });
-  });
-
-  describe('mergeEntities', () => {
-    it('should merge two disjoint lists of entities', () => {
-      const listA: Entity[] = [{ id: 'person:claude', type: 'person', value: 'Claude', count: 1, importance: 0.7, lastSeen: '2026-01-01', mentions: ['Claude'], source: ['regex'] }];
-      const listB: Entity[] = [{ id: 'org:acme', type: 'organization', value: 'Acme', count: 1, importance: 0.8, lastSeen: '2026-01-01', mentions: ['Acme'], source: ['llm'] }];
-      
-      const merged = EntityExtractor.mergeEntities(listA, listB);
-      assert.strictEqual(merged.length, 2);
-    });
-
-    it('should merge entities with the same ID', () => {
-      const date = new Date().toISOString();
-      const listA: Entity[] = [{ id: 'person:claude', type: 'person', value: 'Claude', count: 1, importance: 0.7, lastSeen: date, mentions: ['Claude'], source: ['regex'] }];
-      const listB: Entity[] = [{ id: 'person:claude', type: 'person', value: 'Claude', count: 2, importance: 0.85, lastSeen: date, mentions: ["claude's", "Claude"], source: ['llm'] }];
-      
-      const merged = EntityExtractor.mergeEntities(listA, listB);
-      assert.strictEqual(merged.length, 1);
-      
-      const entity = merged[0];
-      assert.strictEqual(entity.id, 'person:claude');
-      assert.strictEqual(entity.count, 3);
-      assert.strictEqual(entity.importance, 0.85); // Takes the max importance
-      assert.deepStrictEqual(entity.mentions.sort(), ["Claude", "claude's"].sort());
-      assert.deepStrictEqual(entity.source.sort(), ['llm', 'regex'].sort());
-    });
-
-    it('should handle an empty list', () => {
-      const listA: Entity[] = [{ id: 'person:claude', type: 'person', value: 'Claude', count: 1, importance: 0.7, lastSeen: '2026-01-01', mentions: ['Claude'], source: ['regex'] }];
-      const mergedA = EntityExtractor.mergeEntities(listA, []);
-      assert.deepStrictEqual(mergedA, listA);
-
-      const mergedB = EntityExtractor.mergeEntities([], listA);
-      assert.deepStrictEqual(mergedB, listA);
-
-      const mergedC = EntityExtractor.mergeEntities([], []);
-      assert.deepStrictEqual(mergedC, []);
-    });
-  });
-});

package/test/fact-store.test.ts

@@ -1,266 +0,0 @@
-// test/fact-store.test.ts
-
-import { describe, it, before, after, beforeEach } from 'node:test';
-import * as assert from 'node:assert';
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { FactStore } from '../src/fact-store.js';
-import type { KnowledgeConfig, Logger, Fact } from '../src/types.js';
-
-const createMockLogger = (): Logger => ({
-  info: () => {}, warn: () => {}, error: () => {}, debug: () => {},
-});
-
-const mockConfig: KnowledgeConfig['storage'] = {
-  maxEntities: 100, maxFacts: 10, writeDebounceMs: 0,
-};
-
-describe('FactStore', () => {
-  const testDir = path.join('/tmp', `fact-store-test-${Date.now()}`);
-  let factStore: FactStore;
-
-  before(async () => await fs.mkdir(testDir, { recursive: true }));
-  after(async () => await fs.rm(testDir, { recursive: true, force: true }));
-
-  beforeEach(async () => {
-    // Flush any pending debounced writes from the previous test
-    // to prevent stale data from bleeding across test boundaries.
-    if (factStore) {
-      await factStore.flush();
-    }
-    const filePath = path.join(testDir, 'facts.json');
-    try { await fs.unlink(filePath); } catch (e: unknown) {
-      if ((e as NodeJS.ErrnoException).code !== 'ENOENT') throw e;
-    }
-    factStore = new FactStore(testDir, mockConfig, createMockLogger());
-    await factStore.load();
-  });
-
-  it('should add a new fact to the store', () => {
-    factStore.addFact({ subject: 's1', predicate: 'p1', object: 'o1', source: 'extracted-llm' });
-    const facts = factStore.query({});
-    assert.strictEqual(facts.length, 1);
-  });
-
-  it('should throw if addFact called before load', async () => {
-    const unloaded = new FactStore(testDir, mockConfig, createMockLogger());
-    assert.throws(() => {
-      unloaded.addFact({ subject: 's', predicate: 'p', object: 'o', source: 'ingested' });
-    }, /not been loaded/);
-  });
-
-  it('should deduplicate identical facts by boosting relevance', () => {
-    const f1 = factStore.addFact({ subject: 's', predicate: 'p', object: 'o', source: 'ingested' });
-    assert.strictEqual(f1.relevance, 1.0);
-
-    // Decay the fact first so we can verify the boost
-    factStore.decayFacts(0.5);
-    const decayed = factStore.getFact(f1.id);
-    assert.ok(decayed);
-    // After decay + access boost the relevance should be < 1.0 but > 0.5
-    const preBoost = decayed.relevance;
-
-    // Adding same fact again should boost it
-    const f2 = factStore.addFact({ subject: 's', predicate: 'p', object: 'o', source: 'ingested' });
-    assert.strictEqual(f1.id, f2.id); // Same fact
-    assert.ok(f2.relevance >= preBoost);
-  });
-
-  describe('getFact', () => {
-    it('should retrieve a fact by ID', () => {
-      const added = factStore.addFact({ subject: 's', predicate: 'p', object: 'o', source: 'ingested' });
-      const retrieved = factStore.getFact(added.id);
-      assert.ok(retrieved);
-      assert.strictEqual(retrieved.subject, 's');
-      assert.strictEqual(retrieved.predicate, 'p');
-      assert.strictEqual(retrieved.object, 'o');
-    });
-
-    it('should return undefined for non-existent ID', () => {
-      const result = factStore.getFact('non-existent-id');
-      assert.strictEqual(result, undefined);
-    });
-
-    it('should boost relevance on access', () => {
-      const f = factStore.addFact({ subject: 's', predicate: 'p', object: 'o', source: 'ingested' });
-      factStore.decayFacts(0.5); // Decay to 0.5ish
-      const decayedFact = factStore.query({ subject: 's' })[0];
-      const decayedRelevance = decayedFact.relevance;
-
-      const accessed = factStore.getFact(f.id);
-      assert.ok(accessed);
-      assert.ok(accessed.relevance > decayedRelevance, 'Relevance should increase on access');
-    });
-
-    it('should update lastAccessed timestamp', () => {
-      const f = factStore.addFact({ subject: 's', predicate: 'p', object: 'o', source: 'ingested' });
-      const before = f.lastAccessed;
-
-      // Small delay to get a different timestamp
-      const accessed = factStore.getFact(f.id);
-      assert.ok(accessed);
-      assert.ok(new Date(accessed.lastAccessed) >= new Date(before));
-    });
-  });
-
-  describe('query', () => {
-    it('should query by subject', () => {
-      factStore.addFact({ subject: 'alice', predicate: 'knows', object: 'bob', source: 'ingested' });
-      factStore.addFact({ subject: 'charlie', predicate: 'knows', object: 'bob', source: 'ingested' });
-
-      const results = factStore.query({ subject: 'alice' });
-      assert.strictEqual(results.length, 1);
-      assert.strictEqual(results[0].subject, 'alice');
-    });
-
-    it('should query by predicate', () => {
-      factStore.addFact({ subject: 'a', predicate: 'is-a', object: 'b', source: 'ingested' });
-      factStore.addFact({ subject: 'c', predicate: 'works-at', object: 'd', source: 'ingested' });
-
-      const results = factStore.query({ predicate: 'is-a' });
-      assert.strictEqual(results.length, 1);
-      assert.strictEqual(results[0].predicate, 'is-a');
-    });
-
-    it('should query by object', () => {
-      factStore.addFact({ subject: 'a', predicate: 'p', object: 'target', source: 'ingested' });
-      factStore.addFact({ subject: 'b', predicate: 'p', object: 'other', source: 'ingested' });
-
-      const results = factStore.query({ object: 'target' });
-      assert.strictEqual(results.length, 1);
-      assert.strictEqual(results[0].object, 'target');
-    });
-
-    it('should query with multiple filters', () => {
-      factStore.addFact({ subject: 'a', predicate: 'p1', object: 'o1', source: 'ingested' });
-      factStore.addFact({ subject: 'a', predicate: 'p2', object: 'o2', source: 'ingested' });
-      factStore.addFact({ subject: 'b', predicate: 'p1', object: 'o1', source: 'ingested' });
-
-      const results = factStore.query({ subject: 'a', predicate: 'p1' });
-      assert.strictEqual(results.length, 1);
-      assert.strictEqual(results[0].object, 'o1');
-    });
-
-    it('should return all facts when query is empty', () => {
-      factStore.addFact({ subject: 'a', predicate: 'p', object: 'o1', source: 'ingested' });
-      factStore.addFact({ subject: 'b', predicate: 'p', object: 'o2', source: 'ingested' });
-      const results = factStore.query({});
-      assert.strictEqual(results.length, 2);
-    });
-
-    it('should sort results by relevance descending', () => {
-      const f1 = factStore.addFact({ subject: 'a', predicate: 'p', object: 'o1', source: 'ingested' });
-      factStore.addFact({ subject: 'b', predicate: 'p', object: 'o2', source: 'ingested' });
-
-      // Decay all, then access f1 to boost it
-      factStore.decayFacts(0.5);
-      factStore.getFact(f1.id);
-
-      const results = factStore.query({});
-      assert.strictEqual(results[0].subject, 'a'); // f1 has higher relevance after boost
-    });
-  });
-
-  describe('decayFacts', () => {
-    it('should reduce relevance of all facts', () => {
-      factStore.addFact({ subject: 'a', predicate: 'p', object: 'o', source: 'ingested' });
-      const { decayedCount } = factStore.decayFacts(0.5);
-      assert.strictEqual(decayedCount, 1);
-
-      const facts = factStore.query({});
-      assert.ok(facts[0].relevance < 1.0);
-      assert.ok(facts[0].relevance >= 0.1); // Min relevance floor
-    });
-
-    it('should not decay below the minimum relevance of 0.1', () => {
-      factStore.addFact({ subject: 'a', predicate: 'p', object: 'o', source: 'ingested' });
-      // Apply extreme decay many times
-      for (let i = 0; i < 100; i++) factStore.decayFacts(0.99);
-      const facts = factStore.query({});
-      assert.ok(facts[0].relevance >= 0.1);
-    });
-
-    it('should return 0 when no facts exist', () => {
-      const { decayedCount } = factStore.decayFacts(0.1);
-      assert.strictEqual(decayedCount, 0);
-    });
-  });
-
-  describe('getUnembeddedFacts', () => {
-    it('should return facts without embedded timestamp', () => {
-      factStore.addFact({ subject: 'a', predicate: 'p', object: 'o1', source: 'ingested' });
-      factStore.addFact({ subject: 'b', predicate: 'p', object: 'o2', source: 'ingested' });
-
-      const unembedded = factStore.getUnembeddedFacts();
-      assert.strictEqual(unembedded.length, 2);
-    });
-
-    it('should exclude embedded facts', () => {
-      const f1 = factStore.addFact({ subject: 'a', predicate: 'p', object: 'o1', source: 'ingested' });
-      factStore.addFact({ subject: 'b', predicate: 'p', object: 'o2', source: 'ingested' });
-
-      factStore.markFactsAsEmbedded([f1.id]);
-
-      const unembedded = factStore.getUnembeddedFacts();
-      assert.strictEqual(unembedded.length, 1);
-      assert.strictEqual(unembedded[0].subject, 'b');
-    });
-
-    it('should return empty array when all facts are embedded', () => {
-      const f1 = factStore.addFact({ subject: 'a', predicate: 'p', object: 'o', source: 'ingested' });
-      factStore.markFactsAsEmbedded([f1.id]);
-
-      const unembedded = factStore.getUnembeddedFacts();
-      assert.strictEqual(unembedded.length, 0);
-    });
-  });
-
-  describe('markFactsAsEmbedded', () => {
-    it('should set the embedded timestamp on specified facts', () => {
-      const f1 = factStore.addFact({ subject: 'a', predicate: 'p', object: 'o', source: 'ingested' });
-      assert.strictEqual(f1.embedded, undefined);
-
-      factStore.markFactsAsEmbedded([f1.id]);
-      const updated = factStore.getFact(f1.id);
-      assert.ok(updated);
-      assert.ok(updated.embedded);
-      assert.ok(typeof updated.embedded === 'string');
-    });
-
-    it('should handle non-existent fact IDs gracefully', () => {
-      factStore.addFact({ subject: 'a', predicate: 'p', object: 'o', source: 'ingested' });
-      // Should not throw
-      factStore.markFactsAsEmbedded(['non-existent-id']);
-      assert.ok(true);
-    });
-
-    it('should only update specified facts', () => {
-      const f1 = factStore.addFact({ subject: 'a', predicate: 'p', object: 'o1', source: 'ingested' });
-      const f2 = factStore.addFact({ subject: 'b', predicate: 'p', object: 'o2', source: 'ingested' });
-
-      factStore.markFactsAsEmbedded([f1.id]);
-
-      const updated1 = factStore.getFact(f1.id);
-      const updated2 = factStore.getFact(f2.id);
-      assert.ok(updated1?.embedded);
-      assert.strictEqual(updated2?.embedded, undefined);
-    });
-  });
-
-  it('should remove the least recently accessed facts when pruning', () => {
-    for (let i = 0; i < 11; i++) {
-      const fact = factStore.addFact({ subject: 's', predicate: 'p', object: `o${i}`, source: 'ingested' });
-      const internalFact = (factStore as Record<string, unknown> as { facts: Map<string, Fact> }).facts.get(fact.id);
-      if (internalFact) {
-        internalFact.lastAccessed = new Date(Date.now() - (10 - i) * 1000).toISOString();
-      }
-    }
-
-    const facts = factStore.query({});
-    assert.strictEqual(facts.length, 10);
-
-    const objects = facts.map(f => f.object);
-    assert.strictEqual(objects.includes('o0'), false, 'Fact "o0" (oldest) should have been pruned');
-    assert.strictEqual(objects.includes('o1'), true, 'Fact "o1" should still exist');
-  });
-});