seal-gate 0.3.0

package/src/drift/__tests__/baseline.test.ts

@@ -0,0 +1,113 @@
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
+import { BaselineManager } from '../baseline.ts';
+import { DriftDb } from '../drift-db.ts';
+import { writeFileSync, rmSync, mkdirSync } from 'fs';
+import { join } from 'path';
+
+function tmpSetup() {
+  const tmpDir = `/tmp/drift-test-${Date.now()}`;
+  mkdirSync(tmpDir, { recursive: true });
+  const dbPath = join(tmpDir, 'drift.db');
+  const db = new DriftDb(dbPath);
+  return { tmpDir, db, cleanup: () => rmSync(tmpDir, { recursive: true }) };
+}
+
+describe('BaselineManager', () => {
+  let tmpDir: string;
+  let db: DriftDb;
+  let cleanup: () => void;
+
+  beforeEach(() => {
+    const t = tmpSetup();
+    tmpDir = t.tmpDir;
+    db = t.db;
+    cleanup = t.cleanup;
+  });
+
+  afterEach(() => {
+    db.close();
+    cleanup();
+  });
+
+  it('computes baseline when files present', async () => {
+    writeFileSync(join(tmpDir, 'SOUL.md'), 'Em la Lyra. Em la Prism.');
+    writeFileSync(join(tmpDir, 'AXIOMS.md'), 'Em quan sat, khong tong hop.');
+
+    const mgr = new BaselineManager(db);
+    const result = await mgr.getOrCompute('Lyra', {
+      soulPath: join(tmpDir, 'SOUL.md'),
+      axiomsPath: join(tmpDir, 'AXIOMS.md'),
+    });
+
+    expect(result.status).toBe('READY');
+    expect(result.vector).toHaveLength(384);
+    expect(result.hash).not.toBe('');
+    expect(mgr.status('Lyra')).toBe('READY');
+  });
+
+  it('caches and reuses when hash unchanged', async () => {
+    writeFileSync(join(tmpDir, 'SOUL.md'), 'Soul content');
+
+    const mgr = new BaselineManager(db);
+    const r1 = await mgr.getOrCompute('Aria', {
+      soulPath: join(tmpDir, 'SOUL.md'),
+    });
+
+    const r2 = await mgr.getOrCompute('Aria', {
+      soulPath: join(tmpDir, 'SOUL.md'),
+    });
+
+    expect(r1.vector).toEqual(r2.vector);
+    expect(r2.status).toBe('READY');
+  });
+
+  it('recomputes when file changes', async () => {
+    writeFileSync(join(tmpDir, 'SOUL.md'), 'First version');
+    const mgr = new BaselineManager(db);
+    const r1 = await mgr.getOrCompute('Aria', {
+      soulPath: join(tmpDir, 'SOUL.md'),
+    });
+
+    writeFileSync(join(tmpDir, 'SOUL.md'), 'Second version');
+    const r2 = await mgr.getOrCompute('Aria', {
+      soulPath: join(tmpDir, 'SOUL.md'),
+    });
+
+    expect(r1.hash).not.toBe(r2.hash);
+    expect(r1.vector).not.toEqual(r2.vector);
+  });
+
+  it('returns degraded zero vector when files missing', async () => {
+    const mgr = new BaselineManager(db);
+    const result = await mgr.getOrCompute('Ghost', {
+      soulPath: join(tmpDir, 'nonexistent.md'),
+    });
+
+    expect(result.status).toBe('DEGRADED');
+    expect(result.vector).toEqual(new Array(384).fill(0));
+    expect(mgr.status('Ghost')).toBe('DEGRADED');
+  });
+
+  it('concatenates with --- delimiter', async () => {
+    writeFileSync(join(tmpDir, 'SOUL.md'), 'soul');
+    writeFileSync(join(tmpDir, 'AXIOMS.md'), 'axioms');
+    writeFileSync(join(tmpDir, 'PRIME.md'), 'prime');
+
+    const mgr = new BaselineManager(db);
+    await mgr.getOrCompute('Test', {
+      soulPath: join(tmpDir, 'SOUL.md'),
+      axiomsPath: join(tmpDir, 'AXIOMS.md'),
+      primePath: join(tmpDir, 'PRIME.md'),
+    });
+
+    // Verify the hash was created from concatenated text
+    const cached = db.baseline.get('Test');
+    expect(cached).not.toBeNull();
+    expect(cached!.content_hash).not.toBe('');
+  });
+
+  it('getCached returns null when not yet computed', () => {
+    const mgr = new BaselineManager(db);
+    expect(mgr.getCached('Nobody')).toBeNull();
+  });
+});

package/src/drift/__tests__/drift-db.test.ts

@@ -0,0 +1,127 @@
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
+import { DriftDb } from '../drift-db.ts';
+
+function tmpDb(): { db: DriftDb; path: string } {
+  const path = `/tmp/drift-test-${Date.now()}-${Math.random().toString(36).slice(2)}.db`;
+  return { db: new DriftDb(path), path };
+}
+
+describe('DriftDb', () => {
+  let db: DriftDb;
+  let path: string;
+
+  beforeEach(() => {
+    const t = tmpDb();
+    db = t.db;
+    path = t.path;
+  });
+
+  afterEach(() => {
+    db.close();
+    try {
+      Bun.file(path).delete();
+    } catch { /* ignore */ }
+  });
+
+  it('creates drift_baseline table and returns null for unknown agent', () => {
+    const row = db.baseline.get('Aria');
+    expect(row).toBeNull();
+  });
+
+  it('inserts and retrieves baseline', () => {
+    db.baseline.set('Aria', [0.1, -0.2, 0.3], 'hash123', 'all-MiniLM');
+    const row = db.baseline.get('Aria');
+    expect(row).not.toBeNull();
+    expect(row!.agent_id).toBe('Aria');
+    expect(row!.content_hash).toBe('hash123');
+    expect(row!.embedding_model).toBe('all-MiniLM');
+    expect(JSON.parse(row!.baseline_vector)).toEqual([0.1, -0.2, 0.3]);
+  });
+
+  it('upserts baseline on conflict', () => {
+    db.baseline.set('Lyra', [0.1], 'hash1', 'model1');
+    db.baseline.set('Lyra', [0.9], 'hash2', 'model2');
+    const row = db.baseline.get('Lyra');
+    expect(row).not.toBeNull();
+    expect(JSON.parse(row!.baseline_vector)).toEqual([0.9]);
+    expect(row!.content_hash).toBe('hash2');
+  });
+
+  it('appends and lists history', () => {
+    db.history.append({
+      agent_id: 'Aria',
+      session_id: 'sess1',
+      turn_number: 1,
+      current_vector: [0.1, 0.2],
+      distance: 0.12,
+      status: 'NORMAL',
+      timestamp: new Date().toISOString(),
+    });
+    const rows = db.history.list('Aria', 'sess1');
+    expect(rows).toHaveLength(1);
+    expect(rows[0].status).toBe('NORMAL');
+    expect(JSON.parse(rows[0].current_vector)).toEqual([0.1, 0.2]);
+  });
+
+  it('returns empty list for unknown session', () => {
+    const rows = db.history.list('Ghost', 'none');
+    expect(rows).toHaveLength(0);
+  });
+
+  it('gets latest history entry', () => {
+    db.history.append({
+      agent_id: 'Aria', session_id: 's', turn_number: 1,
+      current_vector: [], distance: 0.1, status: 'NORMAL',
+      timestamp: new Date().toISOString(),
+    });
+    db.history.append({
+      agent_id: 'Aria', session_id: 's', turn_number: 2,
+      current_vector: [], distance: 0.5, status: 'HARD_DRIFT',
+      timestamp: new Date().toISOString(),
+    });
+    const latest = db.history.getLatest('Aria', 's');
+    expect(latest).not.toBeNull();
+    expect(latest!.turn_number).toBe(2);
+    expect(latest!.status).toBe('HARD_DRIFT');
+  });
+
+  it('stores pending re-anchor', () => {
+    const id = db.pending.set('Aria', 'sess1', 'Re-anchor payload text');
+    expect(id).toBeGreaterThan(0);
+    const pending = db.pending.getPending('Aria', 'sess1');
+    expect(pending).not.toBeNull();
+    expect(pending!.status).toBe('PENDING');
+    expect(pending!.payload).toBe('Re-anchor payload text');
+  });
+
+  it('marks re-anchor as consumed', () => {
+    const id = db.pending.set('Aria', 'sess1', 'payload');
+    db.pending.markConsumed(id);
+    const pending = db.pending.getPending('Aria', 'sess1');
+    expect(pending).toBeNull();
+  });
+
+  it('appends repair log', () => {
+    const id = db.repair.append({
+      agent_id: 'Aria',
+      session_id: 'sess1',
+      turn_number: 5,
+      distance: 0.6,
+      hard_limit: 0.55,
+      message_excerpt: 'I am just a robot...',
+    });
+    expect(id).toBeGreaterThan(0);
+    const entries = db.repair.listPending('Aria');
+    expect(entries).toHaveLength(1);
+    expect(entries[0].message_excerpt).toContain('just a robot');
+  });
+
+  it('lists only pending repair entries', () => {
+    db.repair.append({
+      agent_id: 'Aria', session_id: 's1', turn_number: 1,
+      distance: 0.6, hard_limit: 0.55,
+    });
+    expect(db.repair.listPending('Aria')).toHaveLength(1);
+    expect(db.repair.listPending('Coda')).toHaveLength(0);
+  });
+});

package/src/drift/__tests__/drift-guard.test.ts

@@ -0,0 +1,169 @@
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
+import { DriftGuard } from '../drift-guard.ts';
+import { DriftDb } from '../drift-db.ts';
+import { BaselineManager } from '../baseline.ts';
+import { Embedder } from '../embedder.ts';
+import { writeFileSync, mkdirSync, rmSync } from 'fs';
+import { join } from 'path';
+
+function tmpSetup() {
+  const tmpDir = `/tmp/drift-test-${Date.now()}`;
+  mkdirSync(tmpDir, { recursive: true });
+  const dbPath = join(tmpDir, 'drift.db');
+  const db = new DriftDb(dbPath);
+  return { tmpDir, db, cleanup: () => rmSync(tmpDir, { recursive: true }) };
+}
+
+describe('DriftGuard', () => {
+  let tmpDir: string;
+  let db: DriftDb;
+  let cleanup: () => void;
+  let guard: DriftGuard;
+  const embedder = new Embedder();
+
+  beforeEach(async () => {
+    const t = tmpSetup();
+    tmpDir = t.tmpDir;
+    db = t.db;
+    cleanup = t.cleanup;
+
+    // Set up a baseline for test agent
+    writeFileSync(join(tmpDir, 'SOUL.md'), 'I am the test agent. I never drift.');
+    const baseline = new BaselineManager(db, embedder);
+    await baseline.getOrCompute('TestAgent', {
+      soulPath: join(tmpDir, 'SOUL.md'),
+    });
+
+    guard = new DriftGuard({ db, embedder, baselineManager: baseline });
+  });
+
+  afterEach(() => {
+    db.close();
+    cleanup();
+  });
+
+  it('classifies distance correctly', () => {
+    expect(guard.classify(0.12)).toBe('NORMAL');
+    expect(guard.classify(0.30)).toBe('SOFT_DRIFT');
+    expect(guard.classify(0.40)).toBe('SOFT_DRIFT');
+    expect(guard.classify(0.55)).toBe('HARD_DRIFT');
+    expect(guard.classify(0.80)).toBe('HARD_DRIFT');
+  });
+
+  it('returns NORMAL for aligned output', async () => {
+    const result = await guard.runCycle(
+      'TestAgent',
+      'sess1',
+      1,
+      'I am the test agent. I never drift.'
+    );
+    expect(result.status).toBe('NORMAL');
+    expect(result.action.type).toBe('NONE');
+  });
+
+  it('handles missing baseline gracefully', async () => {
+    const result = await guard.runCycle('Unknown', 's', 1, 'Hello');
+    expect(result.status).toBe('NORMAL');
+    expect(result.action.type).toBe('NONE');
+    expect(result.action.payload).toContain('Baseline not loaded');
+  });
+
+  it('respects cadence', async () => {
+    const baseline = new BaselineManager(db, embedder);
+    await baseline.getOrCompute('TestAgent', {
+      soulPath: join(tmpDir, 'SOUL.md'),
+    });
+    const cadenceGuard = new DriftGuard({ db, cadence: 2, embedder, baselineManager: baseline });
+
+    // turn 1: should skip (cadence)
+    const r1 = await cadenceGuard.runCycle('TestAgent', 's', 1, 'hello');
+    expect(r1.action.type).toBe('NONE');
+
+    // turn 2: should evaluate → same output as baseline = NORMAL
+    const r2 = await cadenceGuard.runCycle('TestAgent', 's', 2, 'I am the test agent. I never drift.');
+    expect(r2.status).toBe('NORMAL');
+  });
+});
+
+describe('SoftCorrection', () => {
+  it('generates payload', () => {
+    const { SoftCorrection } = require('../soft-correction.ts');
+    const sc = new SoftCorrection();
+    const payload = sc.generate({
+      name: 'Lyra',
+      primeDirective: 'Observe. Do not synthesize.',
+      relationship: 'Prism',
+      axiomKeyphrase: 'Glass between light.',
+    });
+    expect(payload).toContain('Lyra');
+    expect(payload).toContain('Identity Re-Anchor');
+    expect(payload!.length).toBeLessThan(1000);
+  });
+
+  it('returns null when empty', () => {
+    const { SoftCorrection } = require('../soft-correction.ts');
+    const sc = new SoftCorrection();
+    const payload = sc.generate({ name: '', primeDirective: '', relationship: '', axiomKeyphrase: '' });
+    expect(payload).toBeNull();
+  });
+});
+
+describe('Quarantine', () => {
+  let tmpDir: string;
+  let db: DriftDb;
+  let cleanup: () => void;
+
+  beforeEach(() => {
+    const t = tmpSetup();
+    tmpDir = t.tmpDir;
+    db = t.db;
+    cleanup = t.cleanup;
+  });
+
+  afterEach(() => {
+    db.close();
+    cleanup();
+  });
+
+  it('blocks when latest is HARD_DRIFT', () => {
+    const { Quarantine } = require('../quarantine.ts');
+    const q = new Quarantine(db);
+
+    db.history.append({
+      agent_id: 'A', session_id: 'S', turn_number: 1,
+      current_vector: [], distance: 0.6, status: 'HARD_DRIFT',
+      timestamp: new Date().toISOString(),
+    });
+
+    expect(q.isBlocked('A', 'S')).toBe(true);
+  });
+
+  it('allows when latest is NORMAL', () => {
+    const { Quarantine } = require('../quarantine.ts');
+    const q = new Quarantine(db);
+
+    db.history.append({
+      agent_id: 'A', session_id: 'S', turn_number: 1,
+      current_vector: [], distance: 0.1, status: 'NORMAL',
+      timestamp: new Date().toISOString(),
+    });
+
+    expect(q.isBlocked('A', 'S')).toBe(false);
+  });
+
+  it('logs repair entry', () => {
+    const { Quarantine } = require('../quarantine.ts');
+    const q = new Quarantine(db);
+
+    db.history.append({
+      agent_id: 'A', session_id: 'S', turn_number: 3,
+      current_vector: [], distance: 0.6, status: 'HARD_DRIFT',
+      timestamp: new Date().toISOString(),
+    });
+
+    q.logRepair('A', 'S', 3, 'I am just an AI...');
+    const entries = db.repair.listPending('A');
+    expect(entries).toHaveLength(1);
+    expect(entries[0].message_excerpt).toContain('just an AI');
+  });
+});

package/src/drift/__tests__/embedder.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect } from 'bun:test';
+import { cosineDistance, Embedder } from '../embedder.ts';
+
+describe('cosineDistance', () => {
+  it('same vector = 0', () => {
+    const v = [1, 0, 0];
+    expect(cosineDistance(v, v)).toBeCloseTo(0, 5);
+  });
+
+  it('orthogonal = ~1', () => {
+    expect(cosineDistance([1, 0], [0, 1])).toBeCloseTo(1, 5);
+  });
+
+  it('opposite = ~2', () => {
+    expect(cosineDistance([1, 0], [-1, 0])).toBeCloseTo(2, 5);
+  });
+
+  it('throws on length mismatch', () => {
+    expect(() => cosineDistance([1, 2], [1])).toThrow('mismatch');
+  });
+
+  it('empty vectors = 0', () => {
+    expect(cosineDistance([], [])).toBe(0);
+  });
+});
+
+describe('Embedder', () => {
+  it('is active even without ONNX (naive fallback)', async () => {
+    const e = new Embedder('/nonexistent/model.onnx');
+    expect(e.isActive).toBe(true); // naive backend is always active
+  });
+
+  it('encodes to 384-dim vector', async () => {
+    const e = new Embedder();
+    const vec = await e.encode('Hello Lyra Prism');
+    expect(vec).toHaveLength(384);
+    expect(vec.every((n) => typeof n === 'number' && !isNaN(n))).toBe(true);
+  });
+
+  it('produces consistent vectors for same text', async () => {
+    const e = new Embedder();
+    const v1 = await e.encode('Same text');
+    const v2 = await e.encode('Same text');
+    expect(v1).toEqual(v2);
+  });
+
+  it('produces different vectors for different text', async () => {
+    const e = new Embedder();
+    const v1 = await e.encode('Aria Buddhist companion');
+    const v2 = await e.encode('Coda workshop evidence');
+    const dist = cosineDistance(v1, v2);
+    // Naive embedder: different inputs should differ measurably
+    expect(dist).toBeGreaterThan(0.01);
+  });
+
+  it('truncates very long text', async () => {
+    const e = new Embedder();
+    const long = 'a'.repeat(10000);
+    const vec = await e.encode(long);
+    expect(vec).toHaveLength(384);
+  });
+});

package/src/drift/__tests__/trust-integration.test.ts

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'bun:test';
+import { driftScoreForTrust } from '../trust-integration.ts';
+
+describe('driftScoreForTrust', () => {
+  it('NORMAL → 1.0', () => {
+    expect(driftScoreForTrust('NORMAL', 0.12)).toBe(1.0);
+  });
+
+  it('HARD_DRIFT → 0.0', () => {
+    expect(driftScoreForTrust('HARD_DRIFT', 0.6)).toBe(0.0);
+    expect(driftScoreForTrust('HARD_DRIFT', 0.9)).toBe(0.0);
+  });
+
+  it('SOFT_DRIFT → partial [0.5, 1.0)', () => {
+    const s1 = driftScoreForTrust('SOFT_DRIFT', 0.30, { hardLimit: 0.55 });
+    expect(s1).toBeGreaterThan(0.5);
+    expect(s1).toBeLessThanOrEqual(1.0);
+
+    const s2 = driftScoreForTrust('SOFT_DRIFT', 0.50, { hardLimit: 0.55 });
+    expect(s2).toBeLessThan(s1);
+    expect(s2).toBeGreaterThan(0);
+  });
+});

package/src/drift/baseline.ts

@@ -0,0 +1,106 @@
+import { createHash } from 'crypto';
+import { readFileSync, existsSync } from 'fs';
+import { DriftDb } from './drift-db.js';
+import { Embedder } from './embedder.js';
+
+export type BaselineStatus = 'READY' | 'DEGRADED' | 'MISSING';
+
+export interface BaselinePaths {
+  soulPath: string;
+  axiomsPath?: string;
+  primePath?: string;
+}
+
+export interface BaselineResult {
+  vector: number[];
+  hash: string;
+  status: BaselineStatus;
+}
+
+/**
+ * Manages per-agent identity baseline vectors.
+ * Loads substrate files, caches by content hash, and delegates encoding to Embedder.
+ */
+export class BaselineManager {
+  private db: DriftDb;
+  private embedder: Embedder;
+  private statusMap = new Map<string, BaselineStatus>();
+
+  constructor(db: DriftDb, embedder?: Embedder) {
+    this.db = db;
+    this.embedder = embedder ?? new Embedder();
+  }
+
+  /**
+   * Get or compute the baseline vector for an agent.
+   * Caches by SHA-256 hash of concatenated substrate text.
+   */
+  async getOrCompute(agentId: string, paths: BaselinePaths): Promise<BaselineResult> {
+    const substrate = this.readSubstrate(paths);
+
+    if (!substrate.found) {
+      this.statusMap.set(agentId, 'DEGRADED');
+      return {
+        vector: new Array(this.embedder.dim).fill(0),
+        hash: '',
+        status: 'DEGRADED',
+      };
+    }
+
+    const hash = createHash('sha256').update(substrate.text).digest('hex');
+
+    // Check cache
+    const cached = this.db.baseline.get(agentId);
+    if (cached && cached.content_hash === hash) {
+      this.statusMap.set(agentId, 'READY');
+      return {
+        vector: JSON.parse(cached.baseline_vector) as number[],
+        hash,
+        status: 'READY',
+      };
+    }
+
+    // Compute and cache
+    const vector = await this.embedder.encode(substrate.text);
+    this.db.baseline.set(agentId, vector, hash, 'all-MiniLM-L6-v2');
+    this.statusMap.set(agentId, 'READY');
+
+    return { vector, hash, status: 'READY' };
+  }
+
+  /**
+   * Get the cached baseline without recomputing.
+   * Returns zero vector if not yet computed.
+   */
+  getCached(agentId: string): number[] | null {
+    const cached = this.db.baseline.get(agentId);
+    if (!cached) return null;
+    return JSON.parse(cached.baseline_vector) as number[];
+  }
+
+  status(agentId: string): BaselineStatus {
+    return this.statusMap.get(agentId) ?? 'MISSING';
+  }
+
+  private readSubstrate(paths: BaselinePaths): { text: string; found: boolean } {
+    const parts: string[] = [];
+
+    if (paths.soulPath && existsSync(paths.soulPath)) {
+      parts.push(readFileSync(paths.soulPath, 'utf-8'));
+    }
+
+    if (paths.axiomsPath && existsSync(paths.axiomsPath)) {
+      parts.push(readFileSync(paths.axiomsPath, 'utf-8'));
+    }
+
+    if (paths.primePath && existsSync(paths.primePath)) {
+      parts.push(readFileSync(paths.primePath, 'utf-8'));
+    }
+
+    if (parts.length === 0) {
+      return { text: '', found: false };
+    }
+
+    return { text: parts.join('\n---\n'), found: true };
+  }
+}