@animalabs/connectome-host 0.3.5 → 0.3.7

package/src/recipe.ts

@@ -75,6 +75,10 @@ export interface RecipeStrategy {
 export interface RecipeAgent {
   name?: string;
   model?: string;
+  /** IANA zone used when rendering wall-clock times to the agent. */
+  timezone?: string;
+  /** Provider transport. Omitted preserves the historical Anthropic default. */
+  provider?: 'anthropic' | 'openai-responses';
   systemPrompt: string;
   maxTokens?: number;
   /**
@@ -86,9 +90,8 @@ export interface RecipeAgent {
   /** Per-agent context compile budget (input tokens). When unset, the
    *  ContextManager default (100k) applies. Raise for large-context models. */
   contextBudgetTokens?: number;
-  /** Prompt-cache TTL ('5m' | '1h') forwarded to the provider. Set '1h' for
-   *  agents whose reply cadence is slower than 5 minutes — avoids re-writing
-   *  the full context to cache after every gap. Unset: provider default (5m). */
+  /** Prompt-cache TTL ('5m' | '1h') forwarded to the provider. Defaults to
+   *  '1h'; set '5m' explicitly for high-frequency, sub-5-minute workloads. */
   cacheTtl?: '5m' | '1h';
   strategy?: RecipeStrategy;
   /**
@@ -100,6 +103,13 @@ export interface RecipeAgent {
     enabled: boolean;
     budgetTokens?: number;
   };
+  /** Stateless OpenAI Responses settings. Only used with
+   * `provider: "openai-responses"`. */
+  responses?: {
+    reasoningEffort?: 'none' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+    reasoningContext?: 'current_turn' | 'all_turns';
+    compactThreshold?: number;
+  };
   /**
    * Content-refusal handling. When `autoRewind` is on, a `stop_reason: refusal`
    * turn triggers an automatic rewind of the triggering turn + retry (keeping
@@ -500,6 +510,7 @@ export const DEFAULT_RECIPE: Recipe = {
   description: 'General-purpose assistant with tool access',
   agent: {
     name: 'agent',
+    cacheTtl: '1h',
     systemPrompt: [
       'You are a helpful assistant. You have access to tools provided by connected MCP servers.',
       'Use them to help the user with their tasks.',
@@ -678,6 +689,39 @@ export function validateRecipe(raw: unknown): Recipe {
     throw new Error('Recipe agent must have a "systemPrompt" string');
   }
 
+  if (agent.provider !== undefined && agent.provider !== 'anthropic' && agent.provider !== 'openai-responses') {
+    throw new Error(`Recipe agent.provider must be 'anthropic' or 'openai-responses', got ${JSON.stringify(agent.provider)}.`);
+  }
+
+  if (agent.timezone !== undefined) {
+    if (typeof agent.timezone !== 'string' || !agent.timezone.trim()) {
+      throw new Error('Recipe agent.timezone must be a non-empty IANA time zone string.');
+    }
+    try {
+      new Intl.DateTimeFormat('en-US', { timeZone: agent.timezone }).format(new Date(0));
+    } catch {
+      throw new Error(`Recipe agent.timezone is not a valid IANA time zone: ${JSON.stringify(agent.timezone)}.`);
+    }
+  }
+
+  if (agent.responses !== undefined) {
+    if (!agent.responses || typeof agent.responses !== 'object' || Array.isArray(agent.responses)) {
+      throw new Error('Recipe agent.responses must be an object.');
+    }
+    const responses = agent.responses as Record<string, unknown>;
+    const efforts = ['none', 'low', 'medium', 'high', 'xhigh', 'max'];
+    if (responses.reasoningEffort !== undefined && !efforts.includes(String(responses.reasoningEffort))) {
+      throw new Error(`Invalid agent.responses.reasoningEffort ${JSON.stringify(responses.reasoningEffort)}.`);
+    }
+    if (responses.reasoningContext !== undefined && responses.reasoningContext !== 'current_turn' && responses.reasoningContext !== 'all_turns') {
+      throw new Error(`Invalid agent.responses.reasoningContext ${JSON.stringify(responses.reasoningContext)}.`);
+    }
+    if (responses.compactThreshold !== undefined &&
+        (typeof responses.compactThreshold !== 'number' || responses.compactThreshold <= 0)) {
+      throw new Error('Recipe agent.responses.compactThreshold must be a positive number.');
+    }
+  }
+
   if (agent.maxStreamTokens !== undefined && (typeof agent.maxStreamTokens !== 'number' || agent.maxStreamTokens <= 0)) {
     throw new Error('Recipe agent.maxStreamTokens must be a positive number.');
   }
@@ -687,6 +731,7 @@ export function validateRecipe(raw: unknown): Recipe {
   if (agent.cacheTtl !== undefined && agent.cacheTtl !== '5m' && agent.cacheTtl !== '1h') {
     throw new Error(`Recipe agent.cacheTtl must be '5m' or '1h', got ${JSON.stringify(agent.cacheTtl)}.`);
   }
+  agent.cacheTtl ??= '1h';
 
   // Validate agent.thinking if present. Catches typos and constraint
   // violations (notably max_tokens > budget_tokens) at recipe-load time

package/src/strategies/frontdesk-strategy.ts

@@ -9,6 +9,7 @@ import type {
   SummaryEntry,
 } from '@animalabs/context-manager';
 import type { ContentBlock } from '@animalabs/membrane';
+import { formatZonedTime, resolveTimeZone } from '@animalabs/agent-framework';
 
 // Structural mirror of AutobiographicalStrategy's internal Chunk.
 // Kept inline because @animalabs/context-manager does not currently export it.
@@ -24,7 +25,7 @@ interface Chunk {
   phaseType?: string;
 }
 
-export type FrontdeskStrategyOptions = Partial<AutobiographicalConfig>;
+export type FrontdeskStrategyOptions = Partial<AutobiographicalConfig> & { timeZone?: string };
 
 /**
  * Chatbot-flavoured context strategy for agents that receive messages via
@@ -43,6 +44,13 @@ export class FrontdeskStrategy extends AutobiographicalStrategy {
   override readonly name: string = 'frontdesk';
 
   private salientSourceIds: Set<string> = new Set();
+  private readonly timeZone: string;
+
+  constructor(options: FrontdeskStrategyOptions = {}) {
+    const { timeZone, ...strategyOptions } = options;
+    super(strategyOptions);
+    this.timeZone = resolveTimeZone(timeZone);
+  }
 
   override select(
     store: MessageStoreView,
@@ -146,9 +154,7 @@ export class FrontdeskStrategy extends AutobiographicalStrategy {
     }
     if (!d && msgTs instanceof Date && !isNaN(msgTs.getTime())) d = msgTs;
     if (!d) return null;
-    const hh = String(d.getHours()).padStart(2, '0');
-    const mm = String(d.getMinutes()).padStart(2, '0');
-    return `${hh}:${mm}`;
+    return formatZonedTime(d, this.timeZone);
   }
 
   // ==========================================================================

package/src/web/protocol.ts

@@ -93,6 +93,9 @@ export interface WelcomeMessage {
   /** Per-agent cost breakdown for the parent process, present when the
    *  framework's usage tracker has data. Empty during cold start. */
   perAgentCost?: PerAgentCost[];
+  /** Recent provider calls with cache verdicts. Present when the host's
+   *  provider adapter exposes the call ledger. */
+  callLedger?: CallLedgerSnapshot;
 }
 
 /**
@@ -164,6 +167,91 @@ export interface UsageMessage {
   perAgentCost?: PerAgentCost[];
 }
 
+/** Live replacement snapshot emitted after each provider call. */
+export interface CallLedgerMessage {
+  type: 'call-ledger';
+  ledger: CallLedgerSnapshot;
+}
+
+export type CallLedgerVerdict =
+  | 'HIT'
+  | 'hit+extend'
+  | 'uncached'
+  | 'rewrite:expired'
+  | 'rewrite:prefix-mutated'
+  | 'rewrite:prefix-truncated'
+  | 'rewrite:unexplained'
+  | 'first-write'
+  | 'ERROR'
+  | 'empty'
+  | 'unknown';
+
+export interface CallLedgerRow {
+  id: string;
+  timestamp: string;
+  kind: 'complete' | 'stream';
+  /** Honest call-class estimate; `~` means the trigger plumbing did not
+   *  provide a definitive origin. */
+  originEstimate: 'turn~' | 'aux~';
+  model: string;
+  messages: number;
+  durationMs: number;
+  tokens: { input: number; output: number; cacheRead: number; cacheWrite: number };
+  cost?: CallCostBreakdown;
+  cache: {
+    /** Undefined for older compact logs that predate marker summaries. */
+    breakpoints?: number;
+    ttls: string[];
+    effectiveTtl: '5m' | '1h';
+  };
+  verdict: CallLedgerVerdict;
+  cause: string;
+  stopReason?: string;
+  error?: string;
+}
+
+export interface CallCostBreakdown {
+  input: number;
+  cacheWrite5m: number;
+  cacheWrite1h: number;
+  cacheRead: number;
+  output: number;
+  total: number;
+  currency: 'USD';
+  /** `billing` means every charged usage bucket and pricing modifier was
+   *  known. Unknown/mixed buckets are left unpriced rather than estimated. */
+  grade: 'billing';
+  pricingVersion: string;
+  rates: {
+    inputPerMillion: number;
+    outputPerMillion: number;
+    cacheWrite5mPerMillion: number;
+    cacheWrite1hPerMillion: number;
+    cacheReadPerMillion: number;
+  };
+}
+
+export interface CallLedgerSnapshot {
+  /** Oldest to newest; clients may reverse for display. */
+  rows: CallLedgerRow[];
+  summary: {
+    calls: number;
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    cacheHitRatio: number;
+    cost?: {
+      total: number;
+      currency: 'USD';
+      pricedCalls: number;
+      unpricedCalls: number;
+      pricingVersion: string;
+    };
+    byVerdict: Partial<Record<CallLedgerVerdict, number>>;
+  };
+}
+
 export interface TokenUsage {
   input: number;
   output: number;
@@ -352,6 +440,7 @@ export type WebUiServerMessage =
   | ChildEventMessage
   | CommandResultMessage
   | UsageMessage
+  | CallLedgerMessage
   | BranchChangedMessage
   | SessionChangedMessage
   | PeekMessage

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/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,
+    });
+  });
+});