@hivemind-os/collective-core 0.2.0

package/tests/reputation/score-calculator.test.ts

@@ -0,0 +1,104 @@
+import { describe, expect, it } from 'vitest';
+
+import { PaymentRail, type AgentCard, type ReputationEvent } from '@hivemind-os/collective-types';
+
+import { ReputationScoreCalculator } from '../../src/index.js';
+
+function createAgent(overrides: Partial<AgentCard> = {}): AgentCard {
+  return {
+    id: '0xagent-1',
+    owner: '0xowner',
+    did: 'did:mesh:agent-1' as AgentCard['did'],
+    name: 'Agent One',
+    description: 'Helpful agent',
+    capabilities: [
+      {
+        name: 'echo',
+        description: 'Echo input',
+        version: '1.0.0',
+        pricing: {
+          rail: PaymentRail.SUI_ESCROW,
+          amount: 5n,
+          currency: 'MIST',
+        },
+      },
+    ],
+    active: true,
+    version: 1,
+    registeredAt: 1_000,
+    updatedAt: 2_000,
+    totalTasksCompleted: 4,
+    totalTasksFailed: 1,
+    totalTasksDisputed: 1,
+    totalEarningsMist: 50n,
+    ...overrides,
+  };
+}
+
+function createEvent(overrides: Partial<ReputationEvent> = {}): ReputationEvent {
+  return {
+    eventId: 'event-1',
+    type: 'task_completion',
+    subject: 'did:mesh:agent-1',
+    author: 'did:mesh:requester',
+    taskId: 'task-1',
+    outcome: 'success',
+    capability: 'echo',
+    latencyMs: 100,
+    paymentAmount: { amount: '25', currency: 'MIST' },
+    timestamp: new Date(3_000).toISOString(),
+    nonce: 'nonce-1',
+    signature: 'signature-1',
+    ...overrides,
+  };
+}
+
+describe('ReputationScoreCalculator', () => {
+  it('computes a score from on-chain counters and events', () => {
+    const calculator = new ReputationScoreCalculator();
+    const score = calculator.computeScore(createAgent(), [
+      createEvent(),
+      createEvent({ eventId: 'event-2', outcome: 'failure', type: 'task_failure', latencyMs: 300 }),
+      createEvent({ eventId: 'event-3', type: 'dispute_opened', outcome: 'disputed', latencyMs: undefined }),
+    ]);
+
+    expect(score.successRate).toBeCloseTo(0.8);
+    expect(score.totalTasks).toBe(5);
+    expect(score.totalDisputes).toBe(1);
+    expect(score.averageLatencyMs).toBe(200);
+    expect(score.totalEarningsMist).toBe(75n);
+    expect(score.stakeAmount).toBe(0n);
+    expect(score.capabilityScores.echo?.taskCount).toBe(2);
+  });
+
+  it('ranks agents by reputation', () => {
+    const calculator = new ReputationScoreCalculator();
+    const stronger = createAgent();
+    const weaker = createAgent({ id: '0xagent-2', did: 'did:mesh:agent-2' as AgentCard['did'], totalTasksCompleted: 1, totalTasksFailed: 2, totalEarningsMist: 1n });
+    const scores = new Map([
+      [stronger.did, calculator.computeScore(stronger, [])],
+      [weaker.did, calculator.computeScore(weaker, [])],
+    ]);
+
+    expect(calculator.rankByReputation([weaker, stronger], scores).map((agent) => agent.did)).toEqual([
+      stronger.did,
+      weaker.did,
+    ]);
+  });
+
+  it('uses stake as a reputation tiebreaker', () => {
+    const calculator = new ReputationScoreCalculator();
+    const staked = createAgent({ stakeMist: 10_000_000_000n, hasStake: true });
+    const unstaked = createAgent({ id: '0xagent-2', did: 'did:mesh:agent-2' as AgentCard['did'] });
+    const scores = new Map([
+      [staked.did, calculator.computeScore(staked, [])],
+      [unstaked.did, calculator.computeScore(unstaked, [])],
+    ]);
+
+    expect(calculator.rankByReputation([unstaked, staked], scores).map((agent) => agent.did)).toEqual([
+      staked.did,
+      unstaked.did,
+    ]);
+    expect(scores.get(staked.did)?.stakeAmount).toBe(10_000_000_000n);
+  });
+});

package/tests/reputation/store.test.ts

@@ -0,0 +1,94 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, rm } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+import Database from 'better-sqlite3';
+import { afterEach, describe, expect, it } from 'vitest';
+
+import type { ReputationEvent } from '@hivemind-os/collective-types';
+
+import { ReputationStore } from '../../src/index.js';
+
+const createdPaths: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(createdPaths.splice(0).map((path) => rm(path, { recursive: true, force: true })));
+});
+
+async function createDbPath(): Promise<string> {
+  const dir = resolve(process.cwd(), '.test-data', randomUUID());
+  createdPaths.push(dir);
+  await mkdir(dir, { recursive: true });
+  return resolve(dir, 'reputation.sqlite');
+}
+
+function createEvent(overrides: Partial<ReputationEvent> = {}): ReputationEvent {
+  return {
+    eventId: 'event-1',
+    type: 'task_completion',
+    subject: 'did:mesh:provider',
+    author: 'did:mesh:requester',
+    taskId: 'task-1',
+    outcome: 'success',
+    capability: 'echo',
+    timestamp: new Date(1_700_000_000_000).toISOString(),
+    nonce: 'nonce-1',
+    signature: 'signature-1',
+    ...overrides,
+  };
+}
+
+describe('ReputationStore', () => {
+  it('skips malformed stored events when querying', async () => {
+    const store = new ReputationStore(await createDbPath());
+    const valid = createEvent();
+
+    await store.addEvent(valid);
+    const db = (store as unknown as { db: Database.Database }).db;
+    db.prepare(
+      `INSERT INTO reputation_events (
+        event_id, type, subject, author, task_id, outcome, capability,
+        timestamp, timestamp_ms, nonce, signature, payload_json, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      'corrupt-event',
+      'task_completion',
+      'did:mesh:provider',
+      'did:mesh:requester',
+      'task-corrupt',
+      'success',
+      'echo',
+      valid.timestamp,
+      Date.parse(valid.timestamp),
+      'nonce-corrupt',
+      'signature-corrupt',
+      '{"subject":"did:mesh:provider"}',
+      Date.now(),
+    );
+
+    const events = await store.getEvents({ subject: 'did:mesh:provider' });
+    expect(events).toEqual([valid]);
+    store.close();
+  });
+
+  it('stores, queries, and anchors events', async () => {
+    const store = new ReputationStore(await createDbPath());
+    const first = createEvent();
+    const second = createEvent({ eventId: 'event-2', outcome: 'failure', type: 'task_failure', timestamp: new Date(1_700_000_001_000).toISOString() });
+
+    await store.addEvent(first);
+    await store.addEvent(second);
+
+    const bySubject = await store.getEvents({ subject: 'did:mesh:provider' });
+    expect(bySubject).toHaveLength(2);
+
+    const unanchored = await store.getUnanchoredEvents();
+    expect(unanchored.map((event) => event.eventId)).toEqual(['event-1', 'event-2']);
+
+    await store.markAnchored(['event-1'], 'anchor-1');
+    expect((await store.getUnanchoredEvents()).map((event) => event.eventId)).toEqual(['event-2']);
+
+    expect(await store.getStats('did:mesh:provider')).toEqual({ completed: 1, failed: 1, disputed: 0 });
+    store.close();
+  });
+});

package/tests/routing/circuit-breaker.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'vitest';
+
+import { CircuitBreaker, CircuitBreakerState } from '../../src/index.js';
+
+describe('CircuitBreaker', () => {
+  it('opens after reaching the failure threshold', () => {
+    const breaker = new CircuitBreaker({ failureThreshold: 3 });
+
+    breaker.recordFailure('provider-1');
+    breaker.recordFailure('provider-1');
+    expect(breaker.getState('provider-1')).toBe(CircuitBreakerState.CLOSED);
+
+    breaker.recordFailure('provider-1');
+    expect(breaker.getState('provider-1')).toBe(CircuitBreakerState.OPEN);
+    expect(breaker.isOpen('provider-1')).toBe(true);
+  });
+
+  it('transitions to half-open after the recovery timeout and closes on success', () => {
+    let now = 1_000;
+    const breaker = new CircuitBreaker({ failureThreshold: 2, recoveryTimeoutMs: 100, now: () => now });
+
+    breaker.recordFailure('provider-1');
+    breaker.recordFailure('provider-1');
+    expect(breaker.getState('provider-1')).toBe(CircuitBreakerState.OPEN);
+
+    now += 101;
+    expect(breaker.getState('provider-1')).toBe(CircuitBreakerState.HALF_OPEN);
+
+    breaker.recordSuccess('provider-1');
+    expect(breaker.getState('provider-1')).toBe(CircuitBreakerState.CLOSED);
+  });
+
+  it('re-opens immediately when a half-open provider fails', () => {
+    let now = 1_000;
+    const breaker = new CircuitBreaker({ failureThreshold: 2, recoveryTimeoutMs: 50, now: () => now });
+
+    breaker.recordFailure('provider-1');
+    breaker.recordFailure('provider-1');
+    now += 51;
+    expect(breaker.getState('provider-1')).toBe(CircuitBreakerState.HALF_OPEN);
+
+    breaker.recordFailure('provider-1');
+    expect(breaker.getState('provider-1')).toBe(CircuitBreakerState.OPEN);
+  });
+});

package/tests/routing/fan-out.test.ts

@@ -0,0 +1,123 @@
+import { describe, expect, it } from 'vitest';
+
+import { AggregationMode, ProviderSelectionStrategy, type MultiProviderRequest, type ProviderScore } from '@hivemind-os/collective-types';
+
+import { CircuitBreaker, FanOutExecutor, PerformanceTracker } from '../../src/index.js';
+
+function createProvider(did: string, price = 5n): ProviderScore {
+  return {
+    did: did as ProviderScore['did'],
+    price,
+    reputation: 50,
+    estimatedLatency: 100,
+    circuitBreakerOpen: false,
+    compositeScore: 0,
+  };
+}
+
+function createRequest(overrides: Partial<MultiProviderRequest> = {}): MultiProviderRequest {
+  return {
+    capability: 'echo',
+    input: { message: 'hello' },
+    fanOutCount: 3,
+    strategy: ProviderSelectionStrategy.WEIGHTED,
+    aggregation: AggregationMode.ALL,
+    timeout: 100,
+    ...overrides,
+  };
+}
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+describe('FanOutExecutor', () => {
+  it('fans out to all providers and aggregates all successful results', async () => {
+    const tracker = new PerformanceTracker();
+    const executor = new FanOutExecutor({
+      performanceTracker: tracker,
+      executeProvider: async (provider) => ({
+        value: { provider: provider.did },
+        aggregateValue: provider.did,
+        cost: provider.price,
+      }),
+    });
+
+    const result = await executor.execute(createRequest({ aggregation: AggregationMode.ALL, fanOutCount: 2 }), [
+      createProvider('did:mesh:a', 2n),
+      createProvider('did:mesh:b', 3n),
+    ]);
+
+    expect(result.aggregatedResult).toEqual(['did:mesh:a', 'did:mesh:b']);
+    expect(result.totalCost).toBe(5n);
+    expect(result.results.map((entry) => entry.status)).toEqual(['success', 'success']);
+    expect(tracker.getEstimatedLatency('did:mesh:a', 'echo')).toBeDefined();
+    tracker.close();
+  });
+
+  it('returns the first successful result and aborts slower providers', async () => {
+    const breaker = new CircuitBreaker();
+    const executor = new FanOutExecutor({
+      circuitBreaker: breaker,
+      executeProvider: async (provider, _request, context) => {
+        if (provider.did === 'did:mesh:fast') {
+          await delay(10);
+          return { value: { winner: provider.did }, aggregateValue: provider.did, cost: provider.price };
+        }
+
+        await new Promise((_, reject) => {
+          context.signal.addEventListener('abort', () => reject(new Error('aborted')), { once: true });
+        });
+        return { value: null, cost: 0n };
+      },
+    });
+
+    const result = await executor.execute(createRequest({ aggregation: AggregationMode.FIRST_SUCCESS, fanOutCount: 2 }), [
+      createProvider('did:mesh:fast', 2n),
+      createProvider('did:mesh:slow', 2n),
+    ]);
+
+    expect(result.aggregatedResult).toBe('did:mesh:fast');
+    expect(result.results.find((entry) => entry.provider === 'did:mesh:fast')?.status).toBe('success');
+    expect(result.results.find((entry) => entry.provider === 'did:mesh:slow')?.status).toBe('timeout');
+    expect(breaker.getState('did:mesh:fast')).toBe('closed');
+  });
+
+  it('returns a majority result when more than half the providers agree', async () => {
+    const executor = new FanOutExecutor({
+      executeProvider: async (provider) => ({
+        value: { provider: provider.did },
+        aggregateValue: provider.did === 'did:mesh:c' ? 'different' : 'shared',
+        cost: provider.price,
+      }),
+    });
+
+    const result = await executor.execute(createRequest({ aggregation: AggregationMode.MAJORITY }), [
+      createProvider('did:mesh:a'),
+      createProvider('did:mesh:b'),
+      createProvider('did:mesh:c'),
+    ]);
+
+    expect(result.aggregatedResult).toBe('shared');
+  });
+
+  it('marks provider timeouts and excludes them from total cost', async () => {
+    const executor = new FanOutExecutor({
+      executeProvider: async (provider) => {
+        if (provider.did === 'did:mesh:slow') {
+          await delay(30);
+        }
+        return { value: provider.did, aggregateValue: provider.did, cost: provider.price };
+      },
+    });
+
+    const result = await executor.execute(createRequest({ aggregation: AggregationMode.ALL, fanOutCount: 2, timeout: 5 }), [
+      createProvider('did:mesh:fast', 2n),
+      createProvider('did:mesh:slow', 3n),
+    ]);
+
+    expect(result.results.find((entry) => entry.provider === 'did:mesh:fast')?.status).toBe('success');
+    expect(result.results.find((entry) => entry.provider === 'did:mesh:slow')?.status).toBe('timeout');
+    expect(result.totalCost).toBe(2n);
+  });
+});

package/tests/routing/performance.test.ts

@@ -0,0 +1,49 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, rm } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { PerformanceTracker } from '../../src/index.js';
+
+const createdPaths: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(createdPaths.splice(0).map((path) => rm(path, { recursive: true, force: true })));
+});
+
+async function createDbPath(): Promise<string> {
+  const dir = resolve(process.cwd(), '.test-data', randomUUID());
+  createdPaths.push(dir);
+  await mkdir(dir, { recursive: true });
+  return resolve(dir, 'performance.sqlite');
+}
+
+describe('PerformanceTracker', () => {
+  it('records completions and returns estimated latency', async () => {
+    const tracker = new PerformanceTracker({ dbPath: await createDbPath() });
+
+    tracker.recordCompletion('did:mesh:provider', 'echo', 120, true);
+    tracker.recordCompletion('did:mesh:provider', 'echo', 240, true);
+    tracker.recordCompletion('did:mesh:provider', 'echo', 360, false);
+
+    expect(tracker.getEstimatedLatency('did:mesh:provider', 'echo')).toBe(240);
+    tracker.close();
+  });
+
+  it('returns aggregated provider stats across capabilities', async () => {
+    const tracker = new PerformanceTracker({ dbPath: await createDbPath() });
+
+    tracker.recordCompletion('did:mesh:provider', 'echo', 100, true);
+    tracker.recordCompletion('did:mesh:provider', 'summarize', 200, false);
+
+    const stats = tracker.getProviderStats('did:mesh:provider');
+
+    expect(stats.providerDid).toBe('did:mesh:provider');
+    expect(stats.successCount).toBe(1);
+    expect(stats.failureCount).toBe(1);
+    expect(stats.capabilities).toHaveLength(2);
+    expect(stats.capabilities.map((entry) => entry.capability)).toEqual(['echo', 'summarize']);
+    tracker.close();
+  });
+});

package/tests/routing/selector.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, it } from 'vitest';
+
+import { PaymentRail, ProviderSelectionStrategy, type AgentCard, type ProviderScore } from '@hivemind-os/collective-types';
+
+import { CircuitBreaker, ProviderSelector } from '../../src/index.js';
+
+function createAgent(overrides: Partial<AgentCard> = {}): AgentCard {
+  return {
+    id: 'agent-1',
+    owner: 'owner-1',
+    did: 'did:mesh:agent-1' as AgentCard['did'],
+    name: 'Agent 1',
+    description: 'Test agent',
+    capabilities: [
+      {
+        name: 'echo',
+        description: 'Echo',
+        version: '1.0.0',
+        pricing: {
+          rail: PaymentRail.SUI_ESCROW,
+          amount: 10n,
+          currency: 'MIST',
+        },
+      },
+    ],
+    active: true,
+    version: 1,
+    registeredAt: 1_000,
+    updatedAt: 1_000,
+    ...overrides,
+  };
+}
+
+function createProviderScore(overrides: Partial<ProviderScore> = {}): ProviderScore {
+  return {
+    did: 'did:mesh:agent-1' as ProviderScore['did'],
+    price: 10n,
+    reputation: 50,
+    estimatedLatency: 500,
+    circuitBreakerOpen: false,
+    compositeScore: 0,
+    ...overrides,
+  };
+}
+
+describe('ProviderSelector', () => {
+  it('selects the cheapest providers first', () => {
+    const selector = new ProviderSelector();
+
+    const selected = selector.selectCheapest([
+      createProviderScore({ did: 'did:mesh:expensive' as ProviderScore['did'], price: 25n }),
+      createProviderScore({ did: 'did:mesh:cheap' as ProviderScore['did'], price: 5n }),
+      createProviderScore({ did: 'did:mesh:mid' as ProviderScore['did'], price: 12n }),
+    ], 2);
+
+    expect(selected.map((entry) => entry.did)).toEqual(['did:mesh:cheap', 'did:mesh:mid']);
+  });
+
+  it('selects the fastest providers using performance data', () => {
+    const selector = new ProviderSelector({
+      performanceTracker: {
+        getEstimatedLatency: (provider) => ({
+          'did:mesh:slow': 900,
+          'did:mesh:fast': 120,
+        }[provider]),
+      },
+    });
+
+    const selected = selector.selectProviders([
+      createAgent({ did: 'did:mesh:slow' as AgentCard['did'], totalTasksCompleted: 10 }),
+      createAgent({ did: 'did:mesh:fast' as AgentCard['did'], totalTasksCompleted: 10 }),
+    ], 'echo', ProviderSelectionStrategy.FASTEST, 1);
+
+    expect(selected[0]?.did).toBe('did:mesh:fast');
+  });
+
+  it('selects the highest reputation providers first', () => {
+    const selector = new ProviderSelector();
+
+    const selected = selector.selectProviders([
+      createAgent({ did: 'did:mesh:strong' as AgentCard['did'], totalTasksCompleted: 20, totalTasksFailed: 1 }),
+      createAgent({ did: 'did:mesh:weak' as AgentCard['did'], totalTasksCompleted: 2, totalTasksFailed: 4 }),
+    ], 'echo', ProviderSelectionStrategy.HIGHEST_REPUTATION, 1);
+
+    expect(selected[0]?.did).toBe('did:mesh:strong');
+  });
+
+  it('rotates providers with round robin selection', () => {
+    const selector = new ProviderSelector();
+    const providers = [
+      createProviderScore({ did: 'did:mesh:a' as ProviderScore['did'] }),
+      createProviderScore({ did: 'did:mesh:b' as ProviderScore['did'] }),
+      createProviderScore({ did: 'did:mesh:c' as ProviderScore['did'] }),
+    ];
+
+    expect(selector.selectRoundRobin(providers, 2).map((entry) => entry.did)).toEqual(['did:mesh:a', 'did:mesh:b']);
+    expect(selector.selectRoundRobin(providers, 2).map((entry) => entry.did)).toEqual(['did:mesh:c', 'did:mesh:a']);
+  });
+
+  it('filters out providers with an open circuit breaker before weighted selection', () => {
+    const circuitBreaker = new CircuitBreaker();
+    circuitBreaker.recordFailure('did:mesh:blocked');
+    circuitBreaker.recordFailure('did:mesh:blocked');
+    circuitBreaker.recordFailure('did:mesh:blocked');
+    const selector = new ProviderSelector({ circuitBreaker });
+
+    const selected = selector.selectProviders([
+      createAgent({ did: 'did:mesh:blocked' as AgentCard['did'], totalTasksCompleted: 100 }),
+      createAgent({ did: 'did:mesh:healthy' as AgentCard['did'], totalTasksCompleted: 5 }),
+    ], 'echo', ProviderSelectionStrategy.WEIGHTED, 2);
+
+    expect(selected.map((entry) => entry.did)).toEqual(['did:mesh:healthy']);
+  });
+});

package/tests/spending.test.ts

@@ -0,0 +1,133 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, rm } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { PaymentRail, SpendingPolicyEngine } from '../src/index.js';
+
+const createdPaths: string[] = [];
+const basePolicy = { limits: [] };
+
+beforeEach(() => {
+  vi.useFakeTimers();
+  vi.setSystemTime(new Date('2025-01-02T12:00:00.000Z'));
+});
+
+afterEach(async () => {
+  vi.useRealTimers();
+  await Promise.all(
+    createdPaths.splice(0).map((path) => rm(path, { recursive: true, force: true })),
+  );
+});
+
+async function createDbPath(): Promise<string> {
+  const dir = resolve(process.cwd(), '.test-data', randomUUID());
+  createdPaths.push(dir);
+  await mkdir(dir, { recursive: true });
+  return resolve(dir, 'spending.sqlite');
+}
+
+describe('SpendingPolicyEngine', () => {
+  it('approves everything for an empty policy', async () => {
+    const engine = new SpendingPolicyEngine({ policy: basePolicy, dbPath: await createDbPath() });
+
+    expect(engine.evaluate({ amountMist: 1_000n, rail: PaymentRail.SUI_ESCROW })).toEqual({
+      approved: true,
+    });
+
+    engine.close();
+  });
+
+  it('enforces a daily limit', async () => {
+    const engine = new SpendingPolicyEngine({
+      policy: {
+        limits: [{ amount: 100n, interval: 'day', rail: PaymentRail.SUI_ESCROW }],
+      },
+      dbPath: await createDbPath(),
+    });
+
+    expect(engine.evaluate({ amountMist: 60n, rail: PaymentRail.SUI_ESCROW }).approved).toBe(true);
+    engine.record({ amountMist: 60n, rail: PaymentRail.SUI_ESCROW, taskId: 'task-1' });
+    expect(engine.evaluate({ amountMist: 50n, rail: PaymentRail.SUI_ESCROW }).approved).toBe(false);
+
+    engine.close();
+  });
+
+  it('enforces transaction and daily limits together', async () => {
+    const engine = new SpendingPolicyEngine({
+      policy: {
+        limits: [
+          { amount: 80n, interval: 'transaction', rail: PaymentRail.SUI_ESCROW },
+          { amount: 100n, interval: 'day', rail: PaymentRail.SUI_ESCROW },
+        ],
+      },
+      dbPath: await createDbPath(),
+    });
+
+    expect(engine.evaluate({ amountMist: 90n, rail: PaymentRail.SUI_ESCROW }).approved).toBe(false);
+    engine.record({ amountMist: 40n, rail: PaymentRail.SUI_ESCROW, taskId: 'task-2' });
+    expect(engine.evaluate({ amountMist: 70n, rail: PaymentRail.SUI_ESCROW }).approved).toBe(false);
+    expect(engine.evaluate({ amountMist: 50n, rail: PaymentRail.SUI_ESCROW }).approved).toBe(true);
+
+    engine.close();
+  });
+
+  it('records spending and reports totals', async () => {
+    const engine = new SpendingPolicyEngine({ policy: basePolicy, dbPath: await createDbPath() });
+    engine.record({ amountMist: 25n, rail: PaymentRail.SUI_ESCROW, taskId: 'task-3' });
+    engine.record({ amountMist: 15n, rail: PaymentRail.SUI_ESCROW, taskId: 'task-4' });
+
+    expect(engine.getSpent('day')).toBe(40n);
+
+    engine.close();
+  });
+
+  it('tracks x402 spending by currency without mixing units', async () => {
+    const engine = new SpendingPolicyEngine({
+      policy: {
+        limits: [{ amount: 100n, interval: 'day', rail: PaymentRail.X402_BASE, currency: 'USDC' }],
+      },
+      dbPath: await createDbPath(),
+    });
+
+    engine.record({ amount: 60n, currency: 'USDC', rail: PaymentRail.X402_BASE, taskId: 'task-usdc' });
+    engine.record({ amount: 2n, currency: 'ETH', rail: PaymentRail.X402_BASE, taskId: 'task-eth' });
+
+    expect(engine.getSpent('day', PaymentRail.X402_BASE, undefined, 'USDC')).toBe(60n);
+    expect(engine.getSpent('day', PaymentRail.X402_BASE, undefined, 'ETH')).toBe(2n);
+    expect(engine.evaluate({ amount: 50n, currency: 'USDC', rail: PaymentRail.X402_BASE }).approved).toBe(false);
+    expect(engine.evaluate({ amount: 1n, currency: 'ETH', rail: PaymentRail.X402_BASE }).approved).toBe(true);
+
+    engine.close();
+  });
+
+  it('updates policy rules at runtime', async () => {
+    const engine = new SpendingPolicyEngine({ policy: basePolicy, dbPath: await createDbPath() });
+    expect(engine.evaluate({ amountMist: 200n, rail: PaymentRail.SUI_ESCROW }).approved).toBe(true);
+
+    engine.updatePolicy({
+      limits: [{ amount: 100n, interval: 'transaction', rail: PaymentRail.SUI_ESCROW }],
+    });
+
+    expect(engine.evaluate({ amountMist: 200n, rail: PaymentRail.SUI_ESCROW }).approved).toBe(false);
+    engine.close();
+  });
+
+  it("doesn't count yesterday's spending against today's limit", async () => {
+    const engine = new SpendingPolicyEngine({
+      policy: {
+        limits: [{ amount: 100n, interval: 'day', rail: PaymentRail.SUI_ESCROW }],
+      },
+      dbPath: await createDbPath(),
+    });
+
+    vi.setSystemTime(new Date('2025-01-01T12:00:00.000Z'));
+    engine.record({ amountMist: 90n, rail: PaymentRail.SUI_ESCROW, taskId: 'task-yesterday' });
+
+    vi.setSystemTime(new Date('2025-01-02T12:00:00.000Z'));
+    expect(engine.evaluate({ amountMist: 50n, rail: PaymentRail.SUI_ESCROW }).approved).toBe(true);
+
+    engine.close();
+  });
+});