@animalabs/connectome-host 0.8.0 → 0.8.1

package/src/modules/web-ui-module.ts

@@ -902,6 +902,15 @@ export class WebUiModule implements Module {
 
   private async handleHttp(req: Request, server: ReturnType<typeof Bun.serve>): Promise<Response> {
     const url = new URL(req.url);
+
+    // Every HTTP route here is read-only — mutation happens over the WS.
+    // Wrong methods used to fall through to the same handlers (a POST
+    // /debug/context behaved exactly like the GET), which lies to API
+    // consumers probing the surface.
+    if (req.method !== 'GET' && req.method !== 'HEAD') {
+      return new Response('Method Not Allowed', { status: 405, headers: { allow: 'GET, HEAD' } });
+    }
+
     const isRetrievalTraceRoute = url.pathname === '/debug/retrieval'
       || url.pathname === '/debug/retrieval/view';
 
@@ -1073,9 +1082,20 @@ export class WebUiModule implements Module {
       return this.serveWorkspaceFile(url.pathname.slice('/files/'.length));
     }
 
-    // Static SPA
+    // API namespace exhausted: anything still unmatched under /debug/ is a
+    // typo, wrong casing, or trailing slash — an honest 404 beats the SPA
+    // shell with a 200, which API consumers can't tell from data. (This was
+    // also the mechanism that swallowed real failures like the tokenizer
+    // 404 — the client saw 200/HTML instead of the error.)
+    if (url.pathname.startsWith('/debug/')) {
+      return Response.json({ error: `Unknown debug route: ${url.pathname}` }, { status: 404 });
+    }
+
+    // Static SPA. Bundle assets get real 404s: falling back to index.html
+    // for a missing /assets/*.js serves HTML where the browser expects JS —
+    // a blank page with a MIME error instead of a diagnosable miss.
     const requested = url.pathname === '/' ? '/index.html' : url.pathname;
-    return this.serveStatic(requested);
+    return this.serveStatic(requested, { spaFallback: !url.pathname.startsWith('/assets/') });
   }
 
   /** The minimal app slice the shared panel-data layer needs, or null before
@@ -1281,7 +1301,11 @@ export class WebUiModule implements Module {
     }
   }
 
-  private async serveStatic(requestedPath: string): Promise<Response> {
+  private async serveStatic(
+    requestedPath: string,
+    opts: { spaFallback?: boolean } = {},
+  ): Promise<Response> {
+    const spaFallback = opts.spaFallback ?? true;
     // Path containment: resolve and verify the result is still under staticRoot.
     // Plain startsWith without a separator is unsafe — both `<root>` and
     // `<root>-evil/...` pass `startsWith('<root>')`. The current callers
@@ -1297,11 +1321,15 @@ export class WebUiModule implements Module {
     try {
       const s = await stat(safePath);
       if (s.isDirectory()) {
-        return this.serveStatic(join(requestedPath, 'index.html'));
+        return this.serveStatic(join(requestedPath, 'index.html'), opts);
       }
       const data = await readFile(safePath);
       return new Response(data, { headers: { 'content-type': mimeFor(safePath) } });
     } catch {
+      // Missing bundle assets are honest misses, not SPA routes.
+      if (!spaFallback) {
+        return new Response('Not Found', { status: 404 });
+      }
       // Fall back to index.html so the SPA can handle client-side routing.
       try {
         const indexPath = join(sharedServer!.staticRoot, 'index.html');

package/src/recipe.ts

@@ -62,6 +62,14 @@ export interface RecipeStrategy {
   compressionMergeSourceOnly?: boolean;
   /** Preserve ordinary merge retries, then use target-only on the final attempt. */
   compressionMergeSourceOnlyFallback?: boolean;
+  /** Context Manager split-stitch L1 fallback rung (default off). */
+  compressionSplitFallback?: boolean;
+  /** Allow a single-message placeholder inside a split-stitched L1 (default off). */
+  compressionSplitPlaceholder?: boolean;
+  /** Split-stitch: max sub-calls per chunk (default 40). */
+  compressionSplitMaxCallsPerChunk?: number;
+  /** Split-stitch: max sub-calls per strategy instance per 10-minute in-memory window (default 80). */
+  compressionSplitMaxCallsPer10Min?: number;
   /** Token budget for prior recall-pair context in compression/merge
    * requests (Context Manager `compressionRecallBudgetTokens`). */
   compressionRecallBudgetTokens?: number;
@@ -69,6 +77,7 @@ export interface RecipeStrategy {
   recallHeaderTemplate?: string;
   targetChunkTokens?: number;
   mergeThreshold?: number;
+  mergeMaxSourceSpanMessages?: number;
   summaryTargetTokens?: number;
   /** Standing production target: keep the summary forest deep enough to fit
    *  this budget, enabling a later live-budget descent with no fold-storm and
@@ -239,6 +248,8 @@ export interface RecipeAgent {
    * Default 'locus'.
    */
   proseRouting?: 'locus' | 'explicit' | 'hybrid' | 'disabled';
+  /** Default-off containment of whole-response prose wrappers for known tools. */
+  toolWrapperProseGuard?: boolean;
   /**
    * Extra Anthropic beta flags sent as the `anthropic-beta` header on every
    * request (e.g. `["context-1m-2025-08-07"]` for the 1M context window on
@@ -852,6 +863,30 @@ export interface RecipeCodeExecution {
   idleReclaimMs?: number;
 }
 
+/**
+ * The subconscious resident (agent-framework FrameworkConfig.subconscious,
+ * issue agent-framework#77 — tune-out): a persistent same-model side-agent
+ * that receives traffic from channels the resident has tuned out and
+ * reports to them in its own voice. Passed through verbatim; the framework
+ * owns the defaults (name `Subconscious`, model = the resident's).
+ */
+export interface RecipeSubconscious {
+  /** Master switch. Without it the `tune_out` tool is not offered. */
+  enabled: boolean;
+  /** Registry + participant name (default 'Subconscious'). */
+  name?: string;
+  /** Model id (default: the resident's model — same-model side-process). */
+  model?: string;
+  /** The voice/criteria mode block: report-shaped, second person toward the
+   *  resident. Co-authored with the resident; canary before fleet use. */
+  systemPrompt: string;
+  /** Allow `speak_in_channel` (default false until the voice block has
+   *  passed its canary). */
+  allowChannelSpeech?: boolean;
+  /** WindowedPassthroughStrategy re-anchor fraction in (0, 1] (default 0.5). */
+  reAnchorFraction?: number;
+}
+
 /**
  * Per-channel conversation routing (agent-framework ConversationRouter):
  * the recipe's agent becomes a dormant "trunk" template, and qualifying
@@ -901,6 +936,8 @@ export interface Recipe {
   codeExecution?: RecipeCodeExecution;
   /** Per-channel conversation routing — fork-per-channel from this agent. */
   conversations?: RecipeConversations;
+  /** Tune-out's subconscious resident (agent-framework#77). */
+  subconscious?: RecipeSubconscious;
 }
 
 // ---------------------------------------------------------------------------
@@ -1294,6 +1331,10 @@ export function validateRecipe(raw: unknown): Recipe {
     throw new Error(`Recipe agent.proseRouting must be 'locus', 'explicit', 'hybrid', or 'disabled', got ${JSON.stringify(agent.proseRouting)}.`);
   }
 
+  if (agent.toolWrapperProseGuard !== undefined && typeof agent.toolWrapperProseGuard !== 'boolean') {
+    throw new Error(`Recipe agent.toolWrapperProseGuard must be a boolean, got ${JSON.stringify(agent.toolWrapperProseGuard)}.`);
+  }
+
   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.');
@@ -1555,11 +1596,19 @@ export function validateRecipe(raw: unknown): Recipe {
       'compressionSourceOnlyFallback',
       'compressionMergeSourceOnly',
       'compressionMergeSourceOnlyFallback',
+      'compressionSplitFallback',
+      'compressionSplitPlaceholder',
     ] as const) {
       if (strategy[key] !== undefined && typeof strategy[key] !== 'boolean') {
         throw new Error(`Recipe agent.strategy.${key} must be a boolean.`);
       }
     }
+    for (const key of ['compressionSplitMaxCallsPerChunk', 'compressionSplitMaxCallsPer10Min'] as const) {
+      const value = strategy[key];
+      if (value !== undefined && (typeof value !== 'number' || !Number.isSafeInteger(value) || value <= 0)) {
+        throw new Error(`Recipe agent.strategy.${key} must be a positive safe integer.`);
+      }
+    }
     if (
       strategy.compressionRecallBudgetTokens !== undefined
       && (
@@ -1991,6 +2040,46 @@ export function validateRecipe(raw: unknown): Recipe {
     }
   }
 
+  if (obj.subconscious !== undefined) {
+    if (!obj.subconscious || typeof obj.subconscious !== 'object' || Array.isArray(obj.subconscious)) {
+      throw new Error('Recipe subconscious must be an object.');
+    }
+    const sub = obj.subconscious as Record<string, unknown>;
+    const allowedSubconsciousKeys = new Set([
+      'enabled', 'name', 'model', 'systemPrompt', 'allowChannelSpeech', 'reAnchorFraction',
+    ]);
+    for (const key of Object.keys(sub)) {
+      if (!allowedSubconsciousKeys.has(key)) {
+        throw new Error(
+          `Recipe subconscious has unknown field ${JSON.stringify(key)} ` +
+          `(expected one of: ${[...allowedSubconsciousKeys].join(', ')}).`,
+        );
+      }
+    }
+    if (typeof sub.enabled !== 'boolean') {
+      throw new Error('Recipe subconscious.enabled must be a boolean.');
+    }
+    // The mode block is the subconscious's whole character; an enabled
+    // subconscious without one would run on an empty system prompt.
+    if (typeof sub.systemPrompt !== 'string' || !sub.systemPrompt.trim()) {
+      throw new Error('Recipe subconscious.systemPrompt must be a non-empty string.');
+    }
+    for (const k of ['name', 'model'] as const) {
+      if (sub[k] !== undefined && (typeof sub[k] !== 'string' || !(sub[k] as string).trim())) {
+        throw new Error(`Recipe subconscious.${k} must be a non-empty string.`);
+      }
+    }
+    if (sub.allowChannelSpeech !== undefined && typeof sub.allowChannelSpeech !== 'boolean') {
+      throw new Error('Recipe subconscious.allowChannelSpeech must be a boolean.');
+    }
+    if (sub.reAnchorFraction !== undefined) {
+      const f = sub.reAnchorFraction;
+      if (typeof f !== 'number' || !(f > 0 && f <= 1)) {
+        throw new Error('Recipe subconscious.reAnchorFraction must be a number in (0, 1].');
+      }
+    }
+  }
+
   if (obj.conversations !== undefined) {
     if (!obj.conversations || typeof obj.conversations !== 'object' || Array.isArray(obj.conversations)) {
       throw new Error('Recipe conversations must be an object.');

package/src/web/panel-data.ts

@@ -829,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);
@@ -874,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/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/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();
+  });
+});

package/test/framework-strategy-defaults.test.ts

@@ -61,6 +61,47 @@ describe('standard-recipe memory defaults', () => {
     expect(config.foldingStrategy).toBeUndefined();
   });
 
+  test('compressionSplitFallback / compressionSplitPlaceholder pass through and stay omitted when omitted', () => {
+    const on = buildFrameworkStrategy(
+      recipe({ name: 'Mira', strategy: { type: 'autobiographical', compressionSplitFallback: true, compressionSplitPlaceholder: true } }),
+      'some-model',
+      'America/Los_Angeles',
+    );
+    expect(configView(on).compressionSplitFallback).toBe(true);
+    expect(configView(on).compressionSplitPlaceholder).toBe(true);
+    const omitted = buildFrameworkStrategy(recipe({ name: 'Mira' }), 'some-model', 'America/Los_Angeles');
+    expect(configView(omitted).compressionSplitFallback).toBeUndefined();
+    expect(configView(omitted).compressionSplitPlaceholder).toBeUndefined();
+    expect(() => recipe({ name: 'Mira', strategy: { type: 'autobiographical', compressionSplitFallback: 'yes' } })).toThrow();
+  });
+
+  test('split-stitch cap knobs pass through and are validated as positive integers', () => {
+    const on = buildFrameworkStrategy(
+      recipe({ name: 'Mira', strategy: { type: 'autobiographical', compressionSplitFallback: true, compressionSplitMaxCallsPerChunk: 12, compressionSplitMaxCallsPer10Min: 30 } }),
+      'some-model',
+      'America/Los_Angeles',
+    );
+    expect(configView(on).compressionSplitMaxCallsPerChunk).toBe(12);
+    expect(configView(on).compressionSplitMaxCallsPer10Min).toBe(30);
+    expect(() => recipe({ name: 'Mira', strategy: { type: 'autobiographical', compressionSplitMaxCallsPerChunk: 0 } })).toThrow();
+    expect(() => recipe({ name: 'Mira', strategy: { type: 'autobiographical', compressionSplitMaxCallsPer10Min: 1.5 } })).toThrow();
+  });
+
+  test('mergeMaxSourceSpanMessages is passed through exactly and omission stays omitted (princess 2026-09-05: silently dropped, span guard stuck at the CM default)', () => {
+    const configured = buildFrameworkStrategy(
+      recipe({
+        name: 'Mira',
+        strategy: { type: 'autobiographical', mergeMaxSourceSpanMessages: 3000, mergeThreshold: 3 },
+      }),
+      'some-model',
+      'America/Los_Angeles',
+    );
+    expect(configView(configured).mergeMaxSourceSpanMessages).toBe(3000);
+    expect(configView(configured).mergeThreshold).toBe(3);
+    const omitted = buildFrameworkStrategy(recipe({ name: 'Mira' }), 'some-model', 'America/Los_Angeles');
+    expect(configView(omitted).mergeMaxSourceSpanMessages).toBeUndefined();
+  });
+
   test('productionBudgetTokens is passed through exactly and omission stays omitted', () => {
     const configured = buildFrameworkStrategy(
       recipe({

package/test/gate-telemetry.test.ts

@@ -6,7 +6,7 @@
  * value went to the vendor's default endpoint.
  */
 import { describe, expect, it } from 'bun:test';
-import { gateTelemetryHeaders, originClass } from '../src/gate-telemetry.js';
+import { gateTelemetryHeaders, originClass, stampedTrigger } from '../src/gate-telemetry.js';
 
 const debt = () => 7;
 
@@ -56,6 +56,11 @@ describe('gateTelemetryHeaders', () => {
     expect(gateTelemetryHeaders(env, debt)!({ lane: 'stream' })).toEqual({ 'x-gate-debt-chunks': 7 });
   });
 
+  it('a gate-batched wake reports its telemetry channel (wakeChannelId) when it set no locus', () => {
+    const fn = gateTelemetryHeaders(env, debt, () => ({ reason: 'gate:debounce', source: 'gate', wakeChannelId: 'discord:1:2', counterparty: 'discord:user:42' }));
+    expect(fn!({ lane: 'stream' })).toEqual({ 'x-gate-debt-chunks': 7, 'x-gate-origin': 'event', 'x-gate-channel': 'discord:1:2', 'x-gate-counterparty': 'discord:user:42' });
+  });
+
   it('heartbeat wakes carry no channel or counterparty (null → dropped by membrane)', () => {
     const fn = gateTelemetryHeaders(env, debt, () => ({ reason: 'heartbeat:tick', source: 'heartbeat' }));
     expect(fn!({ lane: 'stream' })).toEqual({ 'x-gate-debt-chunks': 7, 'x-gate-origin': 'heartbeat', 'x-gate-channel': null, 'x-gate-counterparty': null });
@@ -65,6 +70,7 @@ describe('gateTelemetryHeaders', () => {
     expect(originClass({ reason: 'heartbeat', source: 'heartbeat' })).toBe('heartbeat');
     expect(originClass({ reason: 'mail:incoming', source: 'fenmail' })).toBe('mail');
     expect(originClass({ reason: 'mcpl:push-event', source: 'discord' })).toBe('event');
+    expect(originClass({ reason: 'gate:debounce', source: 'gate' })).toBe('event');   // first live stamps came back raw
     expect(originClass({ reason: 'admin-nudge (someone)', source: 'framework' })).toBe('operator');
     expect(originClass({ reason: 'external-message', source: 'headless' })).toBe('operator');
     expect(originClass({ reason: 'external-message', source: 'tui' })).toBe('operator');
@@ -88,4 +94,31 @@ describe('gateTelemetryHeaders', () => {
     const fn = gateTelemetryHeaders(env, debt, () => ({ reason: 'mcpl:channel-incoming', source: 'discord', counterparty: 'x'.repeat(200) }));
     expect((fn!({ lane: 'stream' })['x-gate-counterparty'] as string).length).toBe(120);
   });
+
+  describe('stampedTrigger — one adapter serves every agent', () => {
+    const trig = (name: string) => ({ reason: 'gate:debounce', source: 'gate', counterparty: `discord:user:${name}` });
+
+    it('single agent: its trigger', () => {
+      expect(stampedTrigger({ agents: ['scout'], triggerOf: () => trig('scout') })).toEqual(trig('scout'));
+    });
+
+    it('primary + idle subconscious: the primary\'s trigger', () => {
+      expect(stampedTrigger({ agents: ['scout', 'scout-sub'], primary: 'scout',
+        triggerOf: (n) => (n === 'scout' ? trig('scout') : null) })).toEqual(trig('scout'));
+    });
+
+    it('primary and subconscious both mid-turn: withhold — the hook cannot tell whose request it decorates', () => {
+      expect(stampedTrigger({ agents: ['scout', 'scout-sub'], primary: 'scout',
+        triggerOf: (n) => trig(n) })).toBeNull();
+    });
+
+    it('only the subconscious mid-turn: nothing (its request is not the primary\'s turn)', () => {
+      expect(stampedTrigger({ agents: ['scout', 'scout-sub'], primary: 'scout',
+        triggerOf: (n) => (n === 'scout-sub' ? trig('sub') : null) })).toBeNull();
+    });
+
+    it('several agents and no primary known: withhold', () => {
+      expect(stampedTrigger({ agents: ['a', 'b'], triggerOf: () => trig('a') })).toBeNull();
+    });
+  });
 });