@longarc/mdash 3.1.1 → 3.1.3

package/src/context/__tests__/caret-v0.2.0.test.ts

@@ -0,0 +1,860 @@
+/**
+ * Caret Engine v0.2.0 Test Suite
+ * Now integrated as mdash Context Module v3.1
+ *
+ * Comprehensive tests for research pattern integration:
+ * - Core runtime (seal, compose, resolve)
+ * - Utility learning
+ * - Credit assignment
+ * - Keyword search (Three-Layer Index Layer 2)
+ * - Semantic similarity (Three-Layer Index Layer 1)
+ * - Atomic encoding utilities
+ */
+
+import { describe, test, expect, beforeEach } from 'vitest';
+
+import {
+  createCaret,
+  MemoryStore,
+  ExtendedMemoryStore,
+  VERSION,
+  // Crypto
+  sha256,
+  sha256Object,
+  hmacSeal,
+  hmacVerify,
+  // Types
+  type ContextFragment,
+  type ExecutionTrace,
+  type InfluenceBudget,
+  type UtilityScore,
+  type Timestamp,
+  type FragmentId,
+  // Constraint builders
+  maxAge,
+  requireTrust,
+  requireInfluence,
+  requireMCCA,
+  // Utility learning
+  updateUtilityScore,
+  createInitialUtility,
+  predictSuccess,
+  // Credit assignment
+  assignCredit,
+  validateCreditAssignment,
+  attributeLiability,
+  validateLiabilityShares,
+  createDefaultInfluenceBudget,
+  isMCCACompliant,
+  normalizeInfluenceBudget,
+  // Atomic encoding
+  resolveCoreferences,
+  createDefaultContext,
+  hasUnresolvedCoreferences,
+  canonicalEncode,
+  isValidSubject,
+  isValidTimestamp,
+  // Type guards
+  isValidInfluenceBudget,
+  sumInfluence,
+} from '../index.js';
+
+// ============================================================================
+// TEST UTILITIES
+// ============================================================================
+
+const SEAL_KEY = 'test-secret-key-do-not-use-in-production-32';
+
+function createTestTrace(steps: number = 3): ExecutionTrace {
+  const traceSteps = [];
+  for (let i = 0; i < steps; i++) {
+    traceSteps.push({
+      step_id: `Agent_${i.toString().padStart(4, '0')}_step_${i}`,
+      timestamp: new Date(Date.now() + i * 1000).toISOString() as Timestamp,
+      action: 'INVOKE' as const,
+      observation_hash: `hash_${i}`,
+      influence_consumed: {
+        system: 0.1,
+        user: 0.05,
+        environment: 0.03,
+        assistant: 0.02,
+      },
+    });
+  }
+  
+  return {
+    trace_id: `trace_${Date.now()}` as FragmentId,
+    steps: traceSteps,
+    outcome: 'success',
+    terminal_state: 'completed',
+  };
+}
+
+// ============================================================================
+// VERSION & BASIC TESTS
+// ============================================================================
+
+describe('Caret Core', () => {
+  test('VERSION is 0.2.0', () => {
+    expect(VERSION).toBe('3.1.0');
+  });
+  
+  test('createCaret requires seal_key', () => {
+    expect(() => createCaret({ seal_key: '' })).toThrow();
+  });
+  
+  test('createCaret enforces minimum key length', () => {
+    expect(() => createCaret({ seal_key: 'short' })).toThrow('at least 32');
+  });
+  
+  test('createCaret creates runtime with valid key', () => {
+    const caret = createCaret({ seal_key: SEAL_KEY });
+    expect(caret).toBeDefined();
+    expect(caret.seal).toBeDefined();
+    expect(caret.compose).toBeDefined();
+    expect(caret.resolve).toBeDefined();
+    expect(caret.store).toBeDefined();
+  });
+});
+
+// ============================================================================
+// CRYPTO TESTS
+// ============================================================================
+
+describe('Crypto', () => {
+  test('sha256 produces consistent hashes', async () => {
+    const hash1 = await sha256('hello world');
+    const hash2 = await sha256('hello world');
+    expect(hash1).toBe(hash2);
+    expect(hash1.length).toBe(64);
+  });
+  
+  test('sha256 produces different hashes for different inputs', async () => {
+    const hash1 = await sha256('hello');
+    const hash2 = await sha256('world');
+    expect(hash1).not.toBe(hash2);
+  });
+  
+  test('sha256Object is deterministic with sorted keys', async () => {
+    const hash1 = await sha256Object({ b: 2, a: 1 });
+    const hash2 = await sha256Object({ a: 1, b: 2 });
+    expect(hash1).toBe(hash2);
+  });
+  
+  test('hmacSeal produces verifiable seals', async () => {
+    const content = { message: 'test' };
+    const seal = await hmacSeal(content, SEAL_KEY);
+    const isValid = await hmacVerify(content, seal, SEAL_KEY);
+    expect(isValid).toBe(true);
+  });
+  
+  test('hmacVerify rejects tampered content', async () => {
+    const content = { message: 'test' };
+    const seal = await hmacSeal(content, SEAL_KEY);
+    const tampered = { message: 'tampered' };
+    const isValid = await hmacVerify(tampered, seal, SEAL_KEY);
+    expect(isValid).toBe(false);
+  });
+});
+
+// ============================================================================
+// FRAGMENT TESTS
+// ============================================================================
+
+describe('Fragment Operations', () => {
+  let caret: ReturnType<typeof createCaret>;
+  
+  beforeEach(() => {
+    caret = createCaret({ seal_key: SEAL_KEY });
+  });
+  
+  test('seal creates valid fragment', async () => {
+    const fragment = await caret.seal({
+      content: { message: 'hello' },
+      source: 'test://example' as any,
+      attribution: 'system',
+    });
+    
+    expect(fragment.id).toBeDefined();
+    expect(fragment.hash).toBeDefined();
+    expect(fragment.seal).toBeDefined();
+    expect(fragment.content.data).toEqual({ message: 'hello' });
+    expect(fragment.version).toBe('v3.1');
+  });
+  
+  test('seal with trust level', async () => {
+    const fragment = await caret.seal({
+      content: 'test',
+      source: 'test://example' as any,
+      attribution: 'user',
+      trust_level: 80 as any,
+    });
+    
+    expect(fragment.provenance.head.trust_level).toBe(80);
+  });
+  
+  test('verify returns true for valid fragment', async () => {
+    const fragment = await caret.seal({
+      content: 'verify test',
+      source: 'test://verify' as any,
+      attribution: 'system',
+    });
+    
+    const isValid = await caret.verify(fragment);
+    expect(isValid).toBe(true);
+  });
+});
+
+// ============================================================================
+// CONSTRAINT TESTS
+// ============================================================================
+
+describe('Constraints', () => {
+  let caret: ReturnType<typeof createCaret>;
+  
+  beforeEach(() => {
+    caret = createCaret({ seal_key: SEAL_KEY });
+  });
+  
+  test('maxAge constraint', async () => {
+    const fragment = await caret.seal({
+      content: 'age test',
+      source: 'test://age' as any,
+      attribution: 'system',
+      constraints: [maxAge(60000)],
+    });
+    
+    const result = await caret.resolve(fragment);
+    expect(result.success).toBe(true);
+  });
+  
+  test('requireTrust constraint', async () => {
+    const fragment = await caret.seal({
+      content: 'trust test',
+      source: 'test://trust' as any,
+      attribution: 'system',
+      trust_level: 90 as any,
+      constraints: [requireTrust(80)],
+    });
+    
+    const result = await caret.resolve(fragment);
+    expect(result.success).toBe(true);
+  });
+  
+  test('requireInfluence constraint', async () => {
+    const budget: InfluenceBudget = {
+      system: 0.45,
+      user: 0.30,
+      environment: 0.15,
+      assistant: 0.10,
+    };
+    
+    const constraint = requireInfluence(budget);
+    expect(constraint.kind).toBe('influence');
+    expect(constraint.budget).toEqual(budget);
+  });
+  
+  test('requireMCCA constraint creates MCCA-compliant budget', () => {
+    const constraint = requireMCCA();
+    expect(constraint.kind).toBe('influence');
+    expect(isMCCACompliant(constraint.budget)).toBe(true);
+  });
+});
+
+// ============================================================================
+// UTILITY LEARNING TESTS
+// ============================================================================
+
+describe('Utility Learning', () => {
+  test('createInitialUtility creates valid utility score', () => {
+    const utility = createInitialUtility();
+    expect(utility.score).toBe(0);
+    expect(utility.confidence).toBe(0);
+    expect(utility.update_count).toBe(0);
+  });
+  
+  test('updateUtilityScore increments correctly', () => {
+    const initial = createInitialUtility();
+    const feedback = {
+      reward: 1.0,
+      source: 'human' as const,
+      timestamp: new Date().toISOString() as Timestamp,
+    };
+    
+    const updated = updateUtilityScore(initial, feedback);
+    
+    expect(updated.score).toBeGreaterThan(0);
+    expect(updated.update_count).toBe(1);
+    expect(updated.confidence).toBeGreaterThan(0);
+  });
+  
+  test('updateUtilityScore bounds score to [-1, 1]', () => {
+    let utility = createInitialUtility();
+    
+    // Push score high
+    for (let i = 0; i < 20; i++) {
+      utility = updateUtilityScore(utility, {
+        reward: 1.0,
+        source: 'system' as const,
+        timestamp: new Date().toISOString() as Timestamp,
+      });
+    }
+    
+    expect(utility.score).toBeLessThanOrEqual(1.0);
+    expect(utility.score).toBeGreaterThanOrEqual(-1.0);
+  });
+  
+  test('updateUtilityScore increases confidence with updates', () => {
+    let utility = createInitialUtility();
+    const confidences: number[] = [utility.confidence];
+    
+    for (let i = 0; i < 10; i++) {
+      utility = updateUtilityScore(utility, {
+        reward: 0.5,
+        source: 'environment' as const,
+        timestamp: new Date().toISOString() as Timestamp,
+      });
+      confidences.push(utility.confidence);
+    }
+    
+    // Each confidence should be >= previous
+    for (let i = 1; i < confidences.length; i++) {
+      expect(confidences[i]).toBeGreaterThanOrEqual(confidences[i-1]!);
+    }
+  });
+  
+  test('predictSuccess returns prior for empty history', () => {
+    const prediction = predictSuccess([]);
+    expect(prediction).toBe(0.5);
+  });
+});
+
+// ============================================================================
+// CREDIT ASSIGNMENT TESTS
+// ============================================================================
+
+describe('Credit Assignment', () => {
+  test('assignCredit distributes terminal reward', () => {
+    const trace = createTestTrace(3);
+    const terminalReward = 1.0;
+    
+    const assignment = assignCredit(trace, terminalReward);
+    
+    expect(assignment.trace_id).toBe(trace.trace_id);
+    expect(assignment.terminal_reward).toBe(terminalReward);
+    expect(assignment.step_credits.length).toBe(3);
+  });
+  
+  test('assignCredit conserves terminal reward', () => {
+    const trace = createTestTrace(5);
+    const terminalReward = 10.0;
+    
+    const assignment = assignCredit(trace, terminalReward);
+    
+    expect(validateCreditAssignment(assignment)).toBe(true);
+  });
+  
+  test('assignCredit proportional to influence', () => {
+    // Create trace with unequal influence
+    const trace: ExecutionTrace = {
+      trace_id: 'test_trace' as FragmentId,
+      steps: [
+        {
+          step_id: 'Agent_0001_step_0',
+          timestamp: new Date().toISOString() as Timestamp,
+          action: 'INVOKE',
+          observation_hash: 'hash_0',
+          influence_consumed: { system: 0.4, user: 0.3, environment: 0.2, assistant: 0.1 },
+        },
+        {
+          step_id: 'Agent_0002_step_1',
+          timestamp: new Date().toISOString() as Timestamp,
+          action: 'CHECKPOINT',
+          observation_hash: 'hash_1',
+          influence_consumed: { system: 0.1, user: 0.05, environment: 0.03, assistant: 0.02 },
+        },
+      ],
+      outcome: 'success',
+      terminal_state: 'done',
+    };
+    
+    const assignment = assignCredit(trace, 1.0);
+    
+    // First step has more influence, should get more credit
+    expect(assignment.step_credits[0]!.credit).toBeGreaterThan(assignment.step_credits[1]!.credit);
+  });
+  
+  test('attributeLiability groups by agent', () => {
+    const trace: ExecutionTrace = {
+      trace_id: 'liability_trace' as FragmentId,
+      steps: [
+        {
+          step_id: 'Agent_aaa1_step_0',
+          timestamp: new Date().toISOString() as Timestamp,
+          action: 'INVOKE',
+          observation_hash: 'h0',
+          influence_consumed: { system: 0.2, user: 0.1, environment: 0.1, assistant: 0.1 },
+        },
+        {
+          step_id: 'Agent_bbb2_step_1',
+          timestamp: new Date().toISOString() as Timestamp,
+          action: 'CHECKPOINT',
+          observation_hash: 'h1',
+          influence_consumed: { system: 0.2, user: 0.1, environment: 0.1, assistant: 0.1 },
+        },
+        {
+          step_id: 'Agent_aaa1_step_2',
+          timestamp: new Date().toISOString() as Timestamp,
+          action: 'TERMINATE',
+          observation_hash: 'h2',
+          influence_consumed: { system: 0.2, user: 0.1, environment: 0.1, assistant: 0.1 },
+        },
+      ],
+      outcome: 'success',
+      terminal_state: 'done',
+    };
+    
+    const liability = attributeLiability(trace);
+    
+    // Should have 2 agents
+    expect(liability.length).toBe(2);
+    expect(validateLiabilityShares(liability)).toBe(true);
+    
+    // Agent_aaa1 should have more liability (2 steps vs 1)
+    const agentA = liability.find(l => l.agent_id.includes('aaa1'));
+    const agentB = liability.find(l => l.agent_id.includes('bbb2'));
+    expect(agentA!.contribution).toBeGreaterThan(agentB!.contribution);
+  });
+});
+
+// ============================================================================
+// INFLUENCE BUDGET TESTS
+// ============================================================================
+
+describe('Influence Budget', () => {
+  test('createDefaultInfluenceBudget creates valid budget', () => {
+    const budget = createDefaultInfluenceBudget();
+    expect(isValidInfluenceBudget(budget)).toBe(true);
+    expect(isMCCACompliant(budget)).toBe(true);
+  });
+  
+  test('isMCCACompliant validates bounds', () => {
+    // Valid
+    expect(isMCCACompliant({ system: 0.45, user: 0.30, environment: 0.15, assistant: 0.10 })).toBe(true);
+    
+    // Invalid: system too low
+    expect(isMCCACompliant({ system: 0.35, user: 0.30, environment: 0.20, assistant: 0.15 })).toBe(false);
+    
+    // Invalid: user too high
+    expect(isMCCACompliant({ system: 0.40, user: 0.40, environment: 0.10, assistant: 0.10 })).toBe(false);
+  });
+  
+  test('normalizeInfluenceBudget sums to 1.0', () => {
+    const unnormalized = { system: 0.8, user: 0.4, environment: 0.2, assistant: 0.1 };
+    const normalized = normalizeInfluenceBudget(unnormalized);
+    
+    const sum = sumInfluence(normalized);
+    expect(Math.abs(sum - 1.0)).toBeLessThan(0.001);
+  });
+  
+  test('sumInfluence computes total', () => {
+    const budget = { system: 0.4, user: 0.3, environment: 0.2, assistant: 0.1 };
+    expect(sumInfluence(budget)).toBeCloseTo(1.0);
+  });
+});
+
+// ============================================================================
+// ATOMIC ENCODING TESTS
+// ============================================================================
+
+describe('Atomic Encoding', () => {
+  test('resolveCoreferences replaces pronouns', () => {
+    const context = createDefaultContext();
+    context.lastAgentId = 'Agent_abc123';
+    
+    const text = 'He approved the request';
+    const resolved = resolveCoreferences(text, context);
+    
+    expect(resolved).toContain('Agent_abc123');
+  });
+  
+  test('resolveCoreferences replaces relative time', () => {
+    const context = createDefaultContext();
+    const refDate = new Date('2026-01-18T12:00:00Z');
+    context.referenceTime = refDate.toISOString();
+    
+    const text = 'Approved yesterday';
+    const resolved = resolveCoreferences(text, context);
+    
+    // Should contain ISO timestamp, not "yesterday"
+    expect(resolved).not.toContain('yesterday');
+    expect(resolved).toContain('2026-01-17');
+  });
+  
+  test('hasUnresolvedCoreferences detects pronouns', () => {
+    expect(hasUnresolvedCoreferences('He did it')).toBe(true);
+    expect(hasUnresolvedCoreferences('Agent_123 invoked Warrant_456')).toBe(false);
+  });
+  
+  test('canonicalEncode produces deterministic output', () => {
+    const attestation = {
+      subject: 'Agent_abc',
+      action: 'INVOKE' as const,
+      timestamp: '2026-01-18T00:00:00Z',
+    };
+    
+    const encoded1 = canonicalEncode(attestation);
+    const encoded2 = canonicalEncode(attestation);
+    
+    expect(encoded1).toBe(encoded2);
+  });
+  
+  test('isValidSubject validates entity IDs', () => {
+    expect(isValidSubject('Agent_abc123')).toBe(true);
+    expect(isValidSubject('Warrant_def456')).toBe(true);
+    expect(isValidSubject('Checkpoint_abc789')).toBe(true);  // hex only
+    expect(isValidSubject('User_012abc')).toBe(true);
+    expect(isValidSubject('invalid')).toBe(false);
+    expect(isValidSubject('Agent_xyz')).toBe(false);  // xyz not hex
+  });
+  
+  test('isValidTimestamp validates ISO 8601', () => {
+    expect(isValidTimestamp('2026-01-18T12:00:00Z')).toBe(true);
+    expect(isValidTimestamp('2026-01-18T12:00:00.123Z')).toBe(true);
+    expect(isValidTimestamp('yesterday')).toBe(false);
+    expect(isValidTimestamp('2026-01-18')).toBe(false);
+  });
+});
+
+// ============================================================================
+// KEYWORD SEARCH TESTS (Three-Layer Index Layer 2)
+// ============================================================================
+
+describe('Keyword Search (Layer 2)', () => {
+  let store: MemoryStore;
+  let caret: ReturnType<typeof createCaret>;
+  
+  beforeEach(() => {
+    store = new MemoryStore(SEAL_KEY);
+    caret = createCaret({ seal_key: SEAL_KEY, store });
+  });
+  
+  test('queryByKeywords finds matching fragments', async () => {
+    await caret.seal({
+      content: 'The quick brown fox jumps over the lazy dog',
+      source: 'test://keyword1' as any,
+      attribution: 'system',
+    });
+    
+    await caret.seal({
+      content: 'A fast red cat sleeps on the mat',
+      source: 'test://keyword2' as any,
+      attribution: 'system',
+    });
+    
+    const results = await store.queryByKeywords(['fox']);
+    expect(results.length).toBe(1);
+    expect((results[0]!.content.data as string)).toContain('fox');
+  });
+  
+  test('queryByKeywords with matchMode any', async () => {
+    await caret.seal({
+      content: 'Document about cats and dogs',
+      source: 'test://any1' as any,
+      attribution: 'system',
+    });
+    
+    await caret.seal({
+      content: 'Document about birds',
+      source: 'test://any2' as any,
+      attribution: 'system',
+    });
+    
+    const results = await store.queryByKeywords(['cats', 'birds'], 'any');
+    expect(results.length).toBe(2);
+  });
+  
+  test('queryByKeywords with matchMode all', async () => {
+    await caret.seal({
+      content: 'Document about cats and dogs',
+      source: 'test://all1' as any,
+      attribution: 'system',
+    });
+    
+    await caret.seal({
+      content: 'Document about dogs only',
+      source: 'test://all2' as any,
+      attribution: 'system',
+    });
+    
+    const results = await store.queryByKeywords(['cats', 'dogs'], 'all');
+    expect(results.length).toBe(1);
+    expect((results[0]!.content.data as string)).toContain('cats');
+    expect((results[0]!.content.data as string)).toContain('dogs');
+  });
+  
+  test('queryByKeywords is case-insensitive', async () => {
+    await caret.seal({
+      content: 'UPPERCASE CONTENT',
+      source: 'test://case' as any,
+      attribution: 'system',
+    });
+    
+    const results = await store.queryByKeywords(['uppercase']);
+    expect(results.length).toBe(1);
+  });
+  
+  test('queryByKeywords searches object content', async () => {
+    await caret.seal({
+      content: { title: 'Meeting Notes', body: 'Discussed project alpha' },
+      source: 'test://object' as any,
+      attribution: 'system',
+    });
+    
+    const results = await store.queryByKeywords(['alpha']);
+    expect(results.length).toBe(1);
+  });
+  
+  test('queryByKeywords returns empty for no matches', async () => {
+    await caret.seal({
+      content: 'Some unrelated content',
+      source: 'test://nomatch' as any,
+      attribution: 'system',
+    });
+    
+    const results = await store.queryByKeywords(['xyz123']);
+    expect(results.length).toBe(0);
+  });
+});
+
+// ============================================================================
+// SEMANTIC SIMILARITY TESTS (Three-Layer Index Layer 1)
+// ============================================================================
+
+describe('Semantic Similarity (Layer 1)', () => {
+  let store: ExtendedMemoryStore;
+  let caret: ReturnType<typeof createCaret>;
+  
+  beforeEach(() => {
+    store = new ExtendedMemoryStore(SEAL_KEY);
+    caret = createCaret({ seal_key: SEAL_KEY, store });
+  });
+  
+  test('ExtendedMemoryStore inherits MemoryStore methods', async () => {
+    const fragment = await caret.seal({
+      content: 'test content',
+      source: 'test://inherit' as any,
+      attribution: 'system',
+    });
+    
+    const retrieved = await store.get(fragment.id);
+    expect(retrieved).not.toBeNull();
+    expect(retrieved!.id).toBe(fragment.id);
+  });
+  
+  test('setEmbedding stores embedding for fragment', async () => {
+    const fragment = await caret.seal({
+      content: 'semantic test',
+      source: 'test://embed' as any,
+      attribution: 'system',
+    });
+    
+    const embedding = new Float32Array([0.1, 0.2, 0.3, 0.4]);
+    store.setEmbedding(fragment.id, embedding);
+    
+    const stats = store.embeddingStats();
+    expect(stats.count).toBe(1);
+  });
+  
+  test('queryBySimilarity finds similar fragments', async () => {
+    const fragment1 = await caret.seal({
+      content: 'machine learning is great',
+      source: 'test://sim1' as any,
+      attribution: 'system',
+    });
+    
+    const fragment2 = await caret.seal({
+      content: 'cooking recipes for dinner',
+      source: 'test://sim2' as any,
+      attribution: 'system',
+    });
+    
+    // Manually set embeddings (in real use, embedding function would do this)
+    const embedding1 = new Float32Array([0.9, 0.1, 0.0, 0.0]); // ML-like
+    const embedding2 = new Float32Array([0.0, 0.0, 0.9, 0.1]); // Cooking-like
+    
+    store.setEmbedding(fragment1.id, embedding1);
+    store.setEmbedding(fragment2.id, embedding2);
+    
+    // Query for ML-like content
+    const queryEmbedding = new Float32Array([0.8, 0.2, 0.0, 0.0]);
+    const results = await store.queryBySimilarity(queryEmbedding, 0.5, 10);
+    
+    expect(results.length).toBeGreaterThan(0);
+    expect(results[0]!.fragment.id).toBe(fragment1.id); // ML doc should be first
+    expect(results[0]!.similarity).toBeGreaterThan(0.5);
+  });
+  
+  test('queryBySimilarity respects threshold', async () => {
+    const fragment = await caret.seal({
+      content: 'test threshold',
+      source: 'test://threshold' as any,
+      attribution: 'system',
+    });
+    
+    const embedding = new Float32Array([0.1, 0.0, 0.0, 0.9]);
+    store.setEmbedding(fragment.id, embedding);
+    
+    // Query with orthogonal vector
+    const queryEmbedding = new Float32Array([0.9, 0.1, 0.0, 0.0]);
+    
+    // High threshold should exclude
+    const highThreshold = await store.queryBySimilarity(queryEmbedding, 0.9, 10);
+    expect(highThreshold.length).toBe(0);
+    
+    // Low threshold should include
+    const lowThreshold = await store.queryBySimilarity(queryEmbedding, 0.0, 10);
+    expect(lowThreshold.length).toBe(1);
+  });
+  
+  test('queryBySimilarity respects limit', async () => {
+    // Create multiple fragments
+    for (let i = 0; i < 5; i++) {
+      const fragment = await caret.seal({
+        content: `document ${i}`,
+        source: `test://limit${i}` as any,
+        attribution: 'system',
+      });
+      
+      // All similar embeddings
+      const embedding = new Float32Array([0.5, 0.5, 0.0, 0.0]);
+      store.setEmbedding(fragment.id, embedding);
+    }
+    
+    const queryEmbedding = new Float32Array([0.5, 0.5, 0.0, 0.0]);
+    const results = await store.queryBySimilarity(queryEmbedding, 0.0, 3);
+    
+    expect(results.length).toBe(3);
+  });
+  
+  test('setEmbeddingFunction auto-embeds on put', async () => {
+    // Track calls to embedding function
+    let callCount = 0;
+    const mockEmbedFn = async (_text: string): Promise<Float32Array> => {
+      callCount++;
+      return new Float32Array([0.1, 0.2, 0.3, 0.4]);
+    };
+    store.setEmbeddingFunction(mockEmbedFn);
+    
+    await caret.seal({
+      content: 'auto embed test',
+      source: 'test://autoembed' as any,
+      attribution: 'system',
+    });
+    
+    expect(callCount).toBe(1);
+    expect(store.embeddingStats().count).toBe(1);
+  });
+  
+  test('clearEmbeddings removes all embeddings', async () => {
+    const fragment = await caret.seal({
+      content: 'clear test',
+      source: 'test://clear' as any,
+      attribution: 'system',
+    });
+    
+    store.setEmbedding(fragment.id, new Float32Array([0.1, 0.2, 0.3, 0.4]));
+    expect(store.embeddingStats().count).toBe(1);
+    
+    store.clearEmbeddings();
+    expect(store.embeddingStats().count).toBe(0);
+  });
+});
+
+// ============================================================================
+// INTEGRATION TESTS
+// ============================================================================
+
+describe('Integration', () => {
+  test('full workflow: seal, resolve, assign credit', async () => {
+    const caret = createCaret({ seal_key: SEAL_KEY });
+    
+    // 1. Seal a fragment
+    const fragment = await caret.seal({
+      content: { task: 'complete integration test' },
+      source: 'test://integration' as any,
+      attribution: 'system',
+      constraints: [
+        requireTrust(50),
+        requireMCCA(),
+      ],
+    });
+    
+    // 2. Resolve through constraints
+    const resolution = await caret.resolve(fragment, {
+      current_time: new Date().toISOString() as Timestamp,
+      current_domain: 'test',
+      current_trust: 100,
+      current_influence: createDefaultInfluenceBudget(),
+    });
+    
+    expect(resolution.success).toBe(true);
+    
+    // 3. Create execution trace
+    const trace = createTestTrace(4);
+    
+    // 4. Assign credit
+    const credits = assignCredit(trace, 1.0);
+    expect(validateCreditAssignment(credits)).toBe(true);
+    
+    // 5. Attribute liability
+    const liability = attributeLiability(trace);
+    expect(validateLiabilityShares(liability)).toBe(true);
+  });
+  
+  test('three-layer index workflow', async () => {
+    const store = new ExtendedMemoryStore(SEAL_KEY);
+    const caret = createCaret({ seal_key: SEAL_KEY, store });
+    
+    // Create documents
+    const doc1 = await caret.seal({
+      content: 'Machine learning models for NLP',
+      source: 'test://ml1' as any,
+      attribution: 'system',
+    });
+    
+    const doc2 = await caret.seal({
+      content: 'Deep learning neural networks',
+      source: 'test://ml2' as any,
+      attribution: 'system',
+    });
+    
+    const doc3 = await caret.seal({
+      content: 'Cooking pasta recipes',
+      source: 'test://cook' as any,
+      attribution: 'system',
+    });
+    
+    // Set embeddings
+    store.setEmbedding(doc1.id, new Float32Array([0.9, 0.8, 0.1, 0.0]));
+    store.setEmbedding(doc2.id, new Float32Array([0.85, 0.75, 0.15, 0.05]));
+    store.setEmbedding(doc3.id, new Float32Array([0.1, 0.1, 0.9, 0.8]));
+    
+    // Layer 2: Keyword search
+    const keywordResults = await store.queryByKeywords(['learning']);
+    expect(keywordResults.length).toBe(2); // doc1 and doc2
+    
+    // Layer 1: Semantic search
+    const queryEmb = new Float32Array([0.9, 0.85, 0.1, 0.0]); // ML-like query
+    const semanticResults = await store.queryBySimilarity(queryEmb, 0.8, 5);
+    expect(semanticResults.length).toBe(2); // doc1 and doc2
+    expect(semanticResults[0]!.similarity).toBeGreaterThan(0.9);
+    
+    // Layer 3: Time-based (symbolic)
+    const now = new Date();
+    const from = new Date(now.getTime() - 60000).toISOString() as Timestamp;
+    const to = new Date(now.getTime() + 60000).toISOString() as Timestamp;
+    const timeResults = await store.queryByTime(from, to);
+    expect(timeResults.length).toBe(3); // All docs
+  });
+});