@animalabs/connectome-host 0.7.4 → 0.8.1

package/src/web/panel-data.ts

@@ -589,6 +589,25 @@ export function buildHealthSnapshot(app: PanelAppRef): Record<string, unknown> {
   } catch {
     // Health reads never throw.
   }
+  // Compression DEBT per agent — the single-authority reduction from cm
+  // (healthy / degraded / critical + the numbers behind it). Every wedge of
+  // the 2026-08-06 five-resident day was weeks of silently-failing
+  // compression surfacing as a sudden budget crisis; this block is what
+  // lets fleet-watch (and later the resident notice, af #99) catch the
+  // debt while it is still cheap.
+  try {
+    const debt: Record<string, unknown> = {};
+    for (const agent of app.framework.getAllAgents()) {
+      const strategy = (agent.getContextManager() as unknown as {
+        getStrategy?: () => { getCompressionDebt?: () => unknown };
+      }).getStrategy?.();
+      const d = strategy?.getCompressionDebt?.();
+      if (d) debt[(agent as unknown as { name: string }).name] = d;
+    }
+    (snapshot as Record<string, unknown>).compressionDebt = debt;
+  } catch {
+    // Health reads never throw.
+  }
   // Rendered context COMPOSITION per agent — head / raw middle / summaries
   // by level / tail, as actually emitted by the last compile. Sourced from
   // the strategy's own render stats (already computed in-process), so it is
@@ -810,6 +829,23 @@ export function buildContextCoverageSnapshot(
   };
 }
 
+/**
+ * Best-effort mapping from an agent's configured model string to a bare
+ * Anthropic API model id for /v1/messages/count_tokens. Handles membrane /
+ * OpenRouter provider prefixes ("anthropic/claude-…", "…/anthropic/claude-…")
+ * and Bedrock ids ("us.anthropic.claude-…-v1:0"). Returns null for
+ * non-Anthropic models — exact counting is unsupported there, and reporting
+ * that honestly beats 404ing against a wrong tokenizer.
+ */
+export function anthropicCountModel(agentModel: string | undefined): string | null {
+  if (!agentModel) return null;
+  let m = agentModel;
+  const slash = m.lastIndexOf('/');
+  if (slash >= 0) m = m.slice(slash + 1);
+  m = m.replace(/^(us|eu|apac)\./, '').replace(/^anthropic\./, '').replace(/-v\d+:\d+$/, '');
+  return m.startsWith('claude') ? m : null;
+}
+
 /** Summary-tree coverage and queued work, with no message or summary text. */
 export function buildContextCoverage(app: PanelAppRef, agentName: string): ContextCoverageSnapshot {
   const agent = requireAgent(app, agentName);
@@ -855,8 +891,15 @@ export async function buildContextMakeup(app: PanelAppRef, agentName: string): P
     : (typeof sysRaw === 'string' ? sysRaw : undefined);
 
   let exactTotalTokens: number | null = null;
-  const countModel = process.env.COUNT_TOKENS_MODEL || 'anthropic/claude-opus-4.5';
+  // Count against the model the agent actually runs, not a hardcoded id:
+  // a stale/foreign id 404s and exact counts silently degrade to null on
+  // every install. COUNT_TOKENS_MODEL stays as an explicit operator override.
+  const countModel = process.env.COUNT_TOKENS_MODEL
+    || anthropicCountModel((agent as { model?: string }).model);
   let countSource = 'count_tokens';
+  if (!countModel) {
+    return { agent: agentName, stats, exactTotalTokens, countModel, countSource: 'count_tokens_unsupported_model' };
+  }
   try {
     const base = (process.env.ANTHROPIC_BASE_URL || 'https://api.anthropic.com').replace(/\/$/, '');
     const res = await fetch(base + '/v1/messages/count_tokens', {

package/src/workspace-mounts.ts

@@ -0,0 +1,73 @@
+/**
+ * Workspace mount construction — the single source of truth for which mounts
+ * a recipe's `modules.workspace` produces and with what flags.
+ *
+ * Used by BOTH the runtime (src/index.ts, to build the real WorkspaceModule
+ * config) and recipe validation (validateRecipe's instructions cross-check,
+ * which reasons about mount names, modes, and autoMaterialize). Keeping one
+ * builder prevents the validator from modeling a mount differently than the
+ * host constructs it — the exact split-brain the `_config` mount had when
+ * validation assumed it auto-materialized and the runtime built it without.
+ */
+
+import { join, resolve } from 'node:path';
+import type { MountConfig } from '@animalabs/agent-framework';
+import type { RecipeModules, RecipeWorkspaceMount } from './recipe.js';
+
+/**
+ * Build the mount list for a recipe's workspace declaration.
+ *
+ * Returns null when the workspace is disabled (`workspace: false`).
+ * `storePath` anchors the `_config` mount (session store config dir); pass
+ * any placeholder when only mount names/modes/flags are needed (validation).
+ */
+export function buildWorkspaceMounts(
+  workspace: RecipeModules['workspace'],
+  storePath: string,
+): MountConfig[] | null {
+  if (workspace === false) return null;
+
+  let mounts: MountConfig[];
+  if (typeof workspace === 'object' && workspace.mounts) {
+    // Only pass fields the recipe explicitly provides; let WorkspaceModule
+    // default the rest. watch is overridden to 'never' since the host does
+    // not need chokidar filesystem watchers by default.
+    mounts = workspace.mounts.map((m: RecipeWorkspaceMount) => {
+      const mount: MountConfig = {
+        name: m.name,
+        path: resolve(m.path),
+        mode: m.mode ?? 'read-write',
+        watch: m.watch ?? 'never',
+      };
+      if (m.ignore) mount.ignore = m.ignore;
+      if (m.maxFileSize !== undefined) mount.maxFileSize = m.maxFileSize;
+      if (m.wakeOnChange !== undefined) mount.wakeOnChange = m.wakeOnChange;
+      if (m.autoMaterialize !== undefined) mount.autoMaterialize = m.autoMaterialize;
+      return mount;
+    });
+  } else {
+    // Default: read-only input mount + read-write products mount.
+    mounts = [
+      { name: 'input', path: resolve('./input'), mode: 'read-only', watch: 'never' },
+      { name: 'products', path: resolve('./output'), mode: 'read-write', watch: 'never' },
+    ];
+  }
+
+  // Config mount: version-controls gate.json (and future config files) via
+  // Chronicle. Opt-in via recipe: workspace.configMount = true. NOTE: this
+  // mount is deliberately NOT autoMaterialize — the host re-materializes it
+  // explicitly after branch-changing commands, and ordinary agent edits stay
+  // Chronicle-side until then. Anything that assumes `_config` disk content
+  // tracks agent edits is wrong (see the instructions-path validation).
+  const wantConfigMount = typeof workspace === 'object' && workspace.configMount;
+  if (wantConfigMount) {
+    mounts.push({
+      name: '_config',
+      path: resolve(join(storePath, 'config')),
+      mode: 'read-write',
+      watch: 'always',
+    });
+  }
+
+  return mounts;
+}

package/test/audit-module-optins.test.ts

@@ -8,7 +8,7 @@
 
 import { describe, test, expect } from 'bun:test';
 import { mkdtempSync, writeFileSync, mkdirSync, readFileSync, statSync } from 'node:fs';
-import { join } from 'node:path';
+import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
 import { tmpdir } from 'node:os';
 import {
   classifyModule,
@@ -74,15 +74,22 @@ describe('auditRecipe', () => {
   });
 
   test('collects local fleet children, resolves relative paths, skips URLs', () => {
+    const parentPath = resolve('/deploy/recipes/parent.json');
     const a = auditRecipe(
       {
         name: 'parent',
         agent: AGENT,
         modules: { fleet: { children: [{ recipe: 'child.json' }, { recipe: 'https://x.example/c.json' }] } },
       },
-      '/deploy/recipes/parent.json',
+      parentPath,
     );
-    expect(a.childRecipePaths).toEqual(['/deploy/recipes/child.json']);
+
+    // The https child is skipped; the relative one resolves beside the parent.
+    expect(a.childRecipePaths).toHaveLength(1);
+    const [childPath] = a.childRecipePaths;
+    expect(isAbsolute(childPath)).toBe(true);
+    expect(dirname(childPath)).toBe(dirname(parentPath));
+    expect(basename(childPath)).toBe('child.json');
   });
 });
 

package/test/cache-keepalive-log.test.ts

@@ -0,0 +1,83 @@
+/**
+ * Keepalive events must ALL reach stderr.
+ *
+ * The host unit routes StandardError to service-stderr.log and leaves stdout on
+ * the journal, so an event written with console.log lands where no operator
+ * greps. That actually happened on fable-cm 2026-08-23: the keepalive refreshed
+ * a 523k prefix three times, correctly, while a monitor tailing
+ * service-stderr.log reported zero activity for three hours.
+ *
+ * These tests fail if anyone re-introduces severity routing.
+ */
+import { describe, test, expect } from 'bun:test';
+import {
+  logKeepaliveEvent,
+  formatKeepaliveEvent,
+  KEEPALIVE_LOG_PREFIX,
+} from '../src/cache-keepalive-log.js';
+import type { KeepaliveEvent } from '@animalabs/membrane';
+
+const EVENTS: KeepaliveEvent[] = [
+  { type: 'refreshed', key: 'k1', lane: 'stream', readTokens: 523102, idleMs: 2987020 },
+  { type: 'expired', key: 'k1', idleMs: 21600000 },
+  { type: 'ineffective', key: 'k1', reason: 'wrote-instead-of-read', readTokens: 0, writeTokens: 523102 },
+  { type: 'skipped', key: 'k1', reason: 'no-1h-breakpoint' },
+  { type: 'error', key: 'k1', error: '400 invalid_request_error', consecutive: 1 },
+  { type: 'disabled', reason: '3 consecutive keepalive failures' },
+];
+
+describe('keepalive event logging', () => {
+  test('every event type is written, none silently dropped', () => {
+    for (const event of EVENTS) {
+      const lines: string[] = [];
+      logKeepaliveEvent(event, (l) => lines.push(l));
+      expect(lines.length).toBe(1);
+    }
+  });
+
+  test('routine refreshes are logged, not filtered as noise', () => {
+    // The regression this guards: treating `refreshed` as too chatty to log
+    // leaves no positive evidence the feature ran at all.
+    const lines: string[] = [];
+    logKeepaliveEvent(EVENTS[0]!, (l) => lines.push(l));
+    expect(lines[0]).toContain('refreshed');
+    expect(lines[0]).toContain('523102');
+  });
+
+  test('lines carry the greppable prefix', () => {
+    for (const event of EVENTS) {
+      expect(formatKeepaliveEvent(event).startsWith(KEEPALIVE_LOG_PREFIX)).toBe(true);
+    }
+  });
+
+  test('the payload is machine-readable JSON after the prefix', () => {
+    const line = formatKeepaliveEvent(EVENTS[2]!);
+    const json = line.slice(KEEPALIVE_LOG_PREFIX.length).trim();
+    const parsed = JSON.parse(json) as { type: string; reason: string; writeTokens: number };
+    expect(parsed.type).toBe('ineffective');
+    expect(parsed.reason).toBe('wrote-instead-of-read');
+    expect(parsed.writeTokens).toBe(523102);
+  });
+
+  test('DEFAULT SINK IS STDERR for every event type — not stdout', () => {
+    // The actual bug. console.error -> stderr -> service-stderr.log;
+    // console.log -> stdout -> journal, where nobody looks.
+    const origLog = console.log;
+    const origErr = console.error;
+    const origWarn = console.warn;
+    const toStdout: string[] = [];
+    const toStderr: string[] = [];
+    try {
+      console.log = (...a: unknown[]) => { toStdout.push(String(a[0])); };
+      console.error = (...a: unknown[]) => { toStderr.push(String(a[0])); };
+      console.warn = (...a: unknown[]) => { toStderr.push(String(a[0])); };
+      for (const event of EVENTS) logKeepaliveEvent(event);
+    } finally {
+      console.log = origLog;
+      console.error = origErr;
+      console.warn = origWarn;
+    }
+    expect(toStderr.length).toBe(EVENTS.length);
+    expect(toStdout.length).toBe(0);
+  });
+});

package/test/commands-qa-family.test.ts

@@ -0,0 +1,239 @@
+import { describe, test, expect, afterEach } from 'bun:test';
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs';
+import { handleCommand, createBranchState } from '../src/commands.js';
+import { DEFAULT_CONFIG_PATH } from '../src/mcpl-config.js';
+
+// Regression tests for the QA-reported command family:
+// - first-token argument parsing truncated multi-word names on
+//   /checkpoint, /restore, /checkout, /session switch, /session delete
+//   (while /session rename accepted them — making renamed sessions
+//   unreachable by name);
+// - /session delete executed irreversibly with no confirmation;
+// - /mcp add on an existing server silently wiped its env vars;
+// - head-moving commands ran while a generation was in flight, letting
+//   the streaming reply commit onto the wrong branch (orphaned nodes);
+// - /budget displayed small values as "0k" (50 → "0k") while rejecting 0.
+
+interface StubMessage { id: string; participant: string; content: unknown[] }
+
+function makeStubWorld(agentStatus: string | undefined = 'idle') {
+  const messagesByBranch = new Map<string, StubMessage[]>([['main', []]]);
+  let currentName = 'main';
+  let msgCounter = 0;
+
+  const cm = {
+    currentBranch: () => ({ id: currentName, name: currentName, head: messagesByBranch.get(currentName)!.length }),
+    listBranches: () => [...messagesByBranch.keys()].map(name => ({ id: name, name, head: messagesByBranch.get(name)!.length })),
+    queryMessages: (_q: unknown) => ({ messages: messagesByBranch.get(currentName)! }),
+    branchAt: (messageId: string, newName: string): string => {
+      const msgs = messagesByBranch.get(currentName)!;
+      const idx = msgs.findIndex(m => m.id === messageId);
+      if (idx === -1) throw new Error(`Message not found: ${messageId}`);
+      messagesByBranch.set(newName, msgs.slice(0, idx + 1));
+      return newName;
+    },
+    switchBranch: async (name: string): Promise<void> => {
+      if (!messagesByBranch.has(name)) throw new Error(`No such branch: ${name}`);
+      currentName = name;
+    },
+  };
+
+  const agent = {
+    name: 'stub-agent',
+    ...(agentStatus !== undefined ? { state: { status: agentStatus } } : {}),
+    getContextManager: () => cm,
+  };
+
+  const deleted: string[] = [];
+  const sessions = [
+    { id: 'aaaa1111', name: 'Renamed Multi Word Name', manuallyNamed: true, createdAt: 't', lastAccessedAt: 't', messageCount: 3 },
+    { id: 'bbbb2222', name: 'other', manuallyNamed: true, createdAt: 't', lastAccessedAt: 't', messageCount: 1 },
+  ];
+
+  const app = {
+    framework: {
+      getAgent: () => undefined,
+      getAllAgents: () => [agent],
+      getAllModules: () => [],
+    },
+    sessionManager: {
+      listSessions: () => sessions,
+      getActiveSession: () => sessions[1],
+      findSession: (nameOrId: string) =>
+        sessions.find(s => s.id === nameOrId || s.id.startsWith(nameOrId) || s.name === nameOrId),
+      deleteSession: (id: string) => { deleted.push(id); },
+    },
+    branchState: createBranchState(),
+  } as any;
+
+  const addMessage = (participant = 'user'): StubMessage => {
+    const msg: StubMessage = { id: `m${++msgCounter}`, participant, content: [] };
+    messagesByBranch.get(currentName)!.push(msg);
+    return msg;
+  };
+
+  const text = (r: { lines: Array<{ text: string }> }) => r.lines.map(l => l.text).join('\n');
+
+  return { cm, app, addMessage, deleted, text, currentName: () => currentName };
+}
+
+describe('multi-word names: rest-of-line parsing', () => {
+  test('/checkpoint saves the full multi-word name', () => {
+    const { app, addMessage } = makeStubWorld();
+    addMessage(); addMessage('agent');
+    handleCommand('/checkpoint my test point', app);
+    expect(app.branchState.checkpoints.has('my test point')).toBe(true);
+    expect(app.branchState.checkpoints.has('my')).toBe(false);
+  });
+
+  test('/restore finds a multi-word checkpoint', async () => {
+    const { app, addMessage, text } = makeStubWorld();
+    addMessage(); addMessage('agent');
+    handleCommand('/checkpoint some check point', app);
+    addMessage(); addMessage('agent');
+    const r = handleCommand('/restore some check point', app);
+    expect(text(r)).not.toContain('not found');
+    await r.asyncWork;
+  });
+
+  test('/session switch reaches a multi-word-renamed session', () => {
+    const { app, text } = makeStubWorld();
+    const r = handleCommand('/session switch Renamed Multi Word Name', app);
+    expect(text(r)).toContain('Switching to session');
+    expect(r.switchToSessionId).toBe('aaaa1111');
+  });
+
+  test('/checkout passes the full name through (not found reported honestly)', () => {
+    const { app, text } = makeStubWorld();
+    const r = handleCommand('/checkout my branch name', app);
+    expect(text(r)).toContain('Branch "my branch name" not found');
+  });
+});
+
+describe('/session delete confirmation', () => {
+  test('bare delete shows the match and asks for --confirm, deletes nothing', () => {
+    const { app, deleted, text } = makeStubWorld();
+    const r = handleCommand('/session delete other', app);
+    expect(deleted).toEqual([]);
+    expect(text(r)).toContain('irreversible');
+    expect(text(r)).toContain('--confirm');
+    expect(text(r)).toContain('bbbb2222');
+  });
+
+  test('delete with --confirm deletes', () => {
+    const { app, deleted } = makeStubWorld();
+    handleCommand('/session delete other --confirm', app);
+    expect(deleted).toEqual(['bbbb2222']);
+  });
+
+  test('multi-word name + --confirm parses both correctly', () => {
+    const { app, deleted } = makeStubWorld();
+    handleCommand('/session delete Renamed Multi Word Name --confirm', app);
+    expect(deleted).toEqual(['aaaa1111']);
+  });
+});
+
+describe('in-flight guard on head-moving commands', () => {
+  for (const cmd of ['/undo', '/redo', '/checkout main', '/newtopic', '/branchto m1']) {
+    test(`${cmd} is refused while streaming`, () => {
+      const { app, addMessage, text } = makeStubWorld('streaming');
+      addMessage(); addMessage('agent');
+      const r = handleCommand(cmd, app);
+      expect(text(r)).toContain('refused: a turn is in flight');
+      expect(r.asyncWork).toBeUndefined();
+    });
+  }
+
+  test('/undo proceeds when idle', () => {
+    const { app, addMessage, text } = makeStubWorld('idle');
+    addMessage(); addMessage('agent');
+    const r = handleCommand('/undo', app);
+    expect(text(r)).toContain('Undoing');
+  });
+
+  test('agents without state (stubs) are treated as idle', () => {
+    const { app, addMessage, text } = makeStubWorld(undefined);
+    addMessage(); addMessage('agent');
+    const r = handleCommand('/undo', app);
+    expect(text(r)).toContain('Undoing');
+  });
+});
+
+describe('checkpoint visibility', () => {
+  test('/branches lists checkpoints alongside branches', () => {
+    const { app, addMessage, text } = makeStubWorld();
+    addMessage(); addMessage('agent');
+    handleCommand('/checkpoint visible point', app);
+    const r = handleCommand('/branches', app);
+    expect(text(r)).toContain('Checkpoints (1');
+    expect(text(r)).toContain('visible point');
+  });
+
+  test('bare /checkpoint lists existing checkpoints', () => {
+    const { app, addMessage, text } = makeStubWorld();
+    addMessage(); addMessage('agent');
+    handleCommand('/checkpoint alpha', app);
+    const r = handleCommand('/checkpoint', app);
+    expect(text(r)).toContain('alpha');
+  });
+});
+
+describe('/budget honest display', () => {
+  function makeBudgetApp(maxStreamTokens: number, last = 0) {
+    return {
+      framework: {
+        getAgent: () => undefined,
+        getAllAgents: () => [{ name: 'a', maxStreamTokens, lastStreamInputTokens: last, getContextManager: () => null }],
+        getAllModules: () => [],
+      },
+      branchState: createBranchState(),
+    } as any;
+  }
+
+  test('small values display exactly, not as 0k', () => {
+    const app = makeBudgetApp(1000);
+    const r = handleCommand('/budget 50', app);
+    expect(r.lines[0]!.text).toContain('50 tokens');
+    expect(r.lines[0]!.text).not.toContain('0k');
+  });
+
+  test('show branch displays small budgets exactly', () => {
+    const app = makeBudgetApp(50, 12);
+    const r = handleCommand('/budget', app);
+    expect(r.lines.map(l => l.text).join('\n')).toContain('a: 50 (last: 12');
+  });
+});
+
+describe('/mcp add preserves env on overwrite', () => {
+  // handleMcp* read/write DEFAULT_CONFIG_PATH (cwd/mcpl-servers.json, which
+  // is gitignored). Skip rather than clobber if a real config exists.
+  const hadFile = existsSync(DEFAULT_CONFIG_PATH);
+  const original = hadFile ? readFileSync(DEFAULT_CONFIG_PATH, 'utf-8') : null;
+
+  afterEach(() => {
+    if (original !== null) writeFileSync(DEFAULT_CONFIG_PATH, original);
+    else if (existsSync(DEFAULT_CONFIG_PATH)) unlinkSync(DEFAULT_CONFIG_PATH);
+  });
+
+  test('overwriting the command keeps env vars and reports them', () => {
+    const app = { framework: { getAllAgents: () => [], getAllModules: () => [] }, branchState: createBranchState() } as any;
+    handleCommand('/mcp add envtest echo hello', app);
+    handleCommand('/mcp env envtest FOO=bar SECRET=hunter2', app);
+    const r = handleCommand('/mcp add envtest echo goodbye', app);
+
+    const saved = JSON.parse(readFileSync(DEFAULT_CONFIG_PATH, 'utf-8')).mcplServers;
+    expect(saved.envtest.env).toEqual({ FOO: 'bar', SECRET: 'hunter2' });
+    expect(saved.envtest.command).toBe('echo');
+    expect(saved.envtest.args).toEqual(['goodbye']);
+    expect(r.lines.map(l => l.text).join('\n')).toContain('kept env: FOO, SECRET');
+  });
+
+  test('old args are dropped when the new command line has none', () => {
+    const app = { framework: { getAllAgents: () => [], getAllModules: () => [] }, branchState: createBranchState() } as any;
+    handleCommand('/mcp add argtest echo one two', app);
+    handleCommand('/mcp add argtest ls', app);
+    const saved = JSON.parse(readFileSync(DEFAULT_CONFIG_PATH, 'utf-8')).mcplServers;
+    expect(saved.argtest.command).toBe('ls');
+    expect(saved.argtest.args).toBeUndefined();
+  });
+});

package/test/conversations-recipe.test.ts

@@ -0,0 +1,142 @@
+/**
+ * Recipe surface for per-channel conversation routing:
+ * schema validation of the `conversations` block, and the host-side mapping
+ * to the framework's ConversationRouterConfig (templateAgent auto-filled
+ * from the recipe agent, strategyFactory building fresh per-fork strategy
+ * instances from the recipe's own strategy config).
+ */
+import { describe, test, expect } from 'bun:test';
+import { validateRecipe, type Recipe } from '../src/recipe.js';
+import { buildConversationsConfig } from '../src/framework-strategy.js';
+
+function baseRecipe(extra: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    name: 'Test',
+    agent: { name: 'sherlock', systemPrompt: 'test' },
+    ...extra,
+  };
+}
+
+describe('validateRecipe — conversations schema', () => {
+  test('absent block is accepted', () => {
+    expect(() => validateRecipe(baseRecipe())).not.toThrow();
+  });
+
+  test('full valid block is accepted', () => {
+    expect(() => validateRecipe(baseRecipe({
+      conversations: {
+        bind: { dm: 'always', groupDm: 'always', channel: 'mention' },
+        trigger: { dm: 'always', groupDm: 'mention', channel: 'mention' },
+        idleTtlMs: 12 * 60 * 60 * 1000,
+        closurePrompt: 'Finalize the case report and post the answer.',
+        agentPrefix: 'case',
+      },
+    }))).not.toThrow();
+  });
+
+  test('empty object is accepted (all defaults come from the framework)', () => {
+    expect(() => validateRecipe(baseRecipe({ conversations: {} }))).not.toThrow();
+  });
+
+  test('non-object block is rejected', () => {
+    expect(() => validateRecipe(baseRecipe({ conversations: true }))).toThrow(/must be an object/);
+    expect(() => validateRecipe(baseRecipe({ conversations: [] }))).toThrow(/must be an object/);
+  });
+
+  test('unknown top-level conversation field is rejected rather than silently ignored', () => {
+    expect(() => validateRecipe(baseRecipe({
+      conversations: { idleTTLms: 1000 },
+    }))).toThrow(/unknown field \"idleTTLms\"/);
+  });
+
+  test('unknown channel kind is rejected', () => {
+    expect(() => validateRecipe(baseRecipe({
+      conversations: { bind: { thread: 'always' } },
+    }))).toThrow(/unknown channel kind "thread"/);
+  });
+
+  test('invalid bind rule is rejected', () => {
+    expect(() => validateRecipe(baseRecipe({
+      conversations: { bind: { channel: 'sometimes' } },
+    }))).toThrow(/conversations\.bind\.channel/);
+  });
+
+  test("trigger rule 'never' is rejected (bind-only rule)", () => {
+    expect(() => validateRecipe(baseRecipe({
+      conversations: { trigger: { channel: 'never' } },
+    }))).toThrow(/conversations\.trigger\.channel/);
+  });
+
+  test('non-positive idleTtlMs is rejected', () => {
+    expect(() => validateRecipe(baseRecipe({ conversations: { idleTtlMs: 0 } })))
+      .toThrow(/idleTtlMs/);
+    expect(() => validateRecipe(baseRecipe({ conversations: { idleTtlMs: -5 } })))
+      .toThrow(/idleTtlMs/);
+    for (const bad of [Number.NaN, Number.POSITIVE_INFINITY, 1.5]) {
+      expect(() => validateRecipe(baseRecipe({ conversations: { idleTtlMs: bad } })))
+        .toThrow(/idleTtlMs/);
+    }
+  });
+
+  test('blank closurePrompt is rejected', () => {
+    expect(() => validateRecipe(baseRecipe({ conversations: { closurePrompt: '  ' } })))
+      .toThrow(/closurePrompt/);
+  });
+
+  test('agentPrefix with unsafe characters is rejected', () => {
+    for (const bad of ['with space', 'slash/py', 'dot.seg', '']) {
+      expect(() => validateRecipe(baseRecipe({ conversations: { agentPrefix: bad } })))
+        .toThrow(/agentPrefix/);
+    }
+    expect(() => validateRecipe(baseRecipe({ conversations: { agentPrefix: 'case-fork_2' } })))
+      .not.toThrow();
+  });
+});
+
+describe('buildConversationsConfig — recipe → FrameworkConfig mapping', () => {
+  const recipe = validateRecipe(baseRecipe({
+    conversations: {
+      bind: { channel: 'mention' },
+      idleTtlMs: 3600_000,
+      agentPrefix: 'case',
+    },
+  })) as Recipe;
+
+  test('returns undefined when the recipe has no conversations block', () => {
+    const bare = validateRecipe(baseRecipe()) as Recipe;
+    expect(buildConversationsConfig(bare, 'sherlock', 'model-x', 'UTC')).toBeUndefined();
+  });
+
+  test('templateAgent is auto-filled with the host agent name', () => {
+    const cfg = buildConversationsConfig(recipe, 'sherlock', 'model-x', 'UTC');
+    expect(cfg?.templateAgent).toBe('sherlock');
+  });
+
+  test('recipe fields pass through; omitted fields stay absent for framework defaults', () => {
+    const cfg = buildConversationsConfig(recipe, 'sherlock', 'model-x', 'UTC')!;
+    expect(cfg.bind).toEqual({ channel: 'mention' });
+    expect(cfg.idleTtlMs).toBe(3600_000);
+    expect(cfg.agentPrefix).toBe('case');
+    expect('trigger' in cfg).toBe(false);
+    expect('closurePrompt' in cfg).toBe(false);
+  });
+
+  test('strategyFactory builds a FRESH strategy instance per call', () => {
+    const cfg = buildConversationsConfig(recipe, 'sherlock', 'model-x', 'UTC')!;
+    expect(cfg.strategyFactory).toBeDefined();
+    const a = cfg.strategyFactory!();
+    const b = cfg.strategyFactory!();
+    expect(a).toBeDefined();
+    expect(b).toBeDefined();
+    expect(a).not.toBe(b);
+  });
+
+  test('strategyFactory honors the recipe strategy type', () => {
+    const passthrough = validateRecipe(baseRecipe({
+      agent: { name: 'p', systemPrompt: 't', strategy: { type: 'passthrough' } },
+      conversations: {},
+    })) as Recipe;
+    const cfg = buildConversationsConfig(passthrough, 'p', 'model-x', 'UTC')!;
+    expect(cfg.strategyFactory!().constructor.name).toBe('PassthroughStrategy');
+  });
+});

package/test/count-tokens-model.test.ts

@@ -0,0 +1,31 @@
+import { describe, test, expect } from 'bun:test';
+import { anthropicCountModel } from '../src/web/panel-data.js';
+
+// Regression: the makeup panel's exact token count used to call count_tokens
+// with a hardcoded provider-prefixed id, which the Anthropic endpoint 404s —
+// so exactTotalTokens was silently null on every install. The count model is
+// now derived from the model the agent actually runs.
+
+describe('anthropicCountModel', () => {
+  test('strips a membrane/OpenRouter provider prefix', () => {
+    expect(anthropicCountModel('anthropic/claude-opus-4-6')).toBe('claude-opus-4-6');
+  });
+
+  test('passes a bare Anthropic id through', () => {
+    expect(anthropicCountModel('claude-sonnet-5')).toBe('claude-sonnet-5');
+  });
+
+  test('normalizes a Bedrock id (region + vendor prefix + version suffix)', () => {
+    expect(anthropicCountModel('us.anthropic.claude-3-sonnet-20240229-v1:0'))
+      .toBe('claude-3-sonnet-20240229');
+  });
+
+  test('returns null for non-Anthropic models', () => {
+    expect(anthropicCountModel('openai/gpt-5.6-sol')).toBeNull();
+    expect(anthropicCountModel('gemini-2.5-pro')).toBeNull();
+  });
+
+  test('returns null for undefined', () => {
+    expect(anthropicCountModel(undefined)).toBeNull();
+  });
+});