@animalabs/connectome-host 0.7.3 → 0.7.4

package/src/web/protocol.ts

@@ -323,6 +323,10 @@ export interface PeekMessage {
  *  surface a "module not loaded" hint rather than appearing broken. */
 export interface LessonsListMessage {
   type: 'lessons-list';
+  /** Which process this snapshot describes: 'local' or a fleet-child name.
+   *  Lets the SPA drop stale replies after a scope switch instead of
+   *  rendering child A's data under child B's header. */
+  scope?: string;
   loaded: boolean;
   lessons: Array<{
     id: string;
@@ -339,6 +343,8 @@ export interface LessonsListMessage {
 /** Workspace mount summary — response to request-workspace-mounts. */
 export interface WorkspaceMountsMessage {
   type: 'workspace-mounts';
+  /** Process this snapshot describes ('local' or fleet-child name). */
+  scope?: string;
   /** True iff WorkspaceModule is loaded in the recipe. */
   loaded: boolean;
   mounts: Array<{
@@ -353,6 +359,8 @@ export interface WorkspaceMountsMessage {
 /** Recursive file listing for one mount — response to request-workspace-tree. */
 export interface WorkspaceTreeMessage {
   type: 'workspace-tree';
+  /** Process this listing came from ('local' or fleet-child name). */
+  scope?: string;
   mount: string;
   entries: Array<{ path: string; size: number }>;
 }
@@ -361,6 +369,8 @@ export interface WorkspaceTreeMessage {
  *  line-numbered (cat -n style) as returned by the workspace `read` tool. */
 export interface WorkspaceFileMessage {
   type: 'workspace-file';
+  /** Process this file came from ('local' or fleet-child name). */
+  scope?: string;
   path: string;
   totalLines: number;
   fromLine: number;
@@ -376,6 +386,10 @@ export interface WorkspaceFileMessage {
  *  changes are file-only and require restart anyway. */
 export interface McplListMessage {
   type: 'mcpl-list';
+  /** Process whose MCPL view this is ('local' or fleet-child name). The
+   *  registry FILE is shared cwd-wide, but which entries a process actually
+   *  loads is per-recipe — see `live`. */
+  scope?: string;
   /** Path to the config file (informational — operator may want to grep
    *  for it locally). */
   configPath: string;
@@ -389,6 +403,18 @@ export interface McplListMessage {
     enabledFeatureSets?: string[];
     disabledFeatureSets?: string[];
   }>;
+  /** Servers the scoped process actually LOADED (recipe opt-in + agent
+   *  overlay), with live connection status from its framework. Absent on
+   *  older hosts. This is the per-scope truth the file registry can't give:
+   *  a conductor with zero MCPLs and a clerk with five share one file. */
+  live?: Array<{
+    id: string;
+    connected: boolean;
+    toolCount: number;
+    toolPrefix?: string;
+    /** command or url — whatever the transport targets. */
+    target?: string;
+  }>;
 }
 
 /**
@@ -399,6 +425,8 @@ export interface McplListMessage {
  */
 export interface PinsListMessage {
   type: 'pins-list';
+  /** Process these pins live in ('local' or fleet-child name). */
+  scope?: string;
   agent: string;
   pins: Array<{
     id: string;
@@ -418,6 +446,11 @@ export interface PinsListMessage {
   levelHonored: boolean;
   /** Deepest fold level currently present, so the UI can bound level inputs. */
   deepestLevel?: number;
+  /** Recent pinnable messages (REAL store ids) from the scoped process.
+   *  Shipped for fleet-child scopes, where the SPA has no message window of
+   *  its own to build a picker from; local scope keeps using the client-side
+   *  candidate list. */
+  candidates?: Array<{ id: string; index: number; participant: string; text: string }>;
 }
 
 /**
@@ -429,6 +462,8 @@ export interface PinsListMessage {
  */
 export interface SettingsStateMessage {
   type: 'settings-state';
+  /** Process these settings belong to ('local' or fleet-child name). */
+  scope?: string;
   agent: string;
   /** Live values. `transition` is 'converging' while a paced descent runs. */
   settings: {
@@ -661,11 +696,14 @@ export interface RequestLessonsMessage {
   scope?: string;
 }
 
-/** Pull the configured MCPL servers from mcpl-servers.json. Response is an
- *  `mcpl-list` envelope. Recipe-defined servers are excluded — those live in
+/** Pull the MCPL server view: the shared file registry plus the scoped
+ *  process's LIVE loaded servers. Response is an `mcpl-list` envelope.
+ *  Recipe-defined servers appear only in `live` — their definitions live in
  *  the recipe file and aren't editable from here. */
 export interface RequestMcplMessage {
   type: 'request-mcpl';
+  /** Fleet child name, or 'local'/undefined for the parent process. */
+  scope?: string;
 }
 
 /** Pull the Chronicle branch listing. Response is a `branches-list` envelope
@@ -699,9 +737,13 @@ export interface McplSetEnvMessage {
   env: Record<string, string>;
 }
 
-/** Pull the agent's protected ranges. Response is a `pins-list` envelope. */
+/** Pull the agent's protected ranges. Response is a `pins-list` envelope.
+ *  With a fleet-child `scope` the child also ships picker `candidates`
+ *  (recent real store ids) since the SPA has no window into its store. */
 export interface RequestPinsMessage {
   type: 'request-pins';
+  /** Fleet child name, or 'local'/undefined for the parent process. */
+  scope?: string;
   agent?: string;
 }
 
@@ -723,6 +765,8 @@ export interface RequestPinsMessage {
  */
 export interface PinAddMessage {
   type: 'pin-add';
+  /** Fleet child name, or 'local'/undefined for the parent process. */
+  scope?: string;
   agent?: string;
   kind?: 'pin' | 'document';
   firstMessageId: string;
@@ -735,6 +779,8 @@ export interface PinAddMessage {
 
 export interface PinRemoveMessage {
   type: 'pin-remove';
+  /** Fleet child name, or 'local'/undefined for the parent process. */
+  scope?: string;
   agent?: string;
   pinId: string;
 }
@@ -743,7 +789,9 @@ export interface PinRemoveMessage {
  *  live-appliable vs restart-only. Response is a `settings-state` envelope. */
 export interface RequestSettingsMessage {
   type: 'request-settings';
-  /** Agent name; defaults to the recipe's primary agent. */
+  /** Fleet child name, or 'local'/undefined for the parent process. */
+  scope?: string;
+  /** Agent name; defaults to the scoped process's primary agent. */
   agent?: string;
 }
 
@@ -767,6 +815,8 @@ export interface RequestSettingsMessage {
  */
 export interface SettingsUpdateMessage {
   type: 'settings-update';
+  /** Fleet child name, or 'local'/undefined for the parent process. */
+  scope?: string;
   agent?: string;
   contextBudgetTokens?: number;
   tailTokens?: number;
@@ -782,6 +832,8 @@ export interface SettingsUpdateMessage {
 /** Revert named settings to their recipe values (all four when omitted). */
 export interface SettingsResetMessage {
   type: 'settings-reset';
+  /** Fleet child name, or 'local'/undefined for the parent process. */
+  scope?: string;
   agent?: string;
   keys?: string[];
   persist?: boolean;
@@ -791,6 +843,8 @@ export interface SettingsResetMessage {
 /** Abandon an in-flight paced descent, holding the current frontier. */
 export interface SettingsCancelTransitionMessage {
   type: 'settings-cancel-transition';
+  /** Fleet child name, or 'local'/undefined for the parent process. */
+  scope?: string;
   agent?: string;
   persist?: boolean;
 }
@@ -898,9 +952,10 @@ export function isClientMessage(value: unknown): value is WebUiClientMessage {
   switch (v.type) {
     case 'ping':
     case 'interrupt':
-    case 'request-mcpl':
     case 'request-branches':
       return true;
+    case 'request-mcpl':
+      return isOptionalScope(v.scope);
     case 'user-message':
       return typeof v.content === 'string';
     case 'observer-hello': {
@@ -938,8 +993,9 @@ export function isClientMessage(value: unknown): value is WebUiClientMessage {
     case 'mcpl-set-env':
       return isValidMcplId(v.id) && isStringMap(v.env);
     case 'request-pins':
-      return isOptionalNonEmptyString(v.agent);
+      return isOptionalScope(v.scope) && isOptionalNonEmptyString(v.agent);
     case 'pin-add': {
+      if (!isOptionalScope(v.scope)) return false;
       if (!isOptionalNonEmptyString(v.agent)) return false;
       if (!isNonEmptyString(v.firstMessageId)) return false;
       if (v.lastMessageId !== undefined && !isNonEmptyString(v.lastMessageId)) return false;
@@ -957,10 +1013,11 @@ export function isClientMessage(value: unknown): value is WebUiClientMessage {
       return true;
     }
     case 'pin-remove':
-      return isOptionalNonEmptyString(v.agent) && isNonEmptyString(v.pinId);
+      return isOptionalScope(v.scope) && isOptionalNonEmptyString(v.agent) && isNonEmptyString(v.pinId);
     case 'request-settings':
-      return isOptionalNonEmptyString(v.agent);
+      return isOptionalScope(v.scope) && isOptionalNonEmptyString(v.agent);
     case 'settings-update': {
+      if (!isOptionalScope(v.scope)) return false;
       if (!isOptionalNonEmptyString(v.agent)) return false;
       if (!isOptionalBool(v.persist) || !isOptionalBool(v.notify) || !isOptionalBool(v.immediate)) return false;
       // Positive-integer-or-absent for each knob. The semantic gate (budget must
@@ -976,12 +1033,13 @@ export function isClientMessage(value: unknown): value is WebUiClientMessage {
         || v.transitionPaceTokens !== undefined;
     }
     case 'settings-reset':
-      return isOptionalNonEmptyString(v.agent)
+      return isOptionalScope(v.scope)
+        && isOptionalNonEmptyString(v.agent)
         && isOptionalBool(v.persist)
         && isOptionalBool(v.notify)
         && isOptionalStringArray(v.keys);
     case 'settings-cancel-transition':
-      return isOptionalNonEmptyString(v.agent) && isOptionalBool(v.persist);
+      return isOptionalScope(v.scope) && isOptionalNonEmptyString(v.agent) && isOptionalBool(v.persist);
     case 'request-workspace-mounts':
       return v.scope === undefined || typeof v.scope === 'string';
     case 'request-workspace-tree':
@@ -1041,6 +1099,13 @@ function isOptionalNonEmptyString(v: unknown): v is string | undefined {
   return v === undefined || isNonEmptyString(v);
 }
 
+/** Scope fields: 'local' or a fleet-child name. Same lax shape the existing
+ *  lessons/workspace requests use — the server resolves unknown children to
+ *  a clean error rather than the validator guessing the fleet roster. */
+function isOptionalScope(v: unknown): v is string | undefined {
+  return v === undefined || typeof v === 'string';
+}
+
 function isOptionalBool(v: unknown): v is boolean | undefined {
   return v === undefined || typeof v === 'boolean';
 }

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

@@ -0,0 +1,167 @@
+/**
+ * Tests for the report-only module opt-in audit (Sol's #32 closure gate,
+ * step 3). The contract under test: explicit enables are surfaced for an
+ * operator decision, omissions are explained as the defaults flip working,
+ * resolved .recipe.json snapshots are pointers rather than findings, and
+ * nothing is ever modified.
+ */
+
+import { describe, test, expect } from 'bun:test';
+import { mkdtempSync, writeFileSync, mkdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import {
+  classifyModule,
+  looksLikeRecipe,
+  auditRecipe,
+  auditPaths,
+  renderReport,
+  AUDITED_MODULES,
+} from '../scripts/audit-module-optins.js';
+
+function tmp(): string {
+  return mkdtempSync(join(tmpdir(), 'optin-audit-'));
+}
+
+const AGENT = { name: 'test-agent', systemPrompt: 'hi' };
+
+describe('classifyModule', () => {
+  test('true and config objects are explicit enables', () => {
+    expect(classifyModule(true)).toBe('explicit-enable');
+    expect(classifyModule({ model: 'x' })).toBe('explicit-enable');
+  });
+  test('false is an explicit disable; absent is omitted', () => {
+    expect(classifyModule(false)).toBe('explicit-disable');
+    expect(classifyModule(undefined)).toBe('omitted');
+  });
+});
+
+describe('looksLikeRecipe', () => {
+  test('recipe-shaped objects pass; package.json-shaped ones do not', () => {
+    expect(looksLikeRecipe({ name: 'r', agent: AGENT })).toBe(true);
+    expect(looksLikeRecipe({ name: 'pkg', version: '1.0.0' })).toBe(false);
+    expect(looksLikeRecipe(['name'])).toBe(false);
+    expect(looksLikeRecipe(null)).toBe(false);
+  });
+});
+
+describe('auditRecipe', () => {
+  test('classifies each audited module independently', () => {
+    const a = auditRecipe(
+      { name: 'r', agent: AGENT, modules: { lessons: true, retrieval: false, wake: true } },
+      'r.json',
+    );
+    expect(a.states).toEqual({ subagents: 'omitted', lessons: 'explicit-enable', retrieval: 'explicit-disable' });
+    expect(a.isSnapshot).toBe(false);
+    expect(a.matchesOldDefaultBoilerplate).toBe(false);
+  });
+
+  test('flags retrieval-without-lessons as inert after upgrade', () => {
+    const a = auditRecipe({ name: 'r', agent: AGENT, modules: { retrieval: true } }, 'r.json');
+    expect(a.inertRetrieval).toBe(true);
+    // With lessons enabled the combination is coherent, not inert.
+    const ok = auditRecipe({ name: 'r', agent: AGENT, modules: { retrieval: true, lessons: true } }, 'r.json');
+    expect(ok.inertRetrieval).toBe(false);
+  });
+
+  test('a .recipe.json with all three true is old-default boilerplate; a source recipe never is', () => {
+    const modules = { subagents: true, lessons: true, retrieval: true };
+    const snap = auditRecipe({ name: 'r', agent: AGENT, modules }, 'data/.recipe.json');
+    expect(snap.isSnapshot).toBe(true);
+    expect(snap.matchesOldDefaultBoilerplate).toBe(true);
+    const src = auditRecipe({ name: 'r', agent: AGENT, modules }, 'data/recipe.json');
+    expect(src.matchesOldDefaultBoilerplate).toBe(false);
+  });
+
+  test('collects local fleet children, resolves relative paths, skips URLs', () => {
+    const a = auditRecipe(
+      {
+        name: 'parent',
+        agent: AGENT,
+        modules: { fleet: { children: [{ recipe: 'child.json' }, { recipe: 'https://x.example/c.json' }] } },
+      },
+      '/deploy/recipes/parent.json',
+    );
+    expect(a.childRecipePaths).toEqual(['/deploy/recipes/child.json']);
+  });
+});
+
+describe('auditPaths', () => {
+  test('scans directories, follows fleet children, skips non-recipes, modifies nothing', () => {
+    const dir = tmp();
+    const recipesDir = join(dir, 'recipes');
+    mkdirSync(recipesDir);
+    writeFileSync(
+      join(recipesDir, 'parent.json'),
+      JSON.stringify({
+        name: 'parent',
+        agent: AGENT,
+        modules: { lessons: true, fleet: { children: [{ recipe: '../elsewhere/child.json' }] } },
+      }),
+    );
+    // Child lives OUTSIDE the scanned dir — reachable only by following the reference.
+    mkdirSync(join(dir, 'elsewhere'));
+    const childPath = join(dir, 'elsewhere', 'child.json');
+    writeFileSync(childPath, JSON.stringify({ name: 'child', agent: AGENT, modules: { retrieval: true } }));
+    writeFileSync(join(recipesDir, 'package.json'), JSON.stringify({ name: 'pkg', version: '1.0.0' }));
+    writeFileSync(join(recipesDir, 'broken.json'), '{nope');
+
+    const before = statSync(join(recipesDir, 'parent.json')).mtimeMs;
+    const { audits, unreadable } = auditPaths([recipesDir]);
+    expect(unreadable).toEqual([]);
+    expect(audits.map((a) => a.recipeName).sort()).toEqual(['child', 'parent']);
+    // Report-only, literally: nothing was rewritten.
+    expect(statSync(join(recipesDir, 'parent.json')).mtimeMs).toBe(before);
+    expect(readFileSync(childPath, 'utf-8')).toContain('"retrieval":true');
+  });
+
+  test('finds dot-prefixed .recipe.json snapshots in scanned directories', () => {
+    const dir = tmp();
+    writeFileSync(
+      join(dir, '.recipe.json'),
+      JSON.stringify({ name: 'snap', agent: AGENT, modules: { subagents: true, lessons: true, retrieval: true } }),
+    );
+    const { audits } = auditPaths([dir]);
+    expect(audits.length).toBe(1);
+    expect(audits[0].isSnapshot).toBe(true);
+    expect(audits[0].matchesOldDefaultBoilerplate).toBe(true);
+  });
+
+  test('reports unreadable path arguments', () => {
+    const { audits, unreadable } = auditPaths([join(tmp(), 'nope.json')]);
+    expect(audits).toEqual([]);
+    expect(unreadable.length).toBe(1);
+  });
+});
+
+describe('renderReport', () => {
+  test('explicit enables and inert retrieval need decisions; omissions and disables do not', () => {
+    const clean = auditRecipe({ name: 'clean', agent: AGENT, modules: { lessons: false } }, 'clean.json');
+    expect(renderReport([clean]).needsDecision).toBe(0);
+
+    const enabled = auditRecipe({ name: 'e', agent: AGENT, modules: { lessons: true, retrieval: true } }, 'e.json');
+    // two explicit enables, no inert-retrieval (lessons present)
+    expect(renderReport([enabled]).needsDecision).toBe(2);
+
+    const inert = auditRecipe({ name: 'i', agent: AGENT, modules: { retrieval: true } }, 'i.json');
+    // one explicit enable + one inert-retrieval warning
+    expect(renderReport([inert]).needsDecision).toBe(2);
+  });
+
+  test('snapshot enables are informational, never decision items', () => {
+    const snap = auditRecipe(
+      { name: 's', agent: AGENT, modules: { subagents: true, lessons: true, retrieval: true } },
+      'data/.recipe.json',
+    );
+    const { text, needsDecision } = renderReport([snap]);
+    expect(needsDecision).toBe(0);
+    expect(text).toContain('not authoritative');
+    expect(text).toContain('old DEFAULT_RECIPE shape');
+  });
+
+  test('every audited module appears in a source-recipe report', () => {
+    const a = auditRecipe({ name: 'r', agent: AGENT }, 'r.json');
+    const { text } = renderReport([a]);
+    for (const m of AUDITED_MODULES) expect(text).toContain(`${m}:`);
+  });
+});

package/test/fleet-panel-request.test.ts

@@ -0,0 +1,90 @@
+/**
+ * FleetModule.requestPanel — the promise-based panel-op verb the WebUI's
+ * fleet-scope routing rides on (WS panels and the HTTP ?scope= proxy).
+ *
+ * Uses the mock headless child, which answers panel-request with:
+ *   op 'hang' → nothing (timeout path)
+ *   op 'fail' → {ok:false, error, status:418} (error passthrough)
+ *   others    → {ok:true, data:{op, echo:params}}
+ */
+import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { FleetModule, type FleetModuleConfig } from '../src/modules/fleet-module.js';
+
+const TEST_DIR = dirname(fileURLToPath(import.meta.url));
+const MOCK_CHILD_PATH = join(TEST_DIR, 'mock-headless-child.ts');
+
+function makeFleet(overrides: Partial<FleetModuleConfig> = {}): FleetModule {
+  return new FleetModule({
+    childIndexPath: MOCK_CHILD_PATH,
+    socketWaitTimeoutMs: 10_000,
+    readyTimeoutMs: 5_000,
+    gracefulShutdownMs: 3_000,
+    sigtermEscalationMs: 1_000,
+    ...overrides,
+  });
+}
+
+describe('FleetModule.requestPanel', () => {
+  let tmpDir: string;
+  let fleet: FleetModule;
+
+  beforeAll(async () => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'fkm-panel-'));
+    fleet = makeFleet();
+    const res = await fleet.handleToolCall({
+      id: 'launch-panelkid',
+      name: 'launch',
+      input: { name: 'panelkid', recipe: 'mock-recipe', dataDir: join(tmpDir, 'panelkid') },
+    });
+    if (!res.success) throw new Error(`launch failed: ${res.error}`);
+  });
+
+  afterAll(async () => {
+    try { await fleet.stop(); } catch { /* noop */ }
+    try { rmSync(tmpDir, { recursive: true, force: true }); } catch { /* noop */ }
+  });
+
+  test('round-trips op + params and resolves the child data', async () => {
+    const result = await fleet.requestPanel('panelkid', 'settings', { agent: 'clerk' });
+    expect(result.ok).toBe(true);
+    expect(result.data).toEqual({ op: 'settings', echo: { agent: 'clerk' } });
+  });
+
+  test('concurrent requests correlate independently', async () => {
+    const [a, b] = await Promise.all([
+      fleet.requestPanel('panelkid', 'health', { n: 1 }),
+      fleet.requestPanel('panelkid', 'pins', { n: 2 }),
+    ]);
+    expect(a.ok).toBe(true);
+    expect((a.data as { op: string }).op).toBe('health');
+    expect(b.ok).toBe(true);
+    expect((b.data as { op: string }).op).toBe('pins');
+  });
+
+  test('child-reported failure passes error and status through', async () => {
+    const result = await fleet.requestPanel('panelkid', 'fail');
+    expect(result.ok).toBe(false);
+    expect(result.error).toBe('mock failure');
+    expect(result.status).toBe(418);
+  });
+
+  test('unanswered request resolves ok:false with 504 after timeoutMs', async () => {
+    const started = Date.now();
+    const result = await fleet.requestPanel('panelkid', 'hang', undefined, 400);
+    expect(Date.now() - started).toBeGreaterThanOrEqual(380);
+    expect(result.ok).toBe(false);
+    expect(result.status).toBe(504);
+    expect(result.error).toContain('timed out');
+  });
+
+  test('unknown child resolves ok:false with 404 without touching the wire', async () => {
+    const result = await fleet.requestPanel('nobody', 'settings');
+    expect(result.ok).toBe(false);
+    expect(result.status).toBe(404);
+    expect(result.error).toContain('nobody');
+  });
+});

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

@@ -39,6 +39,28 @@ describe('standard-recipe memory defaults', () => {
     expect(config.summaryParticipant).toBe('Mira');
   });
 
+  test('frontdesk gets adaptive + kv-stable too (2026-08-03 clerk outage: hierarchical saturates)', () => {
+    const strategy = buildFrameworkStrategy(
+      recipe({ name: 'Desk', strategy: { type: 'frontdesk' } }),
+      'some-model',
+      'Europe/Kyiv',
+    );
+    const config = configView(strategy);
+    expect(config.adaptiveResolution).toBe(true);
+    expect(config.foldingStrategy).toBe('kv-stable');
+  });
+
+  test('frontdesk adaptiveResolution: false is the hierarchical rollback lever', () => {
+    const strategy = buildFrameworkStrategy(
+      recipe({ name: 'Desk', strategy: { type: 'frontdesk', adaptiveResolution: false } }),
+      'some-model',
+      'Europe/Kyiv',
+    );
+    const config = configView(strategy);
+    expect(config.adaptiveResolution).toBe(false);
+    expect(config.foldingStrategy).toBeUndefined();
+  });
+
   test('explicit recipe values override the defaults', () => {
     const strategy = buildFrameworkStrategy(
       recipe({

package/test/frontdesk-strategy.test.ts

@@ -2,7 +2,6 @@ import { describe, test, expect } from 'bun:test';
 import type {
   MessageStoreView,
   StoredMessage,
-  SummaryEntry,
   ContextEntry,
 } from '@animalabs/context-manager';
 import { FrontdeskStrategy } from '../src/strategies/frontdesk-strategy.js';
@@ -54,12 +53,12 @@ class TestFrontdesk extends FrontdeskStrategy {
   public pub_updateSalience(store: MessageStoreView) {
     this.updateSalience(store);
   }
-  public pub_selectL1(l1: SummaryEntry[], budget: number, maxTokens: number) {
-    return this.selectL1Summaries(l1, budget, maxTokens);
-  }
   public pub_isTopicBoundary(a: StoredMessage, b: StoredMessage) {
     return this.isTopicBoundary(a, b);
   }
+  public pub_chunkBoundaryHint(a: StoredMessage, b: StoredMessage) {
+    return this.chunkBoundaryHint(a, b);
+  }
   public pub_compressionInstruction(chunkMessages: StoredMessage[], target: number) {
     // Build a minimal Chunk shape sufficient for getCompressionInstruction
     const chunk = {
@@ -293,44 +292,33 @@ describe('compression instruction', () => {
   });
 });
 
-describe('salience-biased L1 selection', () => {
-  function summary(id: string, tokens: number, sourceIds: string[]): SummaryEntry {
-    return {
-      id,
-      level: 1,
-      content: '',
-      tokens,
-      sourceLevel: 0,
-      sourceIds,
-      sourceRange: { first: sourceIds[0] ?? '', last: sourceIds[sourceIds.length - 1] ?? '' },
-      created: Date.now(),
-    };
-  }
+describe('chunk boundary hint (topic-aware chunking via the base seam)', () => {
+  // The chunking mechanics — record persistence, minimum-size, tool-pairing
+  // guard — are context-manager's contract, gated by its
+  // chunk-boundary-hook tests. What is conhost's to pin is the hint policy:
+  // frontdesk hints exactly at topic boundaries.
 
-  test('prefers L1 summaries whose sources contain salient messages', () => {
+  test('hints a close when adjacent messages change topic on one channel', () => {
     const s = makeStrategy();
-    const q = msg('User', 'what is x?', {}); // salient: unanswered
-    s.pub_updateSalience(makeStore([q]));
-
-    // Two L1 summaries, each 100 tokens; budget fits only one
-    const routineFirst = summary('L1-0', 100, ['unrelated-1']);
-    const salientSecond = summary('L1-1', 100, [q.id]);
-
-    const { selected } = s.pub_selectL1([routineFirst, salientSecond], 100, 100);
-    expect(selected).toHaveLength(1);
-    expect(selected[0].id).toBe('L1-1');
+    const a = msg('User', 'x', { serverId: 'zulip', channelId: 'zulip:eng', topic: 'retries' });
+    const b = msg('User', 'y', { serverId: 'zulip', channelId: 'zulip:eng', topic: 'deploys' });
+    expect(s.pub_chunkBoundaryHint(a, b)).toBe(true);
   });
 
-  test('falls back to routine summaries once salient are exhausted', () => {
+  test('does not hint within a topic or when topic metadata is absent', () => {
     const s = makeStrategy();
-    const q = msg('User', 'what is x?', {});
-    s.pub_updateSalience(makeStore([q]));
+    const a = msg('User', 'x', { serverId: 'zulip', channelId: 'zulip:eng', topic: 'retries' });
+    const b = msg('User', 'y', { serverId: 'zulip', channelId: 'zulip:eng', topic: 'retries' });
+    const bare = msg('User', 'z', {});
+    expect(s.pub_chunkBoundaryHint(a, b)).toBe(false);
+    expect(s.pub_chunkBoundaryHint(a, bare)).toBe(false);
+    expect(s.pub_chunkBoundaryHint(bare, a)).toBe(false);
+  });
 
-    const salient = summary('L1-1', 50, [q.id]);
-    const routine = summary('L1-2', 50, ['unrelated-1']);
-    const { selected } = s.pub_selectL1([routine, salient], 200, 200);
-    expect(selected).toHaveLength(2);
-    expect(selected[0].id).toBe('L1-1'); // salient first
-    expect(selected[1].id).toBe('L1-2');
+  test('hint agrees with isTopicBoundary across channels (same topic name, different channel)', () => {
+    const s = makeStrategy();
+    const a = msg('User', 'x', { serverId: 'zulip', channelId: 'zulip:eng', topic: 'retries' });
+    const b = msg('User', 'y', { serverId: 'zulip', channelId: 'zulip:ops', topic: 'retries' });
+    expect(s.pub_chunkBoundaryHint(a, b)).toBe(s.pub_isTopicBoundary(a, b));
   });
 });