@animalabs/connectome-host 0.3.1

package/test/fleet-tree-aggregator-e2e.test.ts

@@ -0,0 +1,110 @@
+/**
+ * End-to-end test for FleetTreeAggregator + FleetModule + headless child.
+ *
+ * Spawns a real headless child via FleetModule.handleLaunch, registers it
+ * with the aggregator, and asserts the snapshot round-trips through the
+ * IPC and ends up populating the per-child reducer.
+ *
+ * This is the integration check that Phase 1 + 2 + 3 + 6 actually compose:
+ *   - Phase 6 lets the child recipe pass validation
+ *   - Phase 1's describe verb returns a snapshot event
+ *   - Phase 2's reducer accepts applySnapshot from that event's tree
+ *   - Phase 3's aggregator orchestrates the describe handshake
+ */
+import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+import { mkdtempSync, writeFileSync, rmSync, existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { FleetModule } from '../src/modules/fleet-module.js';
+import { FleetTreeAggregator } from '../src/state/fleet-tree-aggregator.js';
+
+const TEST_DIR = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(TEST_DIR, '..');
+const INDEX_PATH = join(REPO_ROOT, 'src', 'index.ts');
+
+const CHILD_RECIPE = {
+  name: 'AggregatorChildRecipe',
+  agent: { name: 'commander', systemPrompt: 'never inferred in this test' },
+  modules: {
+    subagents: false,
+    lessons: false,
+    retrieval: false,
+    wake: false,
+    workspace: false,
+  },
+};
+
+async function waitFor(check: () => boolean, timeoutMs: number, label: string): Promise<void> {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (check()) return;
+    await new Promise((r) => setTimeout(r, 50));
+  }
+  throw new Error(`waitFor timed out after ${timeoutMs}ms: ${label}`);
+}
+
+describe('FleetTreeAggregator — e2e against headless child', () => {
+  let tmpDir: string;
+  let recipePath: string;
+  let fleet: FleetModule;
+  let aggregator: FleetTreeAggregator;
+
+  beforeAll(async () => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'fkm-agg-e2e-'));
+    recipePath = join(tmpDir, 'recipe.json');
+    writeFileSync(recipePath, JSON.stringify(CHILD_RECIPE), 'utf-8');
+
+    fleet = new FleetModule({
+      childRuntimePath: 'bun',
+      childIndexPath: INDEX_PATH,
+      readyTimeoutMs: 15_000,
+    });
+    aggregator = new FleetTreeAggregator(fleet);
+  });
+
+  afterAll(async () => {
+    aggregator.dispose();
+    // Best-effort cleanup of the spawned child.
+    try {
+      await fleet.handleToolCall({
+        id: 'cleanup',
+        name: 'kill',
+        input: { name: 'aggregated-child' },
+      });
+    } catch { /* noop */ }
+    await new Promise((r) => setTimeout(r, 500));
+    try { rmSync(tmpDir, { recursive: true, force: true }); } catch { /* noop */ }
+  });
+
+  test('snapshot round-trips through aggregator after launch', async () => {
+    // Register the child name BEFORE launch so we don't miss lifecycle:ready.
+    aggregator.registerChild('aggregated-child');
+
+    const launch = await fleet.handleToolCall({
+      id: 'launch-1',
+      name: 'launch',
+      input: {
+        name: 'aggregated-child',
+        recipe: recipePath,
+        dataDir: join(tmpDir, 'aggregated-child-data'),
+      },
+    });
+    expect((launch as { success?: boolean }).success).toBe(true);
+
+    // Wait for the snapshot to arrive and populate the reducer.
+    // The aggregator requests describe on lifecycle:ready, the child responds
+    // with a snapshot event carrying the seeded 'commander' framework agent.
+    await waitFor(
+      () => aggregator.getChildNodes('aggregated-child').some(n => n.name === 'commander'),
+      15_000,
+      'commander node populated from snapshot',
+    );
+
+    const nodes = aggregator.getChildNodes('aggregated-child');
+    const commander = nodes.find(n => n.name === 'commander');
+    expect(commander).toBeDefined();
+    expect(commander!.kind).toBe('framework');
+    expect(commander!.phase).toBe('idle');
+  });
+});

package/test/fleet-tree-aggregator.test.ts

@@ -0,0 +1,215 @@
+/**
+ * Unit tests for FleetTreeAggregator using a mock FleetModule.
+ *
+ * The aggregator's job is to:
+ *   1. Maintain a per-child AgentTreeReducer.
+ *   2. Request describe on lifecycle:ready (cold start + restart).
+ *   3. Apply snapshots, reseed reducers, drop stale events.
+ *   4. Notify listeners on tree changes.
+ *
+ * These tests drive a fake FleetModule API to assert that orchestration
+ * happens correctly, without actually spawning child processes.
+ */
+import { describe, test, expect } from 'bun:test';
+import { FleetTreeAggregator } from '../src/state/fleet-tree-aggregator.js';
+import type { FleetEventCallback } from '../src/modules/fleet-module.js';
+import type { WireEvent } from '../src/modules/fleet-types.js';
+
+// Minimal stub: only the surface FleetTreeAggregator actually touches.
+interface FakeChild { name: string; status: string }
+
+class FakeFleet {
+  private subscribers = new Map<string, Set<FleetEventCallback>>();
+  private children: FakeChild[] = [];
+  describeRequests: Array<{ name: string; corrId?: string }> = [];
+
+  setChildren(children: FakeChild[]): void { this.children = children; }
+  getChildren(): Map<string, FakeChild> {
+    const m = new Map<string, FakeChild>();
+    for (const c of this.children) m.set(c.name, c);
+    return m;
+  }
+
+  onChildEvent(name: string, callback: FleetEventCallback): () => void {
+    if (!this.subscribers.has(name)) this.subscribers.set(name, new Set());
+    this.subscribers.get(name)!.add(callback);
+    return () => { this.subscribers.get(name)?.delete(callback); };
+  }
+
+  requestDescribe(name: string, corrId?: string): boolean {
+    if (corrId !== undefined) this.describeRequests.push({ name, corrId });
+    else this.describeRequests.push({ name });
+    return this.children.some(c => c.name === name);
+  }
+
+  /** Drive an event from a child (for test injection). */
+  emit(name: string, event: WireEvent): void {
+    const subs = this.subscribers.get(name);
+    if (!subs) return;
+    for (const cb of subs) cb(name, event);
+  }
+}
+
+function makeSnapshot(asOfTs: number, agents: Array<{ name: string; phase?: string; input?: number; toolCalls?: number }>): WireEvent {
+  return {
+    type: 'snapshot',
+    corrId: 'test',
+    asOfTs,
+    child: { name: 'c', pid: 0, startedAt: 0 },
+    tree: {
+      nodes: agents.map(a => ({
+        name: a.name,
+        kind: 'framework',
+        status: 'running',
+        phase: a.phase ?? 'idle',
+        tokens: { input: a.input ?? 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        toolCallsCount: a.toolCalls ?? 0,
+        findingsCount: 0,
+      })),
+      callIdIndex: {},
+    },
+    ts: asOfTs,
+  } as unknown as WireEvent;
+}
+
+describe('FleetTreeAggregator', () => {
+  test('register triggers describe when child is already ready', () => {
+    const fake = new FakeFleet();
+    fake.setChildren([{ name: 'miner', status: 'ready' }]);
+    const agg = new FleetTreeAggregator(fake as never);
+    agg.registerChild('miner');
+    expect(fake.describeRequests.map(r => r.name)).toEqual(['miner']);
+  });
+
+  test('register does NOT describe when child not yet ready; lifecycle:ready triggers it', () => {
+    const fake = new FakeFleet();
+    fake.setChildren([{ name: 'miner', status: 'starting' }]);
+    const agg = new FleetTreeAggregator(fake as never);
+    agg.registerChild('miner');
+    expect(fake.describeRequests).toEqual([]);
+
+    fake.emit('miner', { type: 'lifecycle', phase: 'ready', pid: 1, dataDir: '/tmp' } as WireEvent);
+    expect(fake.describeRequests.map(r => r.name)).toEqual(['miner']);
+  });
+
+  test('snapshot reseeds the per-child reducer', () => {
+    const fake = new FakeFleet();
+    fake.setChildren([{ name: 'miner', status: 'ready' }]);
+    const agg = new FleetTreeAggregator(fake as never);
+    agg.registerChild('miner');
+
+    fake.emit('miner', makeSnapshot(1000, [{ name: 'commander', input: 5000, toolCalls: 3 }]));
+    const nodes = agg.getChildNodes('miner');
+    expect(nodes.length).toBe(1);
+    expect(nodes[0]!.name).toBe('commander');
+    expect(nodes[0]!.tokens.input).toBe(5000);
+    expect(nodes[0]!.toolCallsCount).toBe(3);
+  });
+
+  test('events with ts < lastSnapshotTs are dropped', () => {
+    const fake = new FakeFleet();
+    fake.setChildren([{ name: 'miner', status: 'ready' }]);
+    const agg = new FleetTreeAggregator(fake as never);
+    agg.registerChild('miner');
+
+    // Snapshot at t=1000 with toolCallsCount=3
+    fake.emit('miner', makeSnapshot(1000, [{ name: 'commander', toolCalls: 3 }]));
+    expect(agg.getChildNodes('miner')[0]!.toolCallsCount).toBe(3);
+
+    // Stale tool event (t=500 < snapshot t=1000) — should be dropped
+    fake.emit('miner', {
+      type: 'inference:tool_calls_yielded',
+      agentName: 'commander',
+      calls: [{ id: 'old-c1', name: 'x', input: {} }],
+      timestamp: 500,
+      ts: 500,
+    } as WireEvent);
+    fake.emit('miner', { type: 'tool:started', callId: 'old-c1', tool: 'x', module: 'm', ts: 500 } as WireEvent);
+    expect(agg.getChildNodes('miner')[0]!.toolCallsCount).toBe(3); // unchanged
+
+    // Fresh tool event (t=2000 > snapshot t=1000) — applied
+    fake.emit('miner', {
+      type: 'inference:tool_calls_yielded',
+      agentName: 'commander',
+      calls: [{ id: 'new-c1', name: 'y', input: {} }],
+      timestamp: 2000,
+      ts: 2000,
+    } as WireEvent);
+    fake.emit('miner', { type: 'tool:started', callId: 'new-c1', tool: 'y', module: 'm', ts: 2001 } as WireEvent);
+    expect(agg.getChildNodes('miner')[0]!.toolCallsCount).toBe(4);
+  });
+
+  test('events with no ts are applied (best-effort)', () => {
+    const fake = new FakeFleet();
+    fake.setChildren([{ name: 'miner', status: 'ready' }]);
+    const agg = new FleetTreeAggregator(fake as never);
+    agg.registerChild('miner');
+
+    fake.emit('miner', makeSnapshot(1000, []));
+    fake.emit('miner', {
+      type: 'inference:started',
+      agentName: 'lazy-agent',
+      timestamp: 5000,
+      // No ts field on the wrapper
+    } as WireEvent);
+    const nodes = agg.getChildNodes('miner');
+    expect(nodes.find(n => n.name === 'lazy-agent')).toBeDefined();
+  });
+
+  test('describe is not re-requested while one is in flight', () => {
+    const fake = new FakeFleet();
+    fake.setChildren([{ name: 'miner', status: 'ready' }]);
+    const agg = new FleetTreeAggregator(fake as never);
+    agg.registerChild('miner');
+    expect(fake.describeRequests.length).toBe(1);
+
+    // Second lifecycle:ready before snapshot returns: should NOT re-request.
+    fake.emit('miner', { type: 'lifecycle', phase: 'ready', pid: 1, dataDir: '/tmp' } as WireEvent);
+    expect(fake.describeRequests.length).toBe(1);
+
+    // After snapshot arrives, in-flight clears.
+    fake.emit('miner', makeSnapshot(1000, []));
+
+    // A subsequent lifecycle:ready (e.g. after parent reconnect) DOES re-request.
+    fake.emit('miner', { type: 'lifecycle', phase: 'ready', pid: 1, dataDir: '/tmp' } as WireEvent);
+    expect(fake.describeRequests.length).toBe(2);
+  });
+
+  test('listeners fire on child tree changes', () => {
+    const fake = new FakeFleet();
+    fake.setChildren([{ name: 'miner', status: 'ready' }]);
+    const agg = new FleetTreeAggregator(fake as never);
+    agg.registerChild('miner');
+
+    const updates: string[] = [];
+    agg.onTreeUpdate((scope) => updates.push(scope));
+
+    fake.emit('miner', makeSnapshot(1000, [{ name: 'commander' }]));
+    expect(updates).toContain('miner');
+  });
+
+  test('unregister stops further event handling for that child', () => {
+    const fake = new FakeFleet();
+    fake.setChildren([{ name: 'miner', status: 'ready' }]);
+    const agg = new FleetTreeAggregator(fake as never);
+    agg.registerChild('miner');
+    fake.emit('miner', makeSnapshot(1000, [{ name: 'commander', toolCalls: 1 }]));
+    expect(agg.getChildNodes('miner')[0]!.toolCallsCount).toBe(1);
+
+    agg.unregisterChild('miner');
+    fake.emit('miner', { type: 'lifecycle', phase: 'ready', pid: 1, dataDir: '/tmp', ts: 9999 } as WireEvent);
+    // After unregister, child is gone; getChildNodes returns empty.
+    expect(agg.getChildNodes('miner')).toEqual([]);
+  });
+
+  test('dispose tears down all subscriptions', () => {
+    const fake = new FakeFleet();
+    fake.setChildren([{ name: 'a', status: 'ready' }, { name: 'b', status: 'ready' }]);
+    const agg = new FleetTreeAggregator(fake as never);
+    agg.registerChild('a');
+    agg.registerChild('b');
+    expect(agg.getAllChildNames().sort()).toEqual(['a', 'b']);
+    agg.dispose();
+    expect(agg.getAllChildNames()).toEqual([]);
+  });
+});

package/test/frontdesk-strategy.test.ts

@@ -0,0 +1,326 @@
+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';
+
+// ---------------------------------------------------------------------------
+// Test helpers
+// ---------------------------------------------------------------------------
+
+let idCounter = 0;
+function msg(
+  participant: string,
+  text: string,
+  metadata: Record<string, unknown> = {},
+  timestamp = new Date('2026-04-17T14:32:00Z'),
+): StoredMessage {
+  return {
+    id: `m${++idCounter}`,
+    sequence: idCounter,
+    participant,
+    content: [{ type: 'text', text }],
+    metadata,
+    timestamp,
+  };
+}
+
+function makeStore(messages: StoredMessage[]): MessageStoreView {
+  return {
+    getAll: () => messages,
+    get: (id) => messages.find((m) => m.id === id) ?? null,
+    getFrom: (i) => messages.slice(i),
+    getTail: (n) => messages.slice(-n),
+    length: () => messages.length,
+    estimateTokens: (m) => {
+      let t = 0;
+      for (const b of m.content) if (b.type === 'text') t += Math.ceil(b.text.length / 4);
+      return t;
+    },
+  };
+}
+
+// Expose protected methods for focused testing
+class TestFrontdesk extends FrontdeskStrategy {
+  public pub_wrapProvenance(entry: ContextEntry, store: MessageStoreView) {
+    return this.wrapProvenance(entry, store);
+  }
+  public pub_buildHeader(m: StoredMessage) {
+    return this.buildProvenanceHeader(m);
+  }
+  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_compressionInstruction(chunkMessages: StoredMessage[], target: number) {
+    // Build a minimal Chunk shape sufficient for getCompressionInstruction
+    const chunk = {
+      index: 0,
+      startIndex: 0,
+      endIndex: chunkMessages.length,
+      messages: chunkMessages,
+      tokens: 0,
+      compressed: false,
+    } as any;
+    return this.getCompressionInstruction(chunk, target);
+  }
+}
+
+function makeStrategy(): TestFrontdesk {
+  return new TestFrontdesk({
+    headWindowTokens: 0,
+    recentWindowTokens: 0,
+    targetChunkTokens: 50,
+    autoTickOnNewMessage: false,
+    maxMessageTokens: 0,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Feature 1: Provenance wrapping
+// ---------------------------------------------------------------------------
+
+describe('provenance wrapping', () => {
+  test('wraps a Zulip MCPL-originated entry with a full header', () => {
+    const s = makeStrategy();
+    const m = msg('User', 'where are the packet retry constants defined?', {
+      serverId: 'zulip',
+      channelId: 'zulip:tracker-miner-f',
+      topic: 'packet pipeline',
+      author: { id: 'u1', name: 'alice' },
+      messageId: 'M987654',
+      timestamp: '2026-04-17T14:32:00Z',
+    });
+    const header = s.pub_buildHeader(m);
+    expect(header).not.toBeNull();
+    expect(header).toContain('zulip');
+    expect(header).toContain('#tracker-miner-f');
+    expect(header).toContain('topic "packet pipeline"');
+    expect(header).toContain('@alice');
+    expect(header).toContain('14:32');
+    expect(header).toContain('msg M987654');
+    expect(header!.endsWith('\n')).toBe(true);
+  });
+
+  test('wrapProvenance prepends header into the first text block', () => {
+    const s = makeStrategy();
+    const m = msg('User', 'hello', {
+      serverId: 'zulip',
+      channelId: 'zulip:general',
+      author: { name: 'bob' },
+    });
+    const store = makeStore([m]);
+    const entry: ContextEntry = {
+      index: 0,
+      sourceMessageId: m.id,
+      sourceRelation: 'copy',
+      participant: 'User',
+      content: [{ type: 'text', text: 'hello' }],
+    };
+    const wrapped = s.pub_wrapProvenance(entry, store);
+    expect(wrapped.content).toHaveLength(1);
+    const first = wrapped.content[0] as { type: 'text'; text: string };
+    expect(first.type).toBe('text');
+    expect(first.text.startsWith('[')).toBe(true);
+    expect(first.text).toContain('@bob');
+    expect(first.text).toContain('\nhello');
+  });
+
+  test('degrades gracefully when fields are missing (no empty separators)', () => {
+    const s = makeStrategy();
+    const m = msg('User', 'x', {
+      serverId: 'zulip',
+      // no channelId, no topic, no author, no messageId
+    });
+    const header = s.pub_buildHeader(m);
+    expect(header).not.toBeNull();
+    expect(header).not.toContain('· ·');
+    expect(header).not.toMatch(/\[ /);
+    expect(header).not.toMatch(/ \]/);
+  });
+
+  test('pass-through (unchanged) when no serverId (e.g. TUI-origin or summary)', () => {
+    const s = makeStrategy();
+    const m = msg('User', 'typed from tui', {}); // no serverId
+    expect(s.pub_buildHeader(m)).toBeNull();
+
+    const store = makeStore([m]);
+    const entry: ContextEntry = {
+      index: 0,
+      sourceMessageId: m.id,
+      sourceRelation: 'copy',
+      participant: 'User',
+      content: [{ type: 'text', text: 'typed from tui' }],
+    };
+    const wrapped = s.pub_wrapProvenance(entry, store);
+    expect(wrapped).toBe(entry);
+  });
+
+  test('derived (summary) entries are not wrapped even if sourceMessageId matched', () => {
+    const s = makeStrategy();
+    const m = msg('User', 'x', {
+      serverId: 'zulip',
+      channelId: 'zulip:general',
+      author: { name: 'bob' },
+    });
+    const store = makeStore([m]);
+    const entry: ContextEntry = {
+      index: 0,
+      participant: 'Summary',
+      content: [{ type: 'text', text: '...summary...' }],
+      sourceRelation: 'derived',
+    };
+    const wrapped = s.pub_wrapProvenance(entry, store);
+    expect(wrapped).toBe(entry);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Feature 2: Topic-aware chunking (boundary detection)
+// ---------------------------------------------------------------------------
+
+describe('topic boundary detection', () => {
+  test('returns true when adjacent messages have different topics in same channel', () => {
+    const s = makeStrategy();
+    const a = msg('User', 'a', { channelId: 'zulip:x', topic: 'T1' });
+    const b = msg('User', 'b', { channelId: 'zulip:x', topic: 'T2' });
+    expect(s.pub_isTopicBoundary(a, b)).toBe(true);
+  });
+
+  test('returns false when topics match', () => {
+    const s = makeStrategy();
+    const a = msg('User', 'a', { channelId: 'zulip:x', topic: 'T1' });
+    const b = msg('User', 'b', { channelId: 'zulip:x', topic: 'T1' });
+    expect(s.pub_isTopicBoundary(a, b)).toBe(false);
+  });
+
+  test('returns false when either side lacks topic metadata (graceful fallback)', () => {
+    const s = makeStrategy();
+    const a = msg('User', 'a', {});
+    const b = msg('User', 'b', { channelId: 'zulip:x', topic: 'T1' });
+    expect(s.pub_isTopicBoundary(a, b)).toBe(false);
+    expect(s.pub_isTopicBoundary(b, a)).toBe(false);
+  });
+
+  test('same topic name on different channels is NOT the same boundary', () => {
+    const s = makeStrategy();
+    const a = msg('User', 'a', { channelId: 'zulip:x', topic: 'general' });
+    const b = msg('User', 'b', { channelId: 'zulip:y', topic: 'general' });
+    expect(s.pub_isTopicBoundary(a, b)).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Feature 3: Salience + compression instruction + L1 selection
+// ---------------------------------------------------------------------------
+
+describe('question/mention salience', () => {
+  test('marks a user question as salient when no assistant reply follows', () => {
+    const s = makeStrategy();
+    const q = msg('User', 'what is the packet retry policy?', {});
+    const noise = msg('User', 'just ambient chat', {});
+    s.pub_updateSalience(makeStore([q, noise]));
+    const state = (s as unknown as { salientSourceIds: Set<string> }).salientSourceIds;
+    expect(state.has(q.id)).toBe(true);
+  });
+
+  test('does NOT mark a question as salient when assistant replies within window', () => {
+    const s = makeStrategy();
+    const q = msg('User', 'what is x?', {});
+    const a = msg('Claude', 'x is y', {});
+    s.pub_updateSalience(makeStore([q, a]));
+    const state = (s as unknown as { salientSourceIds: Set<string> }).salientSourceIds;
+    expect(state.has(q.id)).toBe(false);
+  });
+
+  test('marks Zulip-style @mentions as salient', () => {
+    const s = makeStrategy();
+    const m = msg('User', 'hey @**clerk** are you around', {});
+    s.pub_updateSalience(makeStore([m]));
+    const state = (s as unknown as { salientSourceIds: Set<string> }).salientSourceIds;
+    expect(state.has(m.id)).toBe(true);
+  });
+});
+
+describe('compression instruction', () => {
+  test('adds topic clause when chunk spans multiple topics', () => {
+    const s = makeStrategy();
+    const msgs = [
+      msg('User', 'a', { channelId: 'zulip:x', topic: 'T1' }),
+      msg('User', 'b', { channelId: 'zulip:x', topic: 'T2' }),
+    ];
+    const instr = s.pub_compressionInstruction(msgs, 2000);
+    expect(instr).toContain('multiple Zulip topics');
+  });
+
+  test('omits topic clause when all messages share a topic', () => {
+    const s = makeStrategy();
+    const msgs = [
+      msg('User', 'a', { channelId: 'zulip:x', topic: 'T1' }),
+      msg('User', 'b', { channelId: 'zulip:x', topic: 'T1' }),
+    ];
+    const instr = s.pub_compressionInstruction(msgs, 2000);
+    expect(instr).not.toContain('multiple Zulip topics');
+  });
+
+  test('preserves open-question text verbatim when the chunk has unanswered questions', () => {
+    const s = makeStrategy();
+    const q = msg('User', 'where are the packet retry constants defined?', {});
+    const noise = msg('User', 'ok thanks', {});
+    // Run salience first so the question is marked salient
+    s.pub_updateSalience(makeStore([q, noise]));
+    const instr = s.pub_compressionInstruction([q, noise], 2000);
+    expect(instr).toContain('packet retry constants');
+    expect(instr).toContain('Preserve verbatim');
+  });
+});
+
+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(),
+    };
+  }
+
+  test('prefers L1 summaries whose sources contain salient messages', () => {
+    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');
+  });
+
+  test('falls back to routine summaries once salient are exhausted', () => {
+    const s = makeStrategy();
+    const q = msg('User', 'what is x?', {});
+    s.pub_updateSalience(makeStore([q]));
+
+    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');
+  });
+});