@animalabs/connectome-host 0.3.1

package/test/agent-tree-reducer.test.ts

@@ -0,0 +1,443 @@
+/**
+ * Unit tests for AgentTreeReducer.
+ *
+ * Strategy: feed representative trace event sequences and assert the resulting
+ * tree state matches the canonical fold currently scattered across tui.ts and
+ * subagent-module.ts. These streams are hand-built rather than recorded so the
+ * test stays stable across framework changes — but the event shapes mirror
+ * agent-framework/src/types/trace.ts exactly.
+ */
+import { describe, test, expect } from 'bun:test';
+import { AgentTreeReducer, REDUCER_REQUIRED_EVENTS } from '../src/state/agent-tree-reducer.js';
+
+function ts(offset: number): number {
+  return 1_700_000_000_000 + offset;
+}
+
+describe('AgentTreeReducer', () => {
+  test('seed creates framework nodes with zero state', () => {
+    const r = new AgentTreeReducer();
+    r.seedFrameworkAgents(['commander', 'observer']);
+    const nodes = r.getNodes();
+    expect(nodes.length).toBe(2);
+    const commander = r.getNode('commander');
+    expect(commander).toBeDefined();
+    expect(commander!.kind).toBe('framework');
+    expect(commander!.phase).toBe('idle');
+    expect(commander!.tokens).toEqual({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
+    expect(commander!.toolCallsCount).toBe(0);
+    expect(commander!.parent).toBeUndefined();
+  });
+
+  test('phase transitions follow the canonical mapping', () => {
+    const r = new AgentTreeReducer();
+    r.applyEvent({ type: 'inference:started', agentName: 'a', timestamp: ts(0) });
+    expect(r.getNode('a')!.phase).toBe('sending');
+
+    r.applyEvent({ type: 'inference:tokens', agentName: 'a', content: 'hi', timestamp: ts(1) });
+    expect(r.getNode('a')!.phase).toBe('streaming');
+
+    r.applyEvent({
+      type: 'inference:tool_calls_yielded',
+      agentName: 'a',
+      calls: [{ id: 'c1', name: 'files--read', input: {} }],
+      timestamp: ts(2),
+    });
+    expect(r.getNode('a')!.phase).toBe('invoking');
+
+    r.applyEvent({ type: 'tool:started', callId: 'c1', tool: 'files--read', module: 'files', timestamp: ts(3) });
+    expect(r.getNode('a')!.phase).toBe('executing');
+    expect(r.getNode('a')!.toolCallsCount).toBe(1);
+
+    r.applyEvent({ type: 'tool:completed', callId: 'c1', tool: 'files--read', module: 'files', durationMs: 5, timestamp: ts(4) });
+    // tool:completed does NOT transition phase (matches tui.ts behavior)
+    expect(r.getNode('a')!.phase).toBe('executing');
+
+    r.applyEvent({ type: 'inference:completed', agentName: 'a', durationMs: 10, timestamp: ts(5) });
+    expect(r.getNode('a')!.phase).toBe('done');
+  });
+
+  test('inference:failed sets phase=failed and status=failed', () => {
+    const r = new AgentTreeReducer();
+    r.applyEvent({ type: 'inference:started', agentName: 'a', timestamp: ts(0) });
+    r.applyEvent({ type: 'inference:failed', agentName: 'a', error: 'boom', timestamp: ts(1) });
+    const node = r.getNode('a')!;
+    expect(node.phase).toBe('failed');
+    expect(node.status).toBe('failed');
+    expect(node.completedAt).toBe(ts(1));
+  });
+
+  test('inference:aborted produces terminal cancelled state (P1 #3 — distinct from failed)', () => {
+    // Postmortem 2026-05-28 P1 #3: inference:aborted = user cancel /
+    // zombie-reclaim / supersession / agent reboot. Not strictly a fault. The
+    // previous regression guard (pre-2026-05-28) flipped status to 'failed'
+    // because the fleet-child-agent renderer was status-keyed and aborts left
+    // it stuck on 'running'. The right answer is a third terminal state,
+    // 'cancelled' — terminal (renderer must not show as 'running'), but
+    // neutral (renderer must not paint red). Both fields settle to 'cancelled'
+    // so consumers of either status or phase get the same answer.
+    const r = new AgentTreeReducer();
+    r.applyEvent({ type: 'inference:started', agentName: 'a', timestamp: ts(0) });
+    r.applyEvent({ type: 'inference:aborted', agentName: 'a', reason: 'user', timestamp: ts(1) });
+    const node = r.getNode('a')!;
+    expect(node.phase).toBe('cancelled');
+    expect(node.status).toBe('cancelled');
+    expect(node.completedAt).toBe(ts(1));
+  });
+
+  test('inference:exhausted from in-band stream abort also produces cancelled (P1 #3)', () => {
+    // Postmortem 2026-05-28 F1: framework.ts:2108 emits inference:exhausted
+    // for budget-restart / stream-side cancel paths. Same semantics as
+    // aborted — benign termination, not a fault.
+    const r = new AgentTreeReducer();
+    r.applyEvent({ type: 'inference:started', agentName: 'a', timestamp: ts(0) });
+    r.applyEvent({ type: 'inference:exhausted', agentName: 'a', error: 'budget', timestamp: ts(1) });
+    const node = r.getNode('a')!;
+    expect(node.phase).toBe('cancelled');
+    expect(node.status).toBe('cancelled');
+  });
+
+  // Postmortem 2026-05-28 F1: the reducer never transitions status to 'completed'.
+  // inference:completed only sets phase='done', leaving status='running' for the
+  // entire lifetime of the agent — which is fine until a later aborted/exhausted/
+  // failed event latches status='failed', at which point only a fresh
+  // inference:started can clear it. For ephemeral subagents whose terminal event
+  // is a benign abort, terminal RED is then permanent.
+  test('inference:completed sets status=completed (F1 — closes one-way failed latch)', () => {
+    const r = new AgentTreeReducer();
+    r.applyEvent({ type: 'inference:started', agentName: 'a', timestamp: ts(0) });
+    r.applyEvent({
+      type: 'inference:completed',
+      agentName: 'a',
+      durationMs: 5,
+      timestamp: ts(1),
+    });
+    const node = r.getNode('a')!;
+    expect(node.phase).toBe('done');
+    expect(node.status).toBe('completed');
+  });
+
+  test('inference:completed after a prior aborted clears the cancelled status (F1 — recovery un-latches)', () => {
+    // The "successful turn clears earlier transient terminal status" behavior.
+    // Without this, the admin UI shows long-running agents non-running for
+    // hours after a single transient cancel even though they have since
+    // completed many turns. Combined with the P1 #3 cancelled-vs-failed split
+    // (the prior aborted now lands as 'cancelled', not 'failed').
+    const r = new AgentTreeReducer();
+    r.applyEvent({ type: 'inference:started', agentName: 'a', timestamp: ts(0) });
+    r.applyEvent({ type: 'inference:aborted', agentName: 'a', reason: 'cancel', timestamp: ts(1) });
+    expect(r.getNode('a')!.status).toBe('cancelled');
+
+    // A subsequent successful round should heal the latch.
+    r.applyEvent({ type: 'inference:started', agentName: 'a', timestamp: ts(2) });
+    r.applyEvent({
+      type: 'inference:completed',
+      agentName: 'a',
+      durationMs: 5,
+      timestamp: ts(3),
+    });
+    expect(r.getNode('a')!.status).toBe('completed');
+  });
+
+  test('REDUCER_REQUIRED_EVENTS is derived from the dispatch table — every entry actually does something', () => {
+    // Forward direction: each event listed in the constant must observably
+    // affect a fresh reducer (i.e. it has a real handler, not a stale entry).
+    // This catches "constant added but handler never written" and also makes
+    // the derived-from-handler-keys design self-checking.
+    for (const eventType of REDUCER_REQUIRED_EVENTS) {
+      const r = new AgentTreeReducer();
+      const event = makeRepresentativeEvent(eventType);
+      r.applyEvent(event as never);
+      // We expect either a node was created/mutated, or a callId mapping was
+      // installed. The simplest observable: a non-empty getNodes() OR a
+      // tool-event ref that wouldn't have been routable without
+      // tool_calls_yielded establishing the index.
+      const nodes = r.getNodes();
+      const observable = nodes.length > 0 || hasCallIdSideEffect(eventType);
+      expect(observable).toBe(true);
+    }
+  });
+});
+
+/** Synthesize a minimal valid event of the given type for the invariant test. */
+function makeRepresentativeEvent(eventType: string): Record<string, unknown> {
+  // Tool events route via callId, not agentName. Pre-establish a binding by
+  // priming the reducer with a tool_calls_yielded that sets up an index — the
+  // test driver below handles this case separately.
+  switch (eventType) {
+    case 'inference:tool_calls_yielded':
+      return {
+        type: eventType,
+        agentName: 'agent',
+        calls: [{ id: 'c1', name: 'x', input: {} }],
+        timestamp: 1000,
+      };
+    case 'tool:started':
+    case 'tool:completed':
+    case 'tool:failed':
+      return { type: eventType, callId: 'c1', tool: 'x', module: 'm', timestamp: 1000, durationMs: 1, error: '' };
+    case 'inference:usage':
+      return {
+        type: eventType,
+        agentName: 'agent',
+        tokenUsage: { input: 100, output: 10 },
+        timestamp: 1000,
+      };
+    case 'inference:completed':
+      return {
+        type: eventType,
+        agentName: 'agent',
+        durationMs: 5,
+        tokenUsage: { input: 100, output: 10 },
+        timestamp: 1000,
+      };
+    case 'inference:failed':
+    case 'inference:exhausted':
+    case 'inference:aborted':
+      return { type: eventType, agentName: 'agent', error: 'x', reason: 'x', timestamp: 1000 };
+    case 'inference:stream_restarted':
+      return { type: eventType, agentName: 'agent', reason: 'x', inputTokens: 0, budget: 0, timestamp: 1000 };
+    default:
+      return { type: eventType, agentName: 'agent', content: '', timestamp: 1000 };
+  }
+}
+
+/** Tool events that arrive without a prior tool_calls_yielded just no-op. We
+ *  don't pre-prime the reducer in the invariant test, so for tool:* events the
+ *  observable check is the inverse: the reducer correctly does nothing when
+ *  the callId is unknown. We accept that as "wired up" because the no-op path
+ *  itself proves the case is in the dispatch table — falling through to
+ *  default would never reach the lookup. */
+function hasCallIdSideEffect(eventType: string): boolean {
+  return eventType === 'tool:started' || eventType === 'tool:completed' || eventType === 'tool:failed';
+}
+
+describe('AgentTreeReducer (continued)', () => {
+
+  test('input tokens overwrite (current context size); output/cache accumulate', () => {
+    const r = new AgentTreeReducer();
+    r.applyEvent({
+      type: 'inference:usage',
+      agentName: 'a',
+      tokenUsage: { input: 1000, output: 50, cacheRead: 200, cacheCreation: 100 },
+      timestamp: ts(0),
+    });
+    r.applyEvent({
+      type: 'inference:usage',
+      agentName: 'a',
+      tokenUsage: { input: 1500, output: 80, cacheRead: 300, cacheCreation: 50 },
+      timestamp: ts(1),
+    });
+    const tokens = r.getNode('a')!.tokens;
+    expect(tokens.input).toBe(1500);          // overwrite (current context size)
+    expect(tokens.output).toBe(130);          // accumulated
+    expect(tokens.cacheRead).toBe(500);       // accumulated
+    expect(tokens.cacheWrite).toBe(150);      // accumulated
+  });
+
+  test('inference:completed final tokenUsage applies same accumulation rules', () => {
+    const r = new AgentTreeReducer();
+    r.applyEvent({
+      type: 'inference:usage',
+      agentName: 'a',
+      tokenUsage: { input: 500, output: 20, cacheRead: 0, cacheCreation: 0 },
+      timestamp: ts(0),
+    });
+    r.applyEvent({
+      type: 'inference:completed',
+      agentName: 'a',
+      durationMs: 100,
+      tokenUsage: { input: 700, output: 30, cacheRead: 50, cacheCreation: 10 },
+      timestamp: ts(1),
+    });
+    const tokens = r.getNode('a')!.tokens;
+    expect(tokens.input).toBe(700);
+    expect(tokens.output).toBe(50);
+    expect(tokens.cacheRead).toBe(50);
+    expect(tokens.cacheWrite).toBe(10);
+  });
+
+  test('subagent--spawn tool call creates a child node with parent edge', () => {
+    const r = new AgentTreeReducer();
+    r.applyEvent({
+      type: 'inference:tool_calls_yielded',
+      agentName: 'commander',
+      calls: [{
+        id: 'c1',
+        name: 'subagent--spawn',
+        input: { name: 'researcher', task: 'investigate X' },
+      }],
+      timestamp: ts(0),
+    });
+    const child = r.getNode('researcher');
+    expect(child).toBeDefined();
+    expect(child!.kind).toBe('subagent');
+    expect(child!.subagentType).toBe('spawn');
+    expect(child!.task).toBe('investigate X');
+    expect(child!.parent).toBe('commander');
+    expect(r.getChildren('commander').map(n => n.name)).toContain('researcher');
+  });
+
+  test('subagent--fork tool call records type=fork', () => {
+    const r = new AgentTreeReducer();
+    r.applyEvent({
+      type: 'inference:tool_calls_yielded',
+      agentName: 'commander',
+      calls: [{
+        id: 'c1',
+        name: 'subagent--fork',
+        input: { name: 'side-quest', task: 'try a different approach' },
+      }],
+      timestamp: ts(0),
+    });
+    expect(r.getNode('side-quest')!.subagentType).toBe('fork');
+  });
+
+  test('fleet--launch tool call creates a framework-kind child', () => {
+    const r = new AgentTreeReducer();
+    r.applyEvent({
+      type: 'inference:tool_calls_yielded',
+      agentName: 'conductor',
+      calls: [{
+        id: 'c1',
+        name: 'fleet--launch',
+        input: { name: 'miner-1', recipe: 'knowledge-miner.json' },
+      }],
+      timestamp: ts(0),
+    });
+    const child = r.getNode('miner-1');
+    expect(child).toBeDefined();
+    expect(child!.kind).toBe('framework');
+    expect(child!.parent).toBe('conductor');
+  });
+
+  test('tool events without a known callId are dropped silently', () => {
+    const r = new AgentTreeReducer();
+    r.applyEvent({ type: 'tool:started', callId: 'unknown-id', tool: 'x', module: 'y', timestamp: ts(0) });
+    expect(r.getNodes().length).toBe(0);
+  });
+
+  test('tool events route to the agent that yielded the call', () => {
+    const r = new AgentTreeReducer();
+    r.applyEvent({
+      type: 'inference:tool_calls_yielded',
+      agentName: 'a',
+      calls: [{ id: 'c1', name: 'x', input: {} }],
+      timestamp: ts(0),
+    });
+    r.applyEvent({
+      type: 'inference:tool_calls_yielded',
+      agentName: 'b',
+      calls: [{ id: 'c2', name: 'y', input: {} }],
+      timestamp: ts(1),
+    });
+    r.applyEvent({ type: 'tool:started', callId: 'c1', tool: 'x', module: 'm', timestamp: ts(2) });
+    r.applyEvent({ type: 'tool:started', callId: 'c2', tool: 'y', module: 'm', timestamp: ts(3) });
+    r.applyEvent({ type: 'tool:started', callId: 'c2', tool: 'y', module: 'm', timestamp: ts(4) });
+    expect(r.getNode('a')!.toolCallsCount).toBe(1);
+    expect(r.getNode('b')!.toolCallsCount).toBe(2);
+  });
+
+  test('applySnapshot replaces all state', () => {
+    const r = new AgentTreeReducer();
+    r.applyEvent({ type: 'inference:started', agentName: 'old-agent', timestamp: ts(0) });
+    expect(r.getNode('old-agent')).toBeDefined();
+
+    r.applySnapshot({
+      asOfTs: ts(100),
+      nodes: [{
+        name: 'new-agent',
+        kind: 'framework',
+        status: 'running',
+        phase: 'streaming',
+        tokens: { input: 5000, output: 200, cacheRead: 100, cacheWrite: 50 },
+        toolCallsCount: 3,
+        findingsCount: 0,
+      }],
+      callIdIndex: { 'pre-existing-call': 'new-agent' },
+    });
+    expect(r.getNode('old-agent')).toBeUndefined();
+    const recovered = r.getNode('new-agent')!;
+    expect(recovered.tokens.input).toBe(5000);
+    expect(recovered.toolCallsCount).toBe(3);
+
+    // Tool events for callIds in the snapshot's callIdIndex should still route correctly.
+    r.applyEvent({ type: 'tool:started', callId: 'pre-existing-call', tool: 'x', module: 'm', timestamp: ts(101) });
+    expect(r.getNode('new-agent')!.toolCallsCount).toBe(4);
+  });
+
+  test('applySnapshot is deep-copy safe (mutating returned nodes does not affect reducer)', () => {
+    const r = new AgentTreeReducer();
+    r.applyEvent({ type: 'inference:started', agentName: 'a', timestamp: ts(0) });
+    r.applyEvent({
+      type: 'inference:usage',
+      agentName: 'a',
+      tokenUsage: { input: 100, output: 10 },
+      timestamp: ts(1),
+    });
+    const snap = r.getSnapshot();
+    snap.nodes[0]!.tokens.input = 999;
+    snap.nodes[0]!.toolCallsCount = 999;
+    expect(r.getNode('a')!.tokens.input).toBe(100);
+    expect(r.getNode('a')!.toolCallsCount).toBe(0);
+  });
+
+  test('reset clears everything', () => {
+    const r = new AgentTreeReducer();
+    r.applyEvent({ type: 'inference:started', agentName: 'a', timestamp: ts(0) });
+    r.reset();
+    expect(r.getNodes().length).toBe(0);
+  });
+
+  test('getRoots returns parentless nodes only', () => {
+    const r = new AgentTreeReducer();
+    r.seedFrameworkAgents(['commander']);
+    r.applyEvent({
+      type: 'inference:tool_calls_yielded',
+      agentName: 'commander',
+      calls: [{
+        id: 'c1',
+        name: 'subagent--spawn',
+        input: { name: 'child', task: 't' },
+      }],
+      timestamp: ts(0),
+    });
+    const roots = r.getRoots();
+    expect(roots.map(n => n.name)).toEqual(['commander']);
+  });
+
+  test('lazy node creation on first event for an unseen agent', () => {
+    const r = new AgentTreeReducer();
+    r.applyEvent({ type: 'inference:started', agentName: 'lazy-agent', timestamp: ts(0) });
+    const node = r.getNode('lazy-agent');
+    expect(node).toBeDefined();
+    expect(node!.kind).toBe('framework');
+    expect(node!.startedAt).toBe(ts(0));
+  });
+
+  test('startedAt is set on first inference, not overwritten on subsequent', () => {
+    const r = new AgentTreeReducer();
+    r.applyEvent({ type: 'inference:started', agentName: 'a', timestamp: ts(0) });
+    r.applyEvent({ type: 'inference:completed', agentName: 'a', durationMs: 5, timestamp: ts(10) });
+    r.applyEvent({ type: 'inference:started', agentName: 'a', timestamp: ts(20) });
+    expect(r.getNode('a')!.startedAt).toBe(ts(0));
+  });
+
+  test('lastEventAt tracks the most recent event timestamp', () => {
+    const r = new AgentTreeReducer();
+    r.applyEvent({ type: 'inference:started', agentName: 'a', timestamp: ts(0) });
+    r.applyEvent({ type: 'inference:tokens', agentName: 'a', content: 'x', timestamp: ts(50) });
+    expect(r.getNode('a')!.lastEventAt).toBe(ts(50));
+  });
+
+  test('unknown event types are ignored without affecting state', () => {
+    const r = new AgentTreeReducer();
+    r.applyEvent({ type: 'inference:started', agentName: 'a', timestamp: ts(0) });
+    const before = r.getNode('a')!;
+    r.applyEvent({ type: 'gate:decision', eventType: 'foo', matchedPolicy: null, trigger: false, behavior: 'allow' } as never);
+    r.applyEvent({ type: 'process:received', processEvent: { type: 'whatever' } } as never);
+    r.applyEvent({ type: 'message:added', messageId: 'm1', source: 's' } as never);
+    const after = r.getNode('a')!;
+    expect(after).toEqual(before);
+  });
+});

package/test/agent-tree-rollup.test.ts

@@ -0,0 +1,109 @@
+/**
+ * Phase rollup logic — picks the busiest active phase from a list of
+ * AgentTreeReducer nodes, used by the TUI to colour fleet-child header rows
+ * with what's *actually happening inside the child*, not just lifecycle
+ * status. The helper itself lives inside tui.ts as a closure, so this test
+ * mirrors its behaviour against canonical reducer state.
+ */
+import { describe, test, expect } from 'bun:test';
+import { AgentTreeReducer } from '../src/state/agent-tree-reducer.js';
+import type { AgentNode } from '../src/state/agent-tree-reducer.js';
+
+type ActivePhase = 'sending' | 'streaming' | 'invoking' | 'executing';
+
+/** Reference implementation of the rollup. Mirrors tui.ts:rollupActivePhase. */
+function rollupActivePhase(nodes: AgentNode[]): ActivePhase | null {
+  const PRIORITY: Record<ActivePhase, number> = {
+    streaming: 5,
+    invoking: 4,
+    executing: 3,
+    sending: 2,
+  };
+  let best: ActivePhase | null = null;
+  let bestScore = -1;
+  for (const n of nodes) {
+    const phase = n.phase;
+    if (phase === 'streaming' || phase === 'invoking' ||
+        phase === 'executing' || phase === 'sending') {
+      const score = PRIORITY[phase];
+      if (score > bestScore) {
+        best = phase;
+        bestScore = score;
+      }
+    }
+  }
+  return best;
+}
+
+const t = (offset: number) => 1_700_000_000_000 + offset;
+
+describe('phase rollup for fleet-child header status', () => {
+  test('returns null when nothing is active', () => {
+    const r = new AgentTreeReducer();
+    r.applyEvent({ type: 'inference:started', agentName: 'a', timestamp: t(0) });
+    r.applyEvent({ type: 'inference:completed', agentName: 'a', durationMs: 5, timestamp: t(1) });
+    expect(rollupActivePhase(r.getNodes())).toBeNull();
+  });
+
+  test('returns the agent phase when one agent is mid-stream', () => {
+    const r = new AgentTreeReducer();
+    r.applyEvent({ type: 'inference:started', agentName: 'a', timestamp: t(0) });
+    r.applyEvent({ type: 'inference:tokens', agentName: 'a', content: 'hi', timestamp: t(1) });
+    expect(rollupActivePhase(r.getNodes())).toBe('streaming');
+  });
+
+  test('streaming wins over executing when multiple agents are busy', () => {
+    const r = new AgentTreeReducer();
+    r.applyEvent({ type: 'inference:started', agentName: 'a', timestamp: t(0) });
+    r.applyEvent({
+      type: 'inference:tool_calls_yielded',
+      agentName: 'a',
+      calls: [{ id: 'c1', name: 'x', input: {} }],
+      timestamp: t(1),
+    });
+    r.applyEvent({ type: 'tool:started', callId: 'c1', tool: 'x', module: 'm', timestamp: t(2) });
+    // Now agent 'a' is in 'executing'. Add agent 'b' that starts streaming.
+    r.applyEvent({ type: 'inference:tokens', agentName: 'b', content: 'hi', timestamp: t(3) });
+    expect(rollupActivePhase(r.getNodes())).toBe('streaming');
+  });
+
+  test('done and idle do not register as active', () => {
+    const r = new AgentTreeReducer();
+    r.applyEvent({ type: 'inference:started', agentName: 'a', timestamp: t(0) });
+    r.applyEvent({ type: 'inference:completed', agentName: 'a', durationMs: 5, timestamp: t(1) });
+    r.seedFrameworkAgents(['idle-agent']); // phase=idle by default
+    expect(rollupActivePhase(r.getNodes())).toBeNull();
+  });
+
+  test('invoking and executing rank between sending and streaming', () => {
+    const reduce = (phase: 'sending' | 'streaming' | 'invoking' | 'executing'): AgentTreeReducer => {
+      const r = new AgentTreeReducer();
+      r.applyEvent({ type: 'inference:started', agentName: 'a', timestamp: t(0) });
+      if (phase === 'streaming') {
+        r.applyEvent({ type: 'inference:tokens', agentName: 'a', content: 'x', timestamp: t(1) });
+      } else if (phase === 'invoking' || phase === 'executing') {
+        r.applyEvent({
+          type: 'inference:tool_calls_yielded',
+          agentName: 'a',
+          calls: [{ id: 'c1', name: 'x', input: {} }],
+          timestamp: t(1),
+        });
+        if (phase === 'executing') {
+          r.applyEvent({ type: 'tool:started', callId: 'c1', tool: 'x', module: 'm', timestamp: t(2) });
+        }
+      }
+      return r;
+    };
+    expect(rollupActivePhase(reduce('streaming').getNodes())).toBe('streaming');
+    expect(rollupActivePhase(reduce('invoking').getNodes())).toBe('invoking');
+    expect(rollupActivePhase(reduce('executing').getNodes())).toBe('executing');
+    expect(rollupActivePhase(reduce('sending').getNodes())).toBe('sending');
+  });
+
+  test('failed agents do not count as active (the activity rolled up is *current* work, not historical state)', () => {
+    const r = new AgentTreeReducer();
+    r.applyEvent({ type: 'inference:started', agentName: 'a', timestamp: t(0) });
+    r.applyEvent({ type: 'inference:failed', agentName: 'a', error: 'boom', timestamp: t(1) });
+    expect(rollupActivePhase(r.getNodes())).toBeNull();
+  });
+});

package/test/autobio-progress-snapshot.test.ts

@@ -0,0 +1,40 @@
+import { describe, test, expect } from 'bun:test';
+import { AutobiographicalStrategy } from '@animalabs/agent-framework';
+
+// Guards against silent breakage if upstream renames the protected fields
+// that getProgressSnapshot reads. The shape is what warmup-session.ts relies on.
+describe('AutobiographicalStrategy.getProgressSnapshot', () => {
+  test('returns the expected shape on a fresh strategy', () => {
+    const strategy = new AutobiographicalStrategy({
+      compressionModel: 'claude-sonnet-4-5-20250929',
+      autoTickOnNewMessage: false,
+    });
+    const snapshot = strategy.getProgressSnapshot();
+    expect(snapshot).toEqual({
+      totalChunks: 0,
+      chunksCompressed: 0,
+      l1QueueLength: 0,
+      mergeQueueLength: 0,
+      summaryCounts: { l1: 0, l2: 0, l3: 0 },
+      pending: false,
+    });
+  });
+
+  test('exposes the keys warmup-session.ts depends on', () => {
+    const strategy = new AutobiographicalStrategy({
+      compressionModel: 'claude-sonnet-4-5-20250929',
+      autoTickOnNewMessage: false,
+    });
+    const s = strategy.getProgressSnapshot();
+    // Property access — if any rename happens upstream these become undefined
+    // and the test fails loudly.
+    expect(typeof s.totalChunks).toBe('number');
+    expect(typeof s.chunksCompressed).toBe('number');
+    expect(typeof s.l1QueueLength).toBe('number');
+    expect(typeof s.mergeQueueLength).toBe('number');
+    expect(typeof s.pending).toBe('boolean');
+    expect(typeof s.summaryCounts.l1).toBe('number');
+    expect(typeof s.summaryCounts.l2).toBe('number');
+    expect(typeof s.summaryCounts.l3).toBe('number');
+  });
+});