@animalabs/connectome-host 0.3.5 → 0.3.8

package/test/agent-tree-reducer.test.ts

@@ -86,9 +86,12 @@ describe('AgentTreeReducer', () => {
   });
 
   test('inference:exhausted from in-band stream abort also produces cancelled (P1 #3)', () => {
-    // Postmortem 2026-05-28 F1: framework.ts:2108 emits inference:exhausted
-    // for budget-restart / stream-side cancel paths. Same semantics as
-    // aborted — benign termination, not a fault.
+    // Postmortem 2026-05-28 F1: AF used to emit inference:exhausted for
+    // budget-restart / stream-side cancel paths. Same semantics as aborted —
+    // benign termination, not a fault. AF PR #55 (≥ 0.6.5) suppresses the
+    // endTurn/budget-restart cases at the source, but genuine cancels and
+    // reboot-induced exhausted still arrive, and the mapping must keep
+    // handling streams from older AF.
     const r = new AgentTreeReducer();
     r.applyEvent({ type: 'inference:started', agentName: 'a', timestamp: ts(0) });
     r.applyEvent({ type: 'inference:exhausted', agentName: 'a', error: 'budget', timestamp: ts(1) });
@@ -97,6 +100,35 @@ describe('AgentTreeReducer', () => {
     expect(node.status).toBe('cancelled');
   });
 
+  test('inference:turn_ended is terminal in its own right (AF PR #55: no trailing exhausted)', () => {
+    // endTurn = the agent deliberately ended its turn — a successful
+    // terminal. Before AF PR #55 the terminal state of endTurn'd agents came
+    // from the SPURIOUS inference:exhausted the framework emitted right
+    // after; ≥ 0.6.5 no longer sends it, so without this transition an
+    // endTurn'd agent would sit in the tree as 'running' forever.
+    const r = new AgentTreeReducer();
+    r.applyEvent({ type: 'inference:started', agentName: 'a', timestamp: ts(0) });
+    r.applyEvent({ type: 'inference:turn_ended', agentName: 'a', timestamp: ts(1) });
+    const node = r.getNode('a')!;
+    expect(node.phase).toBe('done');
+    expect(node.status).toBe('completed');
+    expect(node.completedAt).toBe(ts(1));
+  });
+
+  test('older AF: the exhausted trailing an endTurn re-terminates as cancelled (harmless)', () => {
+    // Pre-0.6.5 streams still deliver turn_ended followed by the spurious
+    // exhausted. The node flips completed → cancelled one event later; both
+    // are terminal-and-benign, so renderers stay correct either way. Pinned
+    // so the compat behavior is a documented choice, not an accident.
+    const r = new AgentTreeReducer();
+    r.applyEvent({ type: 'inference:started', agentName: 'a', timestamp: ts(0) });
+    r.applyEvent({ type: 'inference:turn_ended', agentName: 'a', timestamp: ts(1) });
+    r.applyEvent({ type: 'inference:exhausted', agentName: 'a', error: 'Stream aborted: user', timestamp: ts(2) });
+    const node = r.getNode('a')!;
+    expect(node.phase).toBe('cancelled');
+    expect(node.status).toBe('cancelled');
+  });
+
   // Postmortem 2026-05-28 F1: the reducer never transitions status to 'completed'.
   // inference:completed only sets phase='done', leaving status='running' for the
   // entire lifetime of the agent — which is fine until a later aborted/exhausted/

package/test/autobio-progress-snapshot.test.ts

@@ -1,14 +1,32 @@
 import { describe, test, expect } from 'bun:test';
 import { AutobiographicalStrategy } from '@animalabs/agent-framework';
+import { ContextManager } from '@animalabs/context-manager';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+async function initializedStrategy() {
+  const root = mkdtempSync(join(tmpdir(), 'autobio-progress-'));
+  const path = join(root, 'store');
+  const strategy = new AutobiographicalStrategy({
+    compressionModel: 'claude-sonnet-4-5-20250929',
+    autoTickOnNewMessage: false,
+  });
+  const cm = await ContextManager.open({ path, strategy });
+  return {
+    strategy,
+    close: () => {
+      cm.close();
+      rmSync(root, { recursive: true, force: true });
+    },
+  };
+}
 
 // Guards against silent breakage if upstream renames the protected fields
 // that getProgressSnapshot reads. The shape is what warmup-session.ts relies on.
 describe('AutobiographicalStrategy.getProgressSnapshot', () => {
-  test('returns the expected shape on a fresh strategy', () => {
-    const strategy = new AutobiographicalStrategy({
-      compressionModel: 'claude-sonnet-4-5-20250929',
-      autoTickOnNewMessage: false,
-    });
+  test('returns the expected shape after branch state is initialized', async () => {
+    const { strategy, close } = await initializedStrategy();
     const snapshot = strategy.getProgressSnapshot();
     expect(snapshot).toEqual({
       totalChunks: 0,
@@ -18,16 +36,12 @@ describe('AutobiographicalStrategy.getProgressSnapshot', () => {
       summaryCounts: { l1: 0, l2: 0, l3: 0 },
       pending: false,
     });
+    close();
   });
 
-  test('exposes the keys warmup-session.ts depends on', () => {
-    const strategy = new AutobiographicalStrategy({
-      compressionModel: 'claude-sonnet-4-5-20250929',
-      autoTickOnNewMessage: false,
-    });
+  test('exposes the keys warmup-session.ts depends on', async () => {
+    const { strategy, close } = await initializedStrategy();
     const s = strategy.getProgressSnapshot();
-    // Property access — if any rename happens upstream these become undefined
-    // and the test fails loudly.
     expect(typeof s.totalChunks).toBe('number');
     expect(typeof s.chunksCompressed).toBe('number');
     expect(typeof s.l1QueueLength).toBe('number');
@@ -36,5 +50,6 @@ describe('AutobiographicalStrategy.getProgressSnapshot', () => {
     expect(typeof s.summaryCounts.l1).toBe('number');
     expect(typeof s.summaryCounts.l2).toBe('number');
     expect(typeof s.summaryCounts.l3).toBe('number');
+    close();
   });
 });

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/framework-fkm-composition.test.ts

@@ -0,0 +1,160 @@
+import { afterEach, describe, expect, test } from 'bun:test';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { buildFrameworkAgentConfig } from '../src/framework-agent-config.js';
+import { buildFrameworkStrategy } from '../src/framework-strategy.js';
+import { loadSavedRecipe, saveRecipe, validateRecipe } from '../src/recipe.js';
+
+function recipe(agent: Record<string, unknown> = {}) {
+  return {
+    name: 'framework-fkm-composition',
+    agent: {
+      systemPrompt: 'sys',
+      ...agent,
+    },
+  };
+}
+
+function strategyConfigView(strategy: object): Record<string, unknown> {
+  return (strategy as { config?: Record<string, unknown> }).config ?? {};
+}
+
+const tempDirs: string[] = [];
+
+afterEach(() => {
+  while (tempDirs.length > 0) {
+    rmSync(tempDirs.pop()!, { force: true, recursive: true });
+  }
+});
+
+describe('framework FKM composition', () => {
+  test('preserves the pre-merge AgentConfig shape field-for-field when FKM additions are omitted', () => {
+    const parsed = validateRecipe(recipe({
+      provider: 'openai-responses',
+      maxTokens: 4_096,
+      maxStreamTokens: 80_000,
+      contextBudgetTokens: 120_000,
+      cacheTtl: '5m',
+      responses: {
+        reasoningEffort: 'medium',
+        reasoningContext: 'current_turn',
+        serviceTier: 'priority',
+        compactThreshold: 90_000,
+      },
+      thinking: {
+        enabled: true,
+        budgetTokens: 1_024,
+      },
+      refusalHandling: {
+        autoRewind: true,
+        maxRewinds: 2,
+        announceHumanTurns: false,
+      },
+    }));
+    const strategy = { kind: 'baseline-strategy' } as never;
+
+    expect(buildFrameworkAgentConfig(parsed, 'agent', 'model', strategy)).toEqual({
+      name: 'agent',
+      model: 'model',
+      systemPrompt: 'sys',
+      maxTokens: 4_096,
+      maxStreamTokens: 80_000,
+      contextBudgetTokens: 120_000,
+      cacheTtl: '5m',
+      providerParams: {
+        reasoning: {
+          effort: 'medium',
+          context: 'current_turn',
+        },
+        service_tier: 'priority',
+        context_management: [{
+          type: 'compaction',
+          compact_threshold: 90_000,
+        }],
+      },
+      strategy,
+      thinking: {
+        enabled: true,
+        budgetTokens: 1_024,
+      },
+      refusalHandling: {
+        autoRewind: true,
+        maxRewinds: 2,
+        announceHumanTurns: false,
+      },
+    });
+  });
+
+  test('composes validation, serialization, and AF/CM wiring for the merged FKM settings without cross-agent bleed', () => {
+    const parsed = validateRecipe(recipe({
+      provider: 'openai-responses',
+      maxTokens: 4_096,
+      responses: {
+        reasoningEffort: 'high',
+        reasoningContext: 'all_turns',
+        serviceTier: 'priority',
+      },
+      sameRoundThinkTextPolicy: 'private',
+      refusalHandling: {
+        autoRewind: true,
+        primarySummaryFallback: {
+          enabled: true,
+          maxNewSummaries: 4,
+          requestBudgetTokens: 216_000,
+        },
+      },
+      strategy: {
+        type: 'autobiographical',
+        compressionRefusalCurveFallbacks: 2,
+        compressionContextBudgetTokens: 19_000,
+      },
+    }));
+
+    const dir = mkdtempSync(join(tmpdir(), 'connectome-fkm-'));
+    tempDirs.push(dir);
+    saveRecipe(dir, parsed);
+    const reloaded = loadSavedRecipe(dir);
+    expect(reloaded).not.toBeNull();
+
+    expect(reloaded!.agent.sameRoundThinkTextPolicy).toBe('private');
+    expect(reloaded!.agent.refusalHandling?.primarySummaryFallback).toEqual({
+      enabled: true,
+      maxNewSummaries: 4,
+      requestBudgetTokens: 216_000,
+    });
+    expect(reloaded!.agent.strategy?.compressionRefusalCurveFallbacks).toBe(2);
+    expect(reloaded!.agent.strategy?.compressionContextBudgetTokens).toBe(19_000);
+
+    const runtimeStrategy = buildFrameworkStrategy(reloaded!, 'model', 'America/Los_Angeles');
+    const runtimeConfig = strategyConfigView(runtimeStrategy);
+    expect(runtimeConfig.compressionRefusalCurveFallbacks).toBe(2);
+    expect(runtimeConfig.compressionContextBudgetTokens).toBe(19_000);
+
+    const agentConfig = buildFrameworkAgentConfig(reloaded!, 'agent', 'model', runtimeStrategy);
+    expect(agentConfig.sameRoundThinkTextPolicy).toBe('private');
+    expect(agentConfig.refusalHandling?.primarySummaryFallback).toEqual({
+      enabled: true,
+      maxNewSummaries: 4,
+      requestBudgetTokens: 216_000,
+    });
+    expect((agentConfig.providerParams as Record<string, unknown>).service_tier).toBe('priority');
+    expect(Object.keys(agentConfig.providerParams as Record<string, unknown>)
+      .filter((key) => key === 'service_tier')).toHaveLength(1);
+
+    const otherRecipe = validateRecipe(recipe({
+      strategy: {
+        type: 'autobiographical',
+        compressionRefusalCurveFallbacks: 0,
+        compressionContextBudgetTokens: 50_000,
+      },
+    }));
+    const otherStrategy = buildFrameworkStrategy(otherRecipe, 'other-model', 'America/Los_Angeles');
+    const otherConfig = strategyConfigView(otherStrategy);
+    expect(otherConfig.compressionRefusalCurveFallbacks).toBe(0);
+    expect(otherConfig.compressionContextBudgetTokens).toBe(50_000);
+    expect(otherConfig).not.toBe(runtimeConfig);
+    expect(runtimeConfig.compressionRefusalCurveFallbacks).toBe(2);
+    expect(runtimeConfig.compressionContextBudgetTokens).toBe(19_000);
+  });
+});

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-refusal.test.ts

@@ -0,0 +1,57 @@
+/**
+ * Off-path refusal dragnet (observability M3): the logging adapter fires
+ * onRefusal for refusals on complete() calls — the compression/summarizer
+ * path the framework's own noteRefusal never sees — and stays silent for
+ * streamed refusals (main driver's job) and non-refusal completions.
+ */
+import { test, expect } from 'bun:test';
+import { LoggingAnthropicAdapter } from '../src/logging-adapter.js';
+
+function makeAdapter() {
+  const adapter = new LoggingAnthropicAdapter({ apiKey: 'test-key' }, '/tmp/llm-test.jsonl', () => ({ enabled: false, budgetTokens: 0 }));
+  const fired: unknown[] = [];
+  adapter.onRefusal = (info) => fired.push(info);
+  const observe = (kind: 'complete' | 'stream', stopReason?: string, category?: string) =>
+    (adapter as unknown as {
+      observeCall: (k: string, t: string, d: number, req: unknown, raw: unknown, res?: unknown) => void;
+    }).observeCall(kind, new Date().toISOString(), 100,
+      { model: 'claude-fable-5', messages: new Array(37).fill({}) },
+      undefined,
+      stopReason
+        ? {
+            usage: { inputTokens: 64_000, outputTokens: 3, cacheReadTokens: 0, cacheCreationTokens: 0 },
+            stopReason,
+            raw: { stop_reason: stopReason, ...(category ? { stop_details: { category } } : {}) },
+          }
+        : undefined,
+    );
+  return { adapter, fired, observe };
+}
+
+test('complete() refusal fires the dragnet with category + size', () => {
+  const { fired, observe } = makeAdapter();
+  observe('complete', 'refusal', 'reasoning_extraction');
+  expect(fired.length).toBe(1);
+  expect(fired[0]).toMatchObject({
+    kind: 'complete',
+    category: 'reasoning_extraction',
+    model: 'claude-fable-5',
+    messages: 37,
+    inputTokens: 64_000,
+  });
+});
+
+test('streamed refusal does NOT fire (main driver already escalates those)', () => {
+  const { fired, observe } = makeAdapter();
+  observe('stream', 'refusal', 'cyber');
+  expect(fired.length).toBe(0);
+});
+
+test('non-refusal completions and throwing callbacks are harmless', () => {
+  const { adapter, fired, observe } = makeAdapter();
+  observe('complete', 'end_turn');
+  observe('complete');            // error path: no response at all
+  expect(fired.length).toBe(0);
+  adapter.onRefusal = () => { throw new Error('observer bug'); };
+  expect(() => observe('complete', 'refusal', 'cyber')).not.toThrow();
+});

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', () => {