@animalabs/connectome-host 0.3.1 → 0.3.7

package/test/call-ledger.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, test } from 'bun:test';
+import { CallLedger, summarizeCacheControls, type ProviderCallRecord } from '../src/call-ledger.js';
+
+const at = (seconds: number): string => new Date(Date.UTC(2026, 0, 1, 0, 0, seconds)).toISOString();
+
+function call(overrides: Partial<ProviderCallRecord> = {}): ProviderCallRecord {
+  return {
+    timestamp: at(0),
+    kind: 'stream',
+    durationMs: 1000,
+    model: 'claude-fable-5',
+    messages: 10,
+    inputTokens: 2,
+    outputTokens: 100,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    cacheBreakpoints: 4,
+    cacheTtls: ['1h', '1h', '1h', '1h'],
+    stopReason: 'end_turn',
+    ...overrides,
+  };
+}
+
+describe('CallLedger cache verdicts', () => {
+  test('distinguishes first write, hit, and expired rewrite using the effective TTL', () => {
+    const ledger = new CallLedger({ hydrate: false, defaultTtl: '1h' });
+    ledger.record(call({ timestamp: at(0), cacheWriteTokens: 100_000 }));
+    ledger.record(call({ timestamp: at(1800), cacheReadTokens: 100_000 }));
+    ledger.record(call({ timestamp: at(5500), cacheWriteTokens: 101_000 }));
+
+    const rows = ledger.snapshot().rows;
+    expect(rows.map((r) => r.verdict)).toEqual(['first-write', 'HIT', 'rewrite:expired']);
+    expect(rows[2]!.cause).toContain('gap 3700s > ttl 3600s');
+  });
+
+  test('calls without cache flags are visibly uncached', () => {
+    const ledger = new CallLedger({ hydrate: false });
+    ledger.record(call({ kind: 'complete', cacheBreakpoints: 0, cacheTtls: [], inputTokens: 48_000 }));
+    expect(ledger.snapshot().rows[0]).toMatchObject({
+      verdict: 'uncached',
+      cause: 'no cache_control flags in request',
+    });
+  });
+
+  test('reports hit+extend and an aggregate cache ratio', () => {
+    const ledger = new CallLedger({ hydrate: false });
+    ledger.record(call({ inputTokens: 100, cacheReadTokens: 900, cacheWriteTokens: 100 }));
+    const snap = ledger.snapshot();
+    expect(snap.rows[0]!.verdict).toBe('hit+extend');
+    expect(snap.summary.cacheHitRatio).toBeCloseTo(900 / 1100);
+  });
+
+  test('allocates an auditable per-call cost and reconciles the retained total', () => {
+    const ledger = new CallLedger({ hydrate: false });
+    ledger.record(call({
+      cacheWriteTokens: 336_010,
+      cacheWrite5mTokens: 336_010,
+      cacheWrite1hTokens: 0,
+      cacheWriteBucketsAuthoritative: true,
+      cacheTtls: ['5m'],
+      outputTokens: 639,
+      serviceTier: 'standard',
+      inferenceGeo: 'global',
+    }));
+    ledger.record(call({ model: 'unknown-model' }));
+
+    const snap = ledger.snapshot();
+    expect(snap.rows[0]!.cost?.total).toBeCloseTo(4.232095, 9);
+    expect(snap.rows[1]!.cost).toBeUndefined();
+    expect(snap.summary.cost).toMatchObject({
+      total: 4.232095,
+      pricedCalls: 1,
+      unpricedCalls: 1,
+      currency: 'USD',
+    });
+  });
+
+  test('does not guess a cache-write TTL bucket from request flags', () => {
+    const ledger = new CallLedger({ hydrate: false });
+    ledger.record(call({ cacheWriteTokens: 100_000, cacheTtls: ['1h'] }));
+    expect(ledger.snapshot().rows[0]!.cost).toBeUndefined();
+  });
+});
+
+test('summarizeCacheControls inventories markers without retaining content', () => {
+  const raw = {
+    system: [{ type: 'text', text: 'secret', cache_control: { type: 'ephemeral', ttl: '1h' } }],
+    messages: [{ role: 'user', content: [{ type: 'text', text: 'private', cache_control: { type: 'ephemeral' } }] }],
+  };
+  expect(summarizeCacheControls(raw)).toEqual({ count: 2, ttls: ['1h', 'default'] });
+});

package/test/call-pricing.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, test } from 'bun:test';
+import { ANTHROPIC_PRICING_VERSION, priceAnthropicCall } from '../src/call-pricing.js';
+
+const timestamp = '2026-07-13T12:00:00.000Z';
+
+function usage(overrides: Partial<Parameters<typeof priceAnthropicCall>[2]> = {}) {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWrite5mTokens: 0,
+    cacheWrite1hTokens: 0,
+    unclassifiedCacheWriteTokens: 0,
+    serviceTier: 'standard',
+    inferenceGeo: 'global',
+    ...overrides,
+  };
+}
+
+describe('Anthropic per-call pricing', () => {
+  test('reproduces the ledger-dashboard Fable/Mythos 5m sample exactly', () => {
+    const cost = priceAnthropicCall('claude-fable-5', timestamp, usage({
+      inputTokens: 2,
+      cacheWrite5mTokens: 336_010,
+      outputTokens: 639,
+    }));
+
+    expect(cost?.total).toBeCloseTo(4.232095, 9);
+    expect(cost).toMatchObject({
+      cacheWrite5m: 4.200125,
+      cacheWrite1h: 0,
+      currency: 'USD',
+      grade: 'billing',
+      pricingVersion: ANTHROPIC_PRICING_VERSION,
+    });
+  });
+
+  test('prices 1h writes at 2x base input and cache reads at 0.1x', () => {
+    const write = priceAnthropicCall('claude-mythos-5', timestamp, usage({ cacheWrite1hTokens: 336_010 }));
+    const read = priceAnthropicCall('claude-mythos-5', timestamp, usage({ cacheReadTokens: 336_010 }));
+    expect(write?.cacheWrite1h).toBeCloseTo(6.7202, 9);
+    expect(read?.cacheRead).toBeCloseTo(0.33601, 9);
+  });
+
+  test('applies the US-only inference multiplier to every token category', () => {
+    const global = priceAnthropicCall('claude-fable-5', timestamp, usage({ inputTokens: 1_000_000 }));
+    const us = priceAnthropicCall('claude-fable-5', timestamp, usage({
+      inputTokens: 1_000_000,
+      inferenceGeo: 'us',
+    }));
+    expect(global?.total).toBe(10);
+    expect(us?.total).toBeCloseTo(11, 9);
+  });
+
+  test('leaves unknown rates, custom tiers, and unclassified writes unpriced', () => {
+    expect(priceAnthropicCall('unknown-model', timestamp, usage())).toBeUndefined();
+    expect(priceAnthropicCall('claude-fable-5', timestamp, usage({ serviceTier: 'priority' }))).toBeUndefined();
+    expect(priceAnthropicCall('claude-fable-5', timestamp, usage({
+      unclassifiedCacheWriteTokens: 1,
+    }))).toBeUndefined();
+  });
+
+  test('honors the published Sonnet 5 promotional cutoff', () => {
+    const promo = priceAnthropicCall('claude-sonnet-5', '2026-08-31T23:59:59Z', usage({ inputTokens: 1_000_000 }));
+    const standard = priceAnthropicCall('claude-sonnet-5', '2026-09-01T00:00:00Z', usage({ inputTokens: 1_000_000 }));
+    expect(promo?.total).toBe(2);
+    expect(standard?.total).toBe(3);
+  });
+});

package/test/fleet-subscribe-union-e2e.test.ts

@@ -45,8 +45,11 @@ describe('FleetModule subscribe union e2e', () => {
   let tmpDir: string;
   let recipePath: string;
   let fleet: FleetModule;
+  let previousApiKey: string | undefined;
 
   beforeAll(async () => {
+    previousApiKey = process.env.ANTHROPIC_API_KEY;
+    process.env.ANTHROPIC_API_KEY = previousApiKey || 'sk-test-fleet-subscribe-union';
     tmpDir = mkdtempSync(join(tmpdir(), 'fkm-sub-union-'));
     recipePath = join(tmpDir, 'recipe.json');
     writeFileSync(recipePath, JSON.stringify(NARROW_RECIPE), 'utf-8');
@@ -68,6 +71,8 @@ describe('FleetModule subscribe union e2e', () => {
     } catch { /* noop */ }
     await new Promise((r) => setTimeout(r, 500));
     try { rmSync(tmpDir, { recursive: true, force: true }); } catch { /* noop */ }
+    if (previousApiKey === undefined) delete process.env.ANTHROPIC_API_KEY;
+    else process.env.ANTHROPIC_API_KEY = previousApiKey;
   });
 
   test('narrow recipe subscription gets reducer-required events forced in by FleetModule', async () => {

package/test/fleet-tree-aggregator-e2e.test.ts

@@ -51,6 +51,8 @@ describe('FleetTreeAggregator — e2e against headless child', () => {
   let aggregator: FleetTreeAggregator;
 
   beforeAll(async () => {
+    // Children validate credentials during startup but never infer in this test.
+    process.env.ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY || 'sk-test-fleet-aggregator';
     tmpDir = mkdtempSync(join(tmpdir(), 'fkm-agg-e2e-'));
     recipePath = join(tmpDir, 'recipe.json');
     writeFileSync(recipePath, JSON.stringify(CHILD_RECIPE), 'utf-8');

package/test/frontdesk-strategy.test.ts

@@ -81,6 +81,7 @@ function makeStrategy(): TestFrontdesk {
     targetChunkTokens: 50,
     autoTickOnNewMessage: false,
     maxMessageTokens: 0,
+    timeZone: 'UTC',
   });
 }
 
@@ -110,6 +111,15 @@ describe('provenance wrapping', () => {
     expect(header!.endsWith('\n')).toBe(true);
   });
 
+  test('renders provenance time in the configured zone', () => {
+    const s = new TestFrontdesk({ timeZone: 'America/Los_Angeles' });
+    const m = msg('User', 'hello', {
+      serverId: 'zulip',
+      timestamp: '2026-07-17T14:32:00Z',
+    });
+    expect(s.pub_buildHeader(m)).toContain('07:32');
+  });
+
   test('wrapProvenance prepends header into the first text block', () => {
     const s = makeStrategy();
     const m = msg('User', 'hello', {

package/test/import-codex-rollout.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, test } from 'bun:test';
+import {
+  projectItem,
+  reconstructEffectiveHistory,
+} from '../scripts/import-codex-rollout.js';
+
+describe('Codex rollout import', () => {
+  test('uses replacement_history as the authoritative compaction boundary', () => {
+    const history = reconstructEffectiveHistory([
+      { type: 'response_item', payload: { type: 'message', id: 'discarded' } },
+      {
+        type: 'compacted', timestamp: '2026-07-13T00:00:00Z',
+        payload: { replacement_history: [
+          { type: 'message', role: 'user', content: 'kept' },
+          { type: 'compaction', id: 'cmp_1', encrypted_content: 'opaque' },
+        ] },
+      },
+      { type: 'response_item', payload: { type: 'reasoning', id: 'rs_2', encrypted_content: 'tail' } },
+    ]);
+
+    expect(history.map(entry => entry.item.id ?? entry.item.type)).toEqual([
+      'message', 'cmp_1', 'rs_2',
+    ]);
+    expect(history[0]!.restoredByCompaction).toBe(true);
+    expect(history[2]!.restoredByCompaction).toBe(false);
+  });
+
+  test('keeps the exact native item on the Chronicle projection block', () => {
+    const item = {
+      type: 'message', id: 'msg_1', role: 'assistant', phase: 'commentary',
+      content: [{ type: 'output_text', text: 'hello' }],
+    };
+    const [block] = projectItem(item);
+    expect(block).toMatchObject({ type: 'text', text: 'hello', rawItem: item });
+  });
+});

package/test/logging-adapter.test.ts

@@ -1,5 +1,6 @@
 import { describe, test, expect } from 'bun:test';
 import { LoggingAnthropicAdapter } from '../src/logging-adapter.js';
+import type { ProviderCallRecord } from '../src/call-ledger.js';
 import type { ProviderRequest, ProviderResponse } from '@animalabs/membrane';
 
 // Regression guard for the reasoning passthrough. `withReasoning` injects
@@ -57,7 +58,7 @@ describe('LoggingAnthropicAdapter.withReasoning', () => {
 describe('LoggingAnthropicAdapter request logging', () => {
   const adapter = new LoggingAnthropicAdapter({ apiKey: 'test' }, '/dev/null');
   const internals = adapter as unknown as {
-    requestSummary(r: ProviderRequest): Record<string, unknown>;
+    requestSummary(r: ProviderRequest, raw?: unknown): Record<string, unknown>;
     refusalRawRequest(r: ProviderResponse, raw: unknown): unknown;
   };
 
@@ -76,6 +77,20 @@ describe('LoggingAnthropicAdapter request logging', () => {
     });
   });
 
+  test('summarizes provider cache markers without retaining prompt content', () => {
+    const raw = {
+      messages: [{
+        role: 'user',
+        content: [{ type: 'text', text: 'do not log me', cache_control: { type: 'ephemeral', ttl: '1h' } }],
+      }],
+    };
+    expect(internals.requestSummary(baseRequest, raw)).toMatchObject({
+      cacheBreakpoints: 1,
+      cacheTtls: ['1h'],
+    });
+    expect(JSON.stringify(internals.requestSummary(baseRequest, raw))).not.toContain('do not log me');
+  });
+
   test('retains the raw request only for refusals', () => {
     const rawRequest = { messages: ['forensic context'] };
     const success = { raw: { stop_reason: 'end_turn' } } as unknown as ProviderResponse;
@@ -84,4 +99,46 @@ describe('LoggingAnthropicAdapter request logging', () => {
     expect(internals.refusalRawRequest(success, rawRequest)).toBeUndefined();
     expect(internals.refusalRawRequest(refusal, rawRequest)).toBe(rawRequest);
   });
+
+  test('forwards authoritative billing buckets from the provider response', () => {
+    const calls: ProviderCallRecord[] = [];
+    const observed = new LoggingAnthropicAdapter(
+      { apiKey: 'test' },
+      '/dev/null',
+      undefined,
+      (call) => calls.push(call),
+    ) as unknown as {
+      observeCall(
+        kind: 'complete' | 'stream',
+        timestamp: string,
+        durationMs: number,
+        request: ProviderRequest,
+        rawRequest: unknown,
+        response: ProviderResponse,
+      ): void;
+    };
+    const response = {
+      usage: { inputTokens: 2, outputTokens: 10, cacheCreationTokens: 100, cacheReadTokens: 50 },
+      raw: {
+        usage: {
+          cache_creation: {
+            ephemeral_5m_input_tokens: 25,
+            ephemeral_1h_input_tokens: 75,
+          },
+          service_tier: 'standard',
+          inference_geo: 'global',
+        },
+      },
+    } as unknown as ProviderResponse;
+
+    observed.observeCall('stream', '2026-07-13T00:00:00Z', 10, baseRequest, {}, response);
+    expect(calls[0]).toMatchObject({
+      cacheWriteTokens: 100,
+      cacheWrite5mTokens: 25,
+      cacheWrite1hTokens: 75,
+      cacheWriteBucketsAuthoritative: true,
+      serviceTier: 'standard',
+      inferenceGeo: 'global',
+    });
+  });
 });

package/test/recipe-cache-ttl.test.ts

@@ -4,7 +4,7 @@
  * inference).
  */
 import { describe, test, expect } from 'bun:test';
-import { validateRecipe } from '../src/recipe.js';
+import { DEFAULT_RECIPE, validateRecipe } from '../src/recipe.js';
 
 function recipeWithCacheTtl(cacheTtl?: unknown) {
   return {
@@ -17,6 +17,10 @@ function recipeWithCacheTtl(cacheTtl?: unknown) {
 }
 
 describe('recipe agent.cacheTtl validation', () => {
+  test('the shipped default recipe explicitly uses "1h"', () => {
+    expect(DEFAULT_RECIPE.agent.cacheTtl).toBe('1h');
+  });
+
   test('accepts "5m"', () => {
     expect(validateRecipe(recipeWithCacheTtl('5m')).agent.cacheTtl).toBe('5m');
   });
@@ -25,8 +29,8 @@ describe('recipe agent.cacheTtl validation', () => {
     expect(validateRecipe(recipeWithCacheTtl('1h')).agent.cacheTtl).toBe('1h');
   });
 
-  test('accepts unset (provider default applies)', () => {
-    expect(validateRecipe(recipeWithCacheTtl()).agent.cacheTtl).toBeUndefined();
+  test('defaults unset cacheTtl to "1h"', () => {
+    expect(validateRecipe(recipeWithCacheTtl()).agent.cacheTtl).toBe('1h');
   });
 
   test('rejects a typo\'d TTL at load time', () => {

package/test/recipe-provider.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, test } from 'bun:test';
+import { validateRecipe } from '../src/recipe.js';
+
+function recipe(agent: Record<string, unknown> = {}) {
+  return { name: 'provider-test', agent: { systemPrompt: 'sys', ...agent } };
+}
+
+describe('recipe provider validation', () => {
+  test('preserves Anthropic as the omitted provider and accepts Responses', () => {
+    expect(validateRecipe(recipe()).agent.provider).toBeUndefined();
+    expect(validateRecipe(recipe({ provider: 'openai-responses' })).agent.provider)
+      .toBe('openai-responses');
+  });
+
+  test('accepts Responses reasoning and compaction settings', () => {
+    expect(validateRecipe(recipe({
+      provider: 'openai-responses',
+      responses: {
+        reasoningEffort: 'xhigh',
+        reasoningContext: 'all_turns',
+        compactThreshold: 100_000,
+      },
+    })).agent.responses).toEqual({
+      reasoningEffort: 'xhigh',
+      reasoningContext: 'all_turns',
+      compactThreshold: 100_000,
+    });
+  });
+
+  test('rejects unknown providers and malformed Responses settings', () => {
+    expect(() => validateRecipe(recipe({ provider: 'openai-chat' }))).toThrow(/agent.provider/);
+    expect(() => validateRecipe(recipe({ responses: { reasoningEffort: 'ultra' } }))).toThrow(/reasoningEffort/);
+    expect(() => validateRecipe(recipe({ responses: { reasoningContext: 'previous_turn' } }))).toThrow(/reasoningContext/);
+    expect(() => validateRecipe(recipe({ responses: { compactThreshold: 0 } }))).toThrow(/compactThreshold/);
+  });
+});

package/test/recipe-timezone.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, test } from 'bun:test';
+import { validateRecipe } from '../src/recipe.js';
+
+function recipe(timezone?: unknown) {
+  return { name: 'tz', agent: { systemPrompt: 'test', ...(timezone === undefined ? {} : { timezone }) } };
+}
+
+describe('recipe agent.timezone validation', () => {
+  test('accepts an IANA timezone', () => {
+    expect(validateRecipe(recipe('America/Los_Angeles')).agent.timezone).toBe('America/Los_Angeles');
+  });
+
+  test('allows the setting to be omitted', () => {
+    expect(validateRecipe(recipe()).agent.timezone).toBeUndefined();
+  });
+
+  test('rejects invalid timezone names', () => {
+    expect(() => validateRecipe(recipe('Pacific/Definitely_Not'))).toThrow(/valid IANA time zone/);
+  });
+});

package/test/time-module.test.ts

@@ -0,0 +1,13 @@
+import { describe, expect, test } from 'bun:test';
+import { formatNow } from '../src/modules/time-module.js';
+
+describe('TimeModule presentation timezone', () => {
+  test('formats current time independently of the host timezone', () => {
+    expect(formatNow(new Date('2026-07-15T12:34:56.789Z'), 'America/Los_Angeles')).toEqual({
+      iso: '2026-07-15T05:34:56.789-07:00',
+      local: '2026-07-15T05:34:56.789-07:00 [America/Los_Angeles]',
+      timezone: 'America/Los_Angeles',
+      unixMs: 1_784_118_896_789,
+    });
+  });
+});

package/test/web-ui-context-coverage.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, test } from 'bun:test';
+import { buildContextCoverageSnapshot } from '../src/modules/web-ui-module.js';
+
+function contextManager(strategy: Record<string, unknown>) {
+  return {
+    currentBranch: () => ({ name: 'test-branch' }),
+    getStrategy: () => strategy,
+    getPendingWork: () => ({ description: 'Compressing chunk 2' }),
+  };
+}
+
+describe('context coverage snapshot', () => {
+  test('reports unbounded summary depth, selected depth, and queued work without text', () => {
+    const summaries = [
+      { id: 'L1-1', level: 1, content: 'secret one', tokens: 100, mergedInto: 'L2-3' },
+      { id: 'L1-2', level: 1, content: 'secret two', tokens: 120, mergedInto: 'L2-3' },
+      { id: 'L2-3', level: 2, content: 'secret parent', tokens: 80, mergedInto: 'L4-4' },
+      { id: 'L4-4', level: 4, content: 'secret root', tokens: 40 },
+    ];
+    const chunks = [
+      { index: 0, tokens: 300, compressed: true, summaryId: 'L1-1', messages: [{ id: 'm1' }, { id: 'm2' }] },
+      { index: 1, tokens: 200, compressed: true, summaryId: 'L1-2', messages: [{ id: 'm3' }] },
+      { index: 2, tokens: 250, compressed: false, messages: [{ id: 'm4' }] },
+    ];
+    const snapshot = buildContextCoverageSnapshot('fable', contextManager({
+      summaries,
+      chunks,
+      compressionQueue: [2],
+      mergeQueue: [{ level: 3, sourceIds: ['L2-a', 'L2-b'] }],
+      resolutions: new Map([['m1', 4], ['m2', 2], ['m3', 1]]),
+      pendingCompression: Promise.resolve(),
+    }));
+
+    expect(snapshot.branch).toBe('test-branch');
+    expect(snapshot.levels.map(level => level.level)).toEqual([1, 2, 4]);
+    expect(snapshot.chunks[0]).toMatchObject({ maxLevel: 4, selectedMin: 2, selectedMax: 4 });
+    expect(snapshot.chunks[2]).toMatchObject({ maxLevel: 0, queued: true });
+    expect(snapshot.queue).toMatchObject({
+      inFlight: true,
+      pending: 'Compressing chunk 2',
+      l1: [2],
+      merges: [{ targetLevel: 3, sourceCount: 2 }],
+    });
+    expect(JSON.stringify(snapshot)).not.toContain('secret');
+    expect(JSON.stringify(snapshot)).not.toContain('content');
+  });
+
+  test('stops coverage traversal at a dangling parent', () => {
+    const snapshot = buildContextCoverageSnapshot('fable', contextManager({
+      summaries: [{ id: 'L1-1', level: 1, tokens: 100, mergedInto: 'missing-L2' }],
+      chunks: [{ index: 0, tokens: 200, compressed: true, summaryId: 'L1-1', messages: [{ id: 'm1' }] }],
+      compressionQueue: [],
+      mergeQueue: [],
+      resolutions: new Map(),
+      pendingCompression: null,
+    }));
+
+    expect(snapshot.chunks[0].maxLevel).toBe(1);
+    expect(snapshot.queue.inFlight).toBe(false);
+  });
+});