@osmosis-ai/core 0.1.0

package/src/__tests__/capture.test.ts

@@ -0,0 +1,113 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { AtomStore } from '../store/index.js';
+import { captureToolCall, captureOutcome } from '../capture/index.js';
+import type { OutcomeSignals } from '../types/index.js';
+
+describe('captureToolCall', () => {
+  let store: AtomStore;
+
+  beforeEach(() => { store = new AtomStore(':memory:'); });
+  afterEach(() => { store.close(); });
+
+  it('captures a successful tool call', () => {
+    const id = captureToolCall(store, 'browser.screenshot', { url: 'https://example.com' }, { data: 'png' });
+    const atom = store.getById(id)!;
+    expect(atom.type).toBe('tool');
+    expect((atom as any).tool_name).toBe('browser.screenshot');
+    expect((atom as any).outcome).toBe('success');
+    expect(atom.confidence).toBe(0.7);
+    expect(atom.fitness_score).toBe(0.8);
+    expect((atom as any).error_signature).toBeNull();
+  });
+
+  it('captures a failed tool call', () => {
+    const id = captureToolCall(store, 'exec.run', { cmd: 'bad' }, null, 'timeout error', 5000);
+    const atom = store.getById(id)!;
+    expect((atom as any).outcome).toBe('failure');
+    expect(atom.confidence).toBe(0.3);
+    expect((atom as any).error_signature).toBe('timeout error');
+    expect((atom as any).latency_ms).toBe(5000);
+  });
+
+  it('captures with null latency', () => {
+    const id = captureToolCall(store, 'test.tool', {}, 'ok');
+    const atom = store.getById(id)!;
+    expect((atom as any).latency_ms).toBeNull();
+  });
+});
+
+describe('captureOutcome', () => {
+  let store: AtomStore;
+
+  beforeEach(() => { store = new AtomStore(':memory:'); });
+  afterEach(() => { store.close(); });
+
+  it('scores a perfect outcome', () => {
+    const signals: OutcomeSignals = {
+      completed_without_error: true,
+      revisited_within_1hr: false,
+      human_accepted: true,
+      convergence_steps: 0,
+      error_free: true,
+    };
+    const id = captureOutcome(store, 'task-1', signals);
+    const atom = store.getById(id)!;
+    // 0.3 + 0.2 + 0.3 + 0.1 + 0.1 = 1.0
+    expect(atom.confidence).toBeCloseTo(1.0);
+  });
+
+  it('scores a complete failure', () => {
+    const signals: OutcomeSignals = {
+      completed_without_error: false,
+      revisited_within_1hr: true,
+      human_accepted: false,
+      convergence_steps: 100,
+      error_free: false,
+    };
+    const id = captureOutcome(store, 'task-2', signals);
+    const atom = store.getById(id)!;
+    // 0 + 0 + 0 + max(0, 0.1*(1-100/20)) + 0 = 0
+    expect(atom.confidence).toBeCloseTo(0.0);
+  });
+
+  it('handles null human_accepted as partial credit', () => {
+    const signals: OutcomeSignals = {
+      completed_without_error: true,
+      revisited_within_1hr: false,
+      human_accepted: null,
+      convergence_steps: 5,
+      error_free: true,
+    };
+    const id = captureOutcome(store, 'task-3', signals);
+    const atom = store.getById(id)!;
+    // 0.3 + 0.2 + 0.15 + 0.1*(1-5/20) + 0.1 = 0.3+0.2+0.15+0.075+0.1 = 0.825
+    expect(atom.confidence).toBeCloseTo(0.825);
+  });
+
+  it('caps convergence contribution at 0', () => {
+    const signals: OutcomeSignals = {
+      completed_without_error: false,
+      revisited_within_1hr: false,
+      human_accepted: null,
+      convergence_steps: 50,
+      error_free: false,
+    };
+    const id = captureOutcome(store, 'task-4', signals);
+    const atom = store.getById(id)!;
+    // 0 + 0.2 + 0.15 + max(0, ...) + 0 = 0.35
+    expect(atom.confidence).toBeCloseTo(0.35);
+  });
+
+  it('stores outcome atoms as context type', () => {
+    const signals: OutcomeSignals = {
+      completed_without_error: true,
+      revisited_within_1hr: false,
+      human_accepted: true,
+      convergence_steps: 0,
+      error_free: true,
+    };
+    const id = captureOutcome(store, 'task-5', signals);
+    const atom = store.getById(id)!;
+    expect(atom.type).toBe('context');
+  });
+});

package/src/__tests__/distill.test.ts

@@ -0,0 +1,83 @@
+import { describe, it, expect } from 'vitest';
+import { distillTrace, BatchDistiller } from '../distill/index.js';
+import type { ToolTrace } from '../distill/index.js';
+import type { KnowledgeAtom } from '../types/index.js';
+
+function makeTrace(overrides?: Partial<ToolTrace>): ToolTrace {
+  return {
+    toolName: 'test_tool',
+    params: { key: 'value' },
+    result: { ok: true },
+    error: null,
+    latencyMs: 100,
+    outcome: 'success',
+    agentId: 'agent-1',
+    timestamp: new Date().toISOString(),
+    ...overrides,
+  };
+}
+
+describe('distillTrace', () => {
+  it('returns null (stub)', async () => {
+    const result = await distillTrace(makeTrace());
+    expect(result).toBeNull();
+  });
+});
+
+describe('BatchDistiller', () => {
+  it('collects traces up to batch size', () => {
+    const bd = new BatchDistiller({ batchSize: 3 });
+    expect(bd.pending).toBe(0);
+    expect(bd.ready).toBe(false);
+
+    bd.add(makeTrace());
+    bd.add(makeTrace());
+    expect(bd.pending).toBe(2);
+    expect(bd.ready).toBe(false);
+
+    const full = bd.add(makeTrace());
+    expect(full).toBe(true);
+    expect(bd.ready).toBe(true);
+    expect(bd.pending).toBe(3);
+  });
+
+  it('flush processes and clears buffer', async () => {
+    const bd = new BatchDistiller({ batchSize: 2 });
+    bd.add(makeTrace());
+    bd.add(makeTrace());
+
+    // Default stub returns null, so results should be empty
+    const atoms = await bd.flush();
+    expect(atoms).toHaveLength(0);
+    expect(bd.pending).toBe(0);
+  });
+
+  it('flush with custom distillFn returns atoms', async () => {
+    const fakeAtom: KnowledgeAtom = {
+      id: 'fake-id', type: 'tool', observation: 'test', context: 'test',
+      confidence: 0.9, fitness_score: 0.8, trust_tier: 'local',
+      source_agent_hash: 'test', created_at: '', updated_at: '', decay_rate: 0.99,
+    };
+    const bd = new BatchDistiller({
+      batchSize: 2,
+      distillFn: async () => fakeAtom,
+    });
+    bd.add(makeTrace());
+    bd.add(makeTrace());
+
+    const atoms = await bd.flush();
+    expect(atoms).toHaveLength(2);
+    expect(atoms[0]).toEqual(fakeAtom);
+  });
+
+  it('drain returns traces without processing', () => {
+    const bd = new BatchDistiller({ batchSize: 5 });
+    bd.add(makeTrace({ toolName: 'a' }));
+    bd.add(makeTrace({ toolName: 'b' }));
+
+    const traces = bd.drain();
+    expect(traces).toHaveLength(2);
+    expect(traces[0]!.toolName).toBe('a');
+    expect(bd.pending).toBe(0);
+  });
+});

package/src/__tests__/fitness.test.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { AtomStore } from '../store/index.js';
+import { computeFitness, recalculateFitness } from '../fitness/index.js';
+
+describe('computeFitness', () => {
+  it('returns 0 for unused atoms', () => {
+    expect(computeFitness(0, 0, 0, null, 10)).toBe(0);
+  });
+
+  it('returns high score for recently used successful atoms', () => {
+    const now = new Date();
+    const score = computeFitness(10, 9, 1, now.toISOString(), 10, now);
+    expect(score).toBeGreaterThan(0.8);
+  });
+
+  it('decays with time', () => {
+    const now = new Date();
+    const recent = computeFitness(5, 5, 0, now.toISOString(), 10, now);
+    const old = computeFitness(5, 5, 0, new Date(now.getTime() - 60 * 86400000).toISOString(), 10, now);
+    expect(recent).toBeGreaterThan(old);
+  });
+
+  it('clamps to [0,1]', () => {
+    const score = computeFitness(100, 100, 0, new Date().toISOString(), 100);
+    expect(score).toBeLessThanOrEqual(1);
+    expect(score).toBeGreaterThanOrEqual(0);
+  });
+});
+
+describe('recalculateFitness', () => {
+  let store: AtomStore;
+
+  beforeEach(() => { store = new AtomStore(':memory:'); });
+  afterEach(() => { store.close(); });
+
+  it('updates fitness scores for all atoms', () => {
+    const atom = store.createAtom({
+      type: 'context',
+      observation: 'test recalc atom',
+      context: '{}',
+      confidence: 0.8,
+      fitness_score: 0.9,
+      trust_tier: 'local',
+      source_agent_hash: 'test',
+      decay_rate: 0.99,
+    });
+
+    store.recordUsage(atom.id, true);
+    store.recordUsage(atom.id, false);
+    store.recordUsage(atom.id, false);
+    recalculateFitness(store);
+
+    const updated = store.getById(atom.id)!;
+    // 3 uses, 1 success / 2 failures → success_ratio ≈ 0.33, so score < 0.9
+    expect(updated.fitness_score).toBeLessThan(0.5);
+    expect(updated.fitness_score).toBeGreaterThan(0);
+  });
+});

package/src/__tests__/retrieval.test.ts

@@ -0,0 +1,83 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { AtomStore } from '../store/index.js';
+import { searchAtoms, getTopAtoms } from '../retrieval/index.js';
+
+describe('retrieval', () => {
+  let store: AtomStore;
+
+  beforeEach(() => {
+    store = new AtomStore(':memory:');
+    // Seed atoms
+    store.createToolAtom({
+      type: 'tool', observation: 'Git push to remote origin succeeded',
+      context: 'CI pipeline', confidence: 0.9, fitness_score: 0.95,
+      trust_tier: 'local', source_agent_hash: 'test', decay_rate: 0.99,
+      tool_name: 'git_push', params_hash: 'abc', outcome: 'success',
+      error_signature: null, latency_ms: 200, reliability_score: 1.0,
+    });
+    store.createToolAtom({
+      type: 'tool', observation: 'NPM install failed with ERESOLVE peer dependency conflict',
+      context: 'package management', confidence: 0.8, fitness_score: 0.3,
+      trust_tier: 'local', source_agent_hash: 'test', decay_rate: 0.99,
+      tool_name: 'npm_install', params_hash: 'def', outcome: 'failure',
+      error_signature: 'ERESOLVE', latency_ms: 5000, reliability_score: 0.0,
+    });
+    store.createToolAtom({
+      type: 'tool', observation: 'Docker build completed with layer caching',
+      context: 'containerization', confidence: 0.85, fitness_score: 0.7,
+      trust_tier: 'local', source_agent_hash: 'test', decay_rate: 0.99,
+      tool_name: 'docker_build', params_hash: 'ghi', outcome: 'success',
+      error_signature: null, latency_ms: 30000, reliability_score: 0.9,
+    });
+  });
+
+  describe('searchAtoms', () => {
+    it('finds atoms matching query', () => {
+      const results = searchAtoms(store, 'git push');
+      expect(results.length).toBeGreaterThanOrEqual(1);
+      expect(results[0]!.observation).toContain('Git push');
+    });
+
+    it('finds atoms by error text', () => {
+      const results = searchAtoms(store, 'ERESOLVE');
+      expect(results.length).toBeGreaterThanOrEqual(1);
+      expect(results[0]!.observation).toContain('ERESOLVE');
+    });
+
+    it('returns empty for no match', () => {
+      const results = searchAtoms(store, 'xyznonexistent');
+      expect(results).toHaveLength(0);
+    });
+
+    it('respects limit', () => {
+      const results = searchAtoms(store, 'tool', 1);
+      expect(results.length).toBeLessThanOrEqual(1);
+    });
+  });
+
+  describe('getTopAtoms', () => {
+    it('returns atoms sorted by fitness_score desc', () => {
+      const results = getTopAtoms(store);
+      expect(results.length).toBe(3);
+      expect(results[0]!.fitness_score).toBeGreaterThanOrEqual(results[1]!.fitness_score);
+      expect(results[1]!.fitness_score).toBeGreaterThanOrEqual(results[2]!.fitness_score);
+    });
+
+    it('filters by type', () => {
+      // Add a non-tool atom
+      store.createAtom({
+        type: 'context', observation: 'Some context note',
+        context: 'test', confidence: 0.5, fitness_score: 0.5,
+        trust_tier: 'local', source_agent_hash: 'test', decay_rate: 0.99,
+      });
+      const tools = getTopAtoms(store, 'tool');
+      expect(tools.every(a => a.type === 'tool')).toBe(true);
+      expect(tools.length).toBe(3);
+    });
+
+    it('respects limit', () => {
+      const results = getTopAtoms(store, undefined, 2);
+      expect(results.length).toBe(2);
+    });
+  });
+});

package/src/__tests__/store.test.ts

@@ -0,0 +1,262 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { AtomStore, jaccardSimilarity } from '../store/index.js';
+import type { CreateAtom, CreateToolAtom, CreateNegativeAtom } from '../types/index.js';
+
+function makeBaseAtom(overrides: Partial<CreateAtom> = {}): CreateAtom {
+  return {
+    type: 'context',
+    observation: 'Test observation',
+    context: '{}',
+    confidence: 0.8,
+    fitness_score: 0.7,
+    trust_tier: 'local',
+    source_agent_hash: 'test-agent',
+    decay_rate: 0.99,
+    ...overrides,
+  };
+}
+
+function makeToolAtom(overrides: Partial<CreateToolAtom> = {}): CreateToolAtom {
+  return {
+    type: 'tool',
+    observation: 'Tool browser.screenshot succeeded',
+    context: '{}',
+    confidence: 0.8,
+    fitness_score: 0.7,
+    trust_tier: 'local',
+    source_agent_hash: 'test-agent',
+    decay_rate: 0.99,
+    tool_name: 'browser.screenshot',
+    params_hash: 'abc123',
+    outcome: 'success',
+    error_signature: null,
+    latency_ms: 150,
+    reliability_score: 0.9,
+    ...overrides,
+  };
+}
+
+function makeNegativeAtom(overrides: Partial<CreateNegativeAtom> = {}): CreateNegativeAtom {
+  return {
+    type: 'negative',
+    observation: 'Never use rm -rf on root',
+    context: '{}',
+    confidence: 0.95,
+    fitness_score: 0.9,
+    trust_tier: 'local',
+    source_agent_hash: 'test-agent',
+    decay_rate: 0.99,
+    anti_pattern: 'rm -rf /',
+    failure_cluster_size: 5,
+    error_type: 'destructive_command',
+    severity: 'critical',
+    ...overrides,
+  };
+}
+
+describe('AtomStore', () => {
+  let store: AtomStore;
+
+  beforeEach(() => {
+    store = new AtomStore(':memory:');
+  });
+
+  afterEach(() => {
+    store.close();
+  });
+
+  describe('CRUD', () => {
+    it('creates and retrieves a base atom', () => {
+      const atom = store.createAtom(makeBaseAtom());
+      expect(atom.id).toBeTruthy();
+      expect(atom.type).toBe('context');
+      expect(atom.created_at).toBeTruthy();
+
+      const fetched = store.getById(atom.id);
+      expect(fetched).toBeTruthy();
+      expect(fetched!.observation).toBe('Test observation');
+    });
+
+    it('creates and retrieves a ToolAtom', () => {
+      const atom = store.createToolAtom(makeToolAtom());
+      expect(atom.tool_name).toBe('browser.screenshot');
+      expect(atom.outcome).toBe('success');
+
+      const fetched = store.getById(atom.id);
+      expect(fetched).toBeTruthy();
+    });
+
+    it('creates and retrieves a NegativeAtom', () => {
+      const atom = store.createNegativeAtom(makeNegativeAtom());
+      expect(atom.anti_pattern).toBe('rm -rf /');
+      expect(atom.severity).toBe('critical');
+    });
+
+    it('deletes an atom', () => {
+      const atom = store.createAtom(makeBaseAtom());
+      expect(store.deleteAtom(atom.id)).toBe(true);
+      expect(store.getById(atom.id)).toBeNull();
+    });
+
+    it('returns false when deleting non-existent', () => {
+      expect(store.deleteAtom('non-existent')).toBe(false);
+    });
+
+    it('returns null for non-existent getById', () => {
+      expect(store.getById('nope')).toBeNull();
+    });
+  });
+
+  describe('Queries', () => {
+    it('queryByType returns atoms of correct type', () => {
+      store.createAtom(makeBaseAtom({ type: 'context', observation: 'ctx 1' }));
+      store.createAtom(makeBaseAtom({ type: 'pattern', observation: 'pat 1' }));
+      store.createToolAtom(makeToolAtom({ observation: 'tool unique obs 1' }));
+
+      expect(store.queryByType('context')).toHaveLength(1);
+      expect(store.queryByType('tool')).toHaveLength(1);
+      expect(store.queryByType('pattern')).toHaveLength(1);
+    });
+
+    it('queryByToolName filters correctly', () => {
+      store.createToolAtom(makeToolAtom({ tool_name: 'browser.screenshot', observation: 'unique obs A' }));
+      store.createToolAtom(makeToolAtom({ tool_name: 'exec.run', observation: 'unique obs B' }));
+
+      expect(store.queryByToolName('browser.screenshot')).toHaveLength(1);
+      expect(store.queryByToolName('exec.run')).toHaveLength(1);
+      expect(store.queryByToolName('nonexistent')).toHaveLength(0);
+    });
+
+    it('queryByConfidence returns atoms above threshold', () => {
+      store.createAtom(makeBaseAtom({ confidence: 0.3, observation: 'low conf unique' }));
+      store.createAtom(makeBaseAtom({ confidence: 0.9, observation: 'high conf unique' }));
+
+      const high = store.queryByConfidence(0.8);
+      expect(high).toHaveLength(1);
+      expect(high[0]!.confidence).toBe(0.9);
+    });
+
+    it('search matches observation text', () => {
+      store.createAtom(makeBaseAtom({ observation: 'screenshot fails on lazy loaded pages' }));
+      store.createAtom(makeBaseAtom({ observation: 'exec works fine always' }));
+
+      const results = store.search('screenshot');
+      expect(results).toHaveLength(1);
+      expect(results[0]!.observation).toContain('screenshot');
+    });
+
+    it('getAll returns all atoms', () => {
+      store.createAtom(makeBaseAtom({ observation: 'unique atom one' }));
+      store.createAtom(makeBaseAtom({ observation: 'unique atom two' }));
+      expect(store.getAll()).toHaveLength(2);
+    });
+  });
+
+  describe('Decay', () => {
+    it('applyDecay reduces fitness scores', () => {
+      const atom = store.createAtom(makeBaseAtom({ fitness_score: 1.0 }));
+      const changed = store.applyDecay();
+      expect(changed).toBe(1);
+
+      const updated = store.getById(atom.id)!;
+      expect(updated.fitness_score).toBeCloseTo(0.99);
+    });
+
+    it('applyDecay does not affect zero-fitness atoms', () => {
+      store.createAtom(makeBaseAtom({ fitness_score: 0.0, observation: 'zero fitness unique' }));
+      const changed = store.applyDecay();
+      expect(changed).toBe(0);
+    });
+  });
+
+  describe('Fitness & Usage', () => {
+    it('updateFitnessScore changes score', () => {
+      const atom = store.createAtom(makeBaseAtom());
+      store.updateFitnessScore(atom.id, 0.5);
+      expect(store.getById(atom.id)!.fitness_score).toBe(0.5);
+    });
+
+    it('recordUsage increments counters', () => {
+      const atom = store.createAtom(makeBaseAtom());
+      store.recordUsage(atom.id, true);
+      store.recordUsage(atom.id, true);
+      store.recordUsage(atom.id, false);
+
+      const row = store.getById(atom.id) as any;
+      expect(row.use_count).toBe(3);
+      expect(row.success_after_use).toBe(2);
+      expect(row.failure_after_use).toBe(1);
+      expect(row.last_used).toBeTruthy();
+    });
+  });
+
+  describe('Dedup', () => {
+    it('merges atoms with very similar observations', () => {
+      const a1 = store.createAtom(makeBaseAtom({ observation: 'browser screenshot fails on lazy loaded pages', fitness_score: 0.5 }));
+      const a2 = store.createAtom(makeBaseAtom({ observation: 'browser screenshot fails on lazy loaded pages', fitness_score: 0.8 }));
+
+      // Should have merged — same ID returned
+      expect(a2.id).toBe(a1.id);
+      const row = store.getById(a1.id) as any;
+      expect(row.evidence_count).toBe(2);
+      expect(row.fitness_score).toBe(0.8); // keeps higher
+    });
+
+    it('does not merge dissimilar observations', () => {
+      store.createAtom(makeBaseAtom({ observation: 'browser screenshot fails on lazy loaded pages' }));
+      store.createAtom(makeBaseAtom({ observation: 'exec command runs perfectly fine every time' }));
+      expect(store.getAll()).toHaveLength(2);
+    });
+
+    it('findSimilar returns matches above threshold', () => {
+      store.createAtom(makeBaseAtom({ observation: 'the quick brown fox jumps' }));
+      store.createAtom(makeBaseAtom({ observation: 'completely different text about cooking recipes' }));
+
+      const similar = store.findSimilar('the quick brown fox jumps over', 0.5);
+      expect(similar.length).toBeGreaterThanOrEqual(1);
+    });
+  });
+
+  describe('Validation', () => {
+    it('rejects invalid confidence', () => {
+      expect(() => store.createAtom(makeBaseAtom({ confidence: 1.5 }))).toThrow();
+      expect(() => store.createAtom(makeBaseAtom({ confidence: -0.1 }))).toThrow();
+    });
+
+    it('rejects invalid fitness_score', () => {
+      expect(() => store.createAtom(makeBaseAtom({ fitness_score: 2.0 }))).toThrow();
+    });
+
+    it('rejects empty observation', () => {
+      expect(() => store.createAtom(makeBaseAtom({ observation: '' }))).toThrow();
+    });
+
+    it('rejects invalid tool atom', () => {
+      expect(() => store.createToolAtom({ ...makeToolAtom(), tool_name: '' })).toThrow();
+    });
+
+    it('rejects invalid negative atom', () => {
+      expect(() => store.createNegativeAtom({ ...makeNegativeAtom(), severity: 'invalid' as any })).toThrow();
+    });
+  });
+});
+
+describe('jaccardSimilarity', () => {
+  it('identical strings return 1', () => {
+    expect(jaccardSimilarity('hello world', 'hello world')).toBe(1);
+  });
+
+  it('completely different strings return low score', () => {
+    expect(jaccardSimilarity('apple banana cherry', 'xray yankee zulu')).toBe(0);
+  });
+
+  it('empty strings return 1', () => {
+    expect(jaccardSimilarity('', '')).toBe(1);
+  });
+
+  it('partially overlapping strings return intermediate score', () => {
+    const score = jaccardSimilarity('the quick brown fox', 'the quick red fox');
+    expect(score).toBeGreaterThan(0.2);
+    expect(score).toBeLessThan(1);
+  });
+});

package/src/__tests__/types.test.ts

@@ -0,0 +1,92 @@
+import { describe, it, expect } from 'vitest';
+import { CreateAtomSchema, CreateToolAtomSchema, CreateNegativeAtomSchema, OutcomeSignalsSchema } from '../validation/index.js';
+
+describe('CreateAtomSchema', () => {
+  const valid = {
+    type: 'context', observation: 'test', context: '{}',
+    confidence: 0.5, fitness_score: 0.5, trust_tier: 'local',
+    source_agent_hash: 'hash', decay_rate: 0.99,
+  };
+
+  it('accepts valid data', () => {
+    expect(() => CreateAtomSchema.parse(valid)).not.toThrow();
+  });
+
+  it('rejects confidence > 1', () => {
+    expect(() => CreateAtomSchema.parse({ ...valid, confidence: 1.1 })).toThrow();
+  });
+
+  it('rejects confidence < 0', () => {
+    expect(() => CreateAtomSchema.parse({ ...valid, confidence: -0.1 })).toThrow();
+  });
+
+  it('rejects empty observation', () => {
+    expect(() => CreateAtomSchema.parse({ ...valid, observation: '' })).toThrow();
+  });
+
+  it('rejects invalid type', () => {
+    expect(() => CreateAtomSchema.parse({ ...valid, type: 'invalid' })).toThrow();
+  });
+
+  it('rejects invalid trust tier', () => {
+    expect(() => CreateAtomSchema.parse({ ...valid, trust_tier: 'bogus' })).toThrow();
+  });
+});
+
+describe('CreateToolAtomSchema', () => {
+  const valid = {
+    type: 'tool', observation: 'test', context: '{}',
+    confidence: 0.5, fitness_score: 0.5, trust_tier: 'local',
+    source_agent_hash: 'hash', decay_rate: 0.99,
+    tool_name: 'browser.click', params_hash: 'abc',
+    outcome: 'success', error_signature: null,
+    latency_ms: null, reliability_score: 1.0,
+  };
+
+  it('accepts valid tool atom', () => {
+    expect(() => CreateToolAtomSchema.parse(valid)).not.toThrow();
+  });
+
+  it('rejects missing tool_name', () => {
+    const { tool_name, ...rest } = valid;
+    expect(() => CreateToolAtomSchema.parse(rest)).toThrow();
+  });
+
+  it('rejects invalid outcome', () => {
+    expect(() => CreateToolAtomSchema.parse({ ...valid, outcome: 'maybe' })).toThrow();
+  });
+});
+
+describe('CreateNegativeAtomSchema', () => {
+  const valid = {
+    type: 'negative', observation: 'test', context: '{}',
+    confidence: 0.5, fitness_score: 0.5, trust_tier: 'local',
+    source_agent_hash: 'hash', decay_rate: 0.99,
+    anti_pattern: 'bad thing', failure_cluster_size: 3,
+    error_type: 'crash', severity: 'high',
+  };
+
+  it('accepts valid negative atom', () => {
+    expect(() => CreateNegativeAtomSchema.parse(valid)).not.toThrow();
+  });
+
+  it('rejects invalid severity', () => {
+    expect(() => CreateNegativeAtomSchema.parse({ ...valid, severity: 'extreme' })).toThrow();
+  });
+});
+
+describe('OutcomeSignalsSchema', () => {
+  it('accepts valid signals', () => {
+    expect(() => OutcomeSignalsSchema.parse({
+      completed_without_error: true,
+      revisited_within_1hr: false,
+      human_accepted: null,
+      convergence_steps: 5,
+      error_free: true,
+    })).not.toThrow();
+  });
+
+  it('rejects missing fields', () => {
+    expect(() => OutcomeSignalsSchema.parse({})).toThrow();
+  });
+});