@genesislcap/ai-assistant 15.19.0 → 15.19.1

package/src/utils/condense-history.test.ts

@@ -1,746 +0,0 @@
-import type { ChatMessage, CondensePolicy } from '@genesislcap/foundation-ai';
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import {
-  applyCondensation,
-  CONDENSE_MIN_CHARS,
-  CONDENSED_ARGS_KEY,
-  type CondenseContext,
-  type CondensedEventDetail,
-  type RegisteredCondensePolicy,
-} from './condense-history';
-
-const suite = createLogicSuite('applyCondensation');
-
-// Payloads must clear the driver-level floor to be condensed.
-const big = (n: number = CONDENSE_MIN_CHARS + 500): string => 'x'.repeat(n);
-
-const asstCall = (
-  id: string,
-  name: string,
-  args: Record<string, unknown> = {},
-  extra: Record<string, unknown> = {},
-): ChatMessage => ({ role: 'assistant', content: '', toolCalls: [{ id, name, args, ...extra }] });
-
-const toolMsg = (toolCallId: string, content: string): ChatMessage => ({
-  role: 'tool',
-  content: '',
-  toolResult: { toolCallId, content },
-});
-
-const reg = (
-  policy: CondensePolicy,
-  clocks: { iteration?: number; turn?: number; activation?: number; phaseEpoch?: number } = {},
-): RegisteredCondensePolicy => ({
-  policy,
-  iteration: clocks.iteration ?? 1,
-  turn: clocks.turn ?? 1,
-  activation: clocks.activation ?? 1,
-  phaseEpoch: clocks.phaseEpoch ?? 1,
-});
-
-/** A CondenseContext for the pure transform. Defaults fire nothing; override per test. */
-const ctx = (
-  o: {
-    modelCall?: number;
-    turn?: number;
-    activationEnded?: (a: number) => boolean;
-    phaseEnded?: (e: number) => boolean;
-    batchCalls?: number;
-  } = {},
-): CondenseContext => ({
-  modelCall: o.modelCall ?? 0,
-  turn: o.turn ?? 0,
-  activationEnded: o.activationEnded ?? (() => false),
-  phaseEnded: o.phaseEnded ?? (() => false),
-  batchCalls: o.batchCalls,
-});
-
-const sink = () => {
-  const events: CondensedEventDetail[] = [];
-  return { events, on: (d: CondensedEventDetail) => events.push(d) };
-};
-
-// ---------------------------------------------------------------------------
-// supersession
-// ---------------------------------------------------------------------------
-
-suite('superseded response: collapses the earlier call, keeps the latest full', () => {
-  const history: ChatMessage[] = [
-    asstCall('r1', 'vfs_read', { path: 'A' }),
-    toolMsg('r1', big()),
-    asstCall('r2', 'vfs_read', { path: 'A' }),
-    toolMsg('r2', big()),
-  ];
-  const policies = new Map<string, RegisteredCondensePolicy>([
-    ['r1', reg({ on: { kind: 'superseded', by: 'A' }, response: 'pointer' })],
-    ['r2', reg({ on: { kind: 'superseded', by: 'A' }, response: 'pointer' })],
-  ]);
-  const { events, on } = sink();
-  const out = applyCondensation(history, policies, ctx(), on);
-
-  assert.match(out[1].toolResult!.content, /re-call to restore/);
-  assert.is(out[3].toolResult!.content, big(), 'latest call for the key stays full');
-  // Exactly one transition reported, for the earlier call's response.
-  assert.is(events.length, 1);
-  assert.is(events[0].toolCallId, 'r1');
-  assert.is(events[0].target, 'response');
-  assert.is(events[0].trigger, 'superseded:A');
-  // Input is never mutated; unchanged messages keep their identity.
-  assert.is(history[1].toolResult!.content, big(), 'stored history untouched');
-  assert.is(out[3], history[3], 'unchanged message reuses the same object');
-  assert.ok(out[1] !== history[1], 'collapsed message is a new object');
-});
-
-suite('superseded crosses tools: a read collapses the earlier write args of the same key', () => {
-  const history: ChatMessage[] = [
-    asstCall('w1', 'vfs_write', { path: 'A', content: big() }),
-    toolMsg('w1', 'written'),
-    asstCall('r1', 'vfs_read', { path: 'A' }),
-    toolMsg('r1', big()),
-  ];
-  const policies = new Map<string, RegisteredCondensePolicy>([
-    ['w1', reg({ on: { kind: 'superseded', by: 'A' }, args: 'pointer' })],
-    ['r1', reg({ on: { kind: 'superseded', by: 'A' }, response: 'pointer' })],
-  ]);
-  const { events, on } = sink();
-  const out = applyCondensation(history, policies, ctx(), on);
-
-  // Earlier write is superseded by the later read of the same key → its args collapse.
-  assert.match(String(out[0].toolCalls![0].args.condensed), /re-call to restore/);
-  // The read is the latest for key A → its response stays full.
-  assert.is(out[3].toolResult!.content, big());
-  assert.is(events.length, 1);
-  assert.is(events[0].toolCallId, 'w1');
-  assert.is(events[0].target, 'args');
-});
-
-// ---------------------------------------------------------------------------
-// age
-// ---------------------------------------------------------------------------
-
-suite('age: the model sees the result on `turns` turns, then it collapses', () => {
-  // Call made on iteration 1 → the result is first visible to the model on
-  // iteration 2. With turns:1 it may be read on that one turn, then collapses.
-  const history: ChatMessage[] = [asstCall('g1', 'grep_source', {}), toolMsg('g1', big())];
-  const policies = new Map<string, RegisteredCondensePolicy>([
-    ['g1', reg({ on: { kind: 'age', turns: 1 }, response: 'pointer' }, { iteration: 1 })],
-  ]);
-  const { events, on } = sink();
-
-  // Iteration 2 — its one allowed look: still full, nothing reported.
-  const seen = applyCondensation(history, policies, ctx({ modelCall: 2 }), on);
-  assert.is(seen[1].toolResult!.content, big(), 'full on the one turn it may be seen');
-  assert.is(events.length, 0, 'not collapsed while the model may still see it');
-
-  // Iteration 3 — one turn past the allowed view: collapses.
-  const collapsed = applyCondensation(history, policies, ctx({ modelCall: 3 }), on);
-  assert.match(collapsed[1].toolResult!.content, /aged out/);
-  assert.match(collapsed[1].toolResult!.content, /re-call to restore/);
-  assert.is(events.length, 1);
-  assert.is(events[0].trigger, 'age:1');
-});
-
-// ---------------------------------------------------------------------------
-// min-size floor
-// ---------------------------------------------------------------------------
-
-suite('payloads below the size floor are never condensed', () => {
-  const history: ChatMessage[] = [
-    asstCall('r1', 'vfs_read', { path: 'A' }),
-    toolMsg('r1', 'tiny'),
-    asstCall('r2', 'vfs_read', { path: 'A' }),
-    toolMsg('r2', big()),
-  ];
-  const policies = new Map<string, RegisteredCondensePolicy>([
-    ['r1', reg({ on: { kind: 'superseded', by: 'A' }, response: 'pointer' })],
-    ['r2', reg({ on: { kind: 'superseded', by: 'A' }, response: 'pointer' })],
-  ]);
-  const { events, on } = sink();
-  const out = applyCondensation(history, policies, ctx(), on);
-
-  assert.is(out[1].toolResult!.content, 'tiny', 'superseded but too small to bother');
-  assert.is(events.length, 0);
-});
-
-// ---------------------------------------------------------------------------
-// result modes
-// ---------------------------------------------------------------------------
-
-suite('drop / pointer / replaceWith produce distinct collapsed forms', () => {
-  const mk = (id: string, result: CondensePolicy['response']): [ChatMessage, ChatMessage] => [
-    asstCall(id, 'vfs_read', { path: id }),
-    toolMsg(id, big()),
-  ];
-  // Each call is superseded by a later same-key call so it actually fires.
-  const history: ChatMessage[] = [
-    ...mk('drop', 'drop'),
-    asstCall('drop2', 'vfs_read', { path: 'drop' }),
-    toolMsg('drop2', big()),
-    ...mk('ptr', 'pointer'),
-    asstCall('ptr2', 'vfs_read', { path: 'ptr' }),
-    toolMsg('ptr2', big()),
-    ...mk('rep', { replaceWith: 'SUMMARY' }),
-    asstCall('rep2', 'vfs_read', { path: 'rep' }),
-    toolMsg('rep2', big()),
-  ];
-  const policies = new Map<string, RegisteredCondensePolicy>([
-    ['drop', reg({ on: { kind: 'superseded', by: 'drop' }, response: 'drop' })],
-    ['drop2', reg({ on: { kind: 'superseded', by: 'drop' }, response: 'drop' })],
-    ['ptr', reg({ on: { kind: 'superseded', by: 'ptr' }, response: 'pointer' })],
-    ['ptr2', reg({ on: { kind: 'superseded', by: 'ptr' }, response: 'pointer' })],
-    ['rep', reg({ on: { kind: 'superseded', by: 'rep' }, response: { replaceWith: 'SUMMARY' } })],
-    ['rep2', reg({ on: { kind: 'superseded', by: 'rep' }, response: { replaceWith: 'SUMMARY' } })],
-  ]);
-  const { on } = sink();
-  const out = applyCondensation(history, policies, ctx(), on);
-
-  // `drop` differs from `pointer` ONLY by the restore promise — it still identifies the call,
-  // because a stub too bare to say what the call did is how GENC-1494 started.
-  assert.match(out[1].toolResult!.content, /vfs_read/, 'drop names the tool');
-  assert.match(out[1].toolResult!.content, /result elided/, 'drop says what was elided');
-  assert.not.match(
-    out[1].toolResult!.content,
-    /re-call to restore/,
-    'drop makes no restore promise',
-  );
-  assert.match(
-    out[5].toolResult!.content,
-    /re-call to restore/,
-    'pointer carries the restore hint',
-  );
-  assert.is(out[9].toolResult!.content, 'SUMMARY', 'replaceWith is verbatim — no hint appended');
-});
-
-// GENC-1494: dropped args must NEVER collapse to `{}`. A bare empty object is
-// indistinguishable from a call the model made with no arguments at all, and the model
-// treats its own history as fact — a ui-builder run read its elided `vfs_write` calls as
-// proof it was writing files with no content and re-wrote them for two hours. A bare marker
-// is not enough either: `path` goes with the args, so the stub must still say WHICH file.
-suite('args drop identifies the call; pointer stashes a stub under one key', () => {
-  const history: ChatMessage[] = [
-    asstCall('w1', 'vfs_write', { path: 'A', content: big() }),
-    toolMsg('w1', 'ok'),
-    asstCall('w2', 'vfs_write', { path: 'A', content: big() }),
-    toolMsg('w2', 'ok'),
-  ];
-  const policies = new Map<string, RegisteredCondensePolicy>([
-    ['w1', reg({ on: { kind: 'superseded', by: 'A' }, args: 'drop' })],
-    ['w2', reg({ on: { kind: 'superseded', by: 'A' }, args: 'drop' })],
-  ]);
-  const { on } = sink();
-  const out = applyCondensation(history, policies, ctx(), on);
-  const dropped = out[0].toolCalls![0].args;
-  const stub = String(dropped[CONDENSED_ARGS_KEY]);
-
-  assert.ok(
-    Object.keys(dropped).length > 0,
-    'dropped args are never empty — that reads as a no-argument call',
-  );
-  assert.match(stub, /vfs_write/, 'stub names the tool');
-  assert.match(stub, /\bA\b/, 'stub names the superseded key — which file this call wrote');
-  assert.not.match(stub, /re-call to restore/, 'drop must not promise a restore it cannot honour');
-  assert.equal(out[2].toolCalls![0].args, { path: 'A', content: big() }, 'latest write kept');
-});
-
-// GENC-1494: trigger resolution picks the first LISTED trigger that is currently true, so it
-// used to change after the collapse — with the usual `on: [{superseded}, {agentEnd}]`, a payload
-// collapsed at `agentEnd` re-resolved to `superseded` the moment a newer same-key call landed,
-// rewriting the stub and breaking the prompt cache a second time for an already-collapsed
-// payload. In one reported session that was 22/22 args collapses and 97 response collapses.
-suite('the fired trigger is latched, so a collapsed stub is never rewritten', () => {
-  const history: ChatMessage[] = [asstCall('r1', 'vfs_read', { path: 'A' }), toolMsg('r1', big())];
-  const entry = reg({
-    on: [{ kind: 'superseded', by: 'A' }, { kind: 'agentEnd' }],
-    response: 'pointer', // pointer embeds the reason, so a re-resolve is visible in the text
-  });
-  const policies = new Map<string, RegisteredCondensePolicy>([['r1', entry]]);
-  const { events, on } = sink();
-
-  // Pass 1: the activation has ended but nothing supersedes r1 yet → collapses as agentEnd.
-  const first = applyCondensation(history, policies, ctx({ activationEnded: () => true }), on);
-  assert.match(first[1].toolResult!.content, /agent finished/, 'collapses under agentEnd');
-  assert.is(events.length, 1);
-  assert.is(events[0].trigger, 'agentEnd');
-
-  // Pass 2: a newer read of the SAME key now exists, which would re-resolve the trigger to
-  // `superseded` (it is listed first). The already-collapsed stub must not change.
-  const grown: ChatMessage[] = [
-    ...history,
-    asstCall('r2', 'vfs_read', { path: 'A' }),
-    toolMsg('r2', big()),
-  ];
-  policies.set('r2', reg({ on: { kind: 'superseded', by: 'A' }, response: 'pointer' }));
-  const second = applyCondensation(grown, policies, ctx({ activationEnded: () => true }), on);
-
-  assert.match(second[1].toolResult!.content, /agent finished/, 'reason stays pinned to agentEnd');
-  assert.not.match(second[1].toolResult!.content, /superseded/, 'must not re-resolve');
-  assert.is(
-    second[1].toolResult!.content,
-    first[1].toolResult!.content,
-    'stub text is byte-stable',
-  );
-});
-
-// ---------------------------------------------------------------------------
-// envelope + metadata invariants
-// ---------------------------------------------------------------------------
-
-suite('collapsing args preserves the tool-call envelope and providerMetadata', () => {
-  const history: ChatMessage[] = [
-    asstCall(
-      'w1',
-      'vfs_write',
-      { path: 'A', content: big() },
-      { providerMetadata: { sig: 'keep' } },
-    ),
-    toolMsg('w1', 'ok'),
-    asstCall('w2', 'vfs_write', { path: 'A', content: big() }),
-    toolMsg('w2', 'ok'),
-  ];
-  const policies = new Map<string, RegisteredCondensePolicy>([
-    ['w1', reg({ on: { kind: 'superseded', by: 'A' }, args: 'pointer' })],
-    ['w2', reg({ on: { kind: 'superseded', by: 'A' }, args: 'pointer' })],
-  ]);
-  const { on } = sink();
-  const out = applyCondensation(history, policies, ctx(), on);
-  const tc = out[0].toolCalls![0];
-  assert.is(tc.id, 'w1', 'id preserved');
-  assert.is(tc.name, 'vfs_write', 'name preserved');
-  assert.equal(tc.providerMetadata, { sig: 'keep' }, 'reasoning signature round-trips');
-});
-
-// ---------------------------------------------------------------------------
-// report-once + no-op
-// ---------------------------------------------------------------------------
-
-suite('the event fires once per payload across repeated applies', () => {
-  const history: ChatMessage[] = [
-    asstCall('r1', 'vfs_read', { path: 'A' }),
-    toolMsg('r1', big()),
-    asstCall('r2', 'vfs_read', { path: 'A' }),
-    toolMsg('r2', big()),
-  ];
-  const policies = new Map<string, RegisteredCondensePolicy>([
-    ['r1', reg({ on: { kind: 'superseded', by: 'A' }, response: 'pointer' })],
-    ['r2', reg({ on: { kind: 'superseded', by: 'A' }, response: 'pointer' })],
-  ]);
-  const { events, on } = sink();
-  applyCondensation(history, policies, ctx(), on);
-  applyCondensation(history, policies, ctx(), on);
-  applyCondensation(history, policies, ctx(), on);
-  assert.is(events.length, 1, 'collapse re-runs every call but the transition is reported once');
-});
-
-suite('an empty registry is a pure pass-through (same array reference)', () => {
-  const history: ChatMessage[] = [asstCall('r1', 'vfs_read'), toolMsg('r1', big())];
-  const { events, on } = sink();
-  const out = applyCondensation(history, new Map(), ctx(), on);
-  assert.is(out, history);
-  assert.is(events.length, 0);
-});
-
-// ---------------------------------------------------------------------------
-// turnEnd
-// ---------------------------------------------------------------------------
-
-suite('turnEnd: full during its own turn, collapsed on a later turn', () => {
-  const history: ChatMessage[] = [asstCall('t1', 'read'), toolMsg('t1', big())];
-  const policies = new Map<string, RegisteredCondensePolicy>([
-    ['t1', reg({ on: { kind: 'turnEnd' }, response: 'pointer' }, { turn: 1 })],
-  ]);
-  const { events, on } = sink();
-
-  const sameTurn = applyCondensation(history, policies, ctx({ turn: 1 }), on);
-  assert.is(sameTurn[1].toolResult!.content, big(), 'full for the rest of the request');
-  assert.is(events.length, 0);
-
-  const laterTurn = applyCondensation(history, policies, ctx({ turn: 2 }), on);
-  assert.match(laterTurn[1].toolResult!.content, /turn ended/);
-  assert.is(events.length, 1);
-  assert.is(events[0].trigger, 'turnEnd');
-});
-
-// ---------------------------------------------------------------------------
-// agentEnd
-// ---------------------------------------------------------------------------
-
-suite('agentEnd: kept while the agent is active, collapsed once its activation ends', () => {
-  const history: ChatMessage[] = [asstCall('a1', 'load'), toolMsg('a1', big())];
-  const policies = new Map<string, RegisteredCondensePolicy>([
-    ['a1', reg({ on: { kind: 'agentEnd' }, response: 'pointer' }, { activation: 1 })],
-  ]);
-  const { events, on } = sink();
-
-  const active = applyCondensation(history, policies, ctx({ activationEnded: () => false }), on);
-  assert.is(active[1].toolResult!.content, big(), 'full while the agent flow is active');
-  assert.is(events.length, 0);
-
-  const ended = applyCondensation(history, policies, ctx({ activationEnded: (a) => a === 1 }), on);
-  assert.match(ended[1].toolResult!.content, /agent finished/);
-  assert.is(events.length, 1);
-  assert.is(events[0].trigger, 'agentEnd');
-});
-
-// ---------------------------------------------------------------------------
-// phaseEnd
-// ---------------------------------------------------------------------------
-
-suite('phaseEnd: kept within the phase, collapsed once the app advances the epoch', () => {
-  // Registered in phase epoch 1.
-  const history: ChatMessage[] = [asstCall('p1', 'load_entity'), toolMsg('p1', big())];
-  const policies = new Map<string, RegisteredCondensePolicy>([
-    ['p1', reg({ on: { kind: 'phaseEnd' }, response: 'pointer' }, { phaseEpoch: 1 })],
-  ]);
-  const { events, on } = sink();
-
-  // Still in phase 1 (no endPhase yet) — full.
-  const sameP = applyCondensation(history, policies, ctx({ phaseEnded: (e) => e < 1 }), on);
-  assert.is(sameP[1].toolResult!.content, big(), 'full while the phase is current');
-  assert.is(events.length, 0);
-
-  // endPhase() advanced the current epoch to 2 → the phase-1 payload collapses.
-  const ended = applyCondensation(history, policies, ctx({ phaseEnded: (e) => e < 2 }), on);
-  assert.match(ended[1].toolResult!.content, /phase ended/);
-  assert.match(ended[1].toolResult!.content, /re-call to restore/);
-  assert.is(events.length, 1);
-  assert.is(events[0].trigger, 'phaseEnd');
-});
-
-suite('phaseEnd: falls back to agentEnd when no phase boundary is ever declared', () => {
-  // Phase epoch never advances (phaseEnded always false), but the activation ends.
-  const history: ChatMessage[] = [asstCall('p1', 'load_entity'), toolMsg('p1', big())];
-  const policies = new Map<string, RegisteredCondensePolicy>([
-    [
-      'p1',
-      reg({ on: { kind: 'phaseEnd' }, response: 'pointer' }, { activation: 1, phaseEpoch: 1 }),
-    ],
-  ]);
-  const { events, on } = sink();
-
-  const active = applyCondensation(
-    history,
-    policies,
-    ctx({ phaseEnded: () => false, activationEnded: () => false }),
-    on,
-  );
-  assert.is(active[1].toolResult!.content, big(), 'full while both phase and agent are live');
-  assert.is(events.length, 0);
-
-  const disposed = applyCondensation(
-    history,
-    policies,
-    ctx({ phaseEnded: () => false, activationEnded: (a) => a === 1 }),
-    on,
-  );
-  assert.match(disposed[1].toolResult!.content, /phase ended/, 'agentEnd backstop collapses it');
-  assert.is(events.length, 1);
-  assert.is(events[0].trigger, 'phaseEnd');
-});
-
-// ---------------------------------------------------------------------------
-// multi-trigger (OR / first-wins)
-// ---------------------------------------------------------------------------
-
-suite('multi-trigger: collapses when ANY listed trigger fires', () => {
-  // superseded OR turnEnd — only one call for key A (never superseded), but the turn ends.
-  const history: ChatMessage[] = [asstCall('m1', 'read', { path: 'A' }), toolMsg('m1', big())];
-  const policies = new Map<string, RegisteredCondensePolicy>([
-    [
-      'm1',
-      reg(
-        { on: [{ kind: 'superseded', by: 'A' }, { kind: 'turnEnd' }], response: 'pointer' },
-        { turn: 1 },
-      ),
-    ],
-  ]);
-  const { events, on } = sink();
-
-  assert.is(
-    applyCondensation(history, policies, ctx({ turn: 1 }), on)[1].toolResult!.content,
-    big(),
-    'neither trigger has fired',
-  );
-  const later = applyCondensation(history, policies, ctx({ turn: 2 }), on);
-  assert.match(later[1].toolResult!.content, /turn ended/, 'turnEnd fired via the OR');
-  assert.is(events[0].trigger, 'turnEnd');
-});
-
-suite('multi-trigger first-wins: the earliest-listed firing trigger is the reason', () => {
-  // m1 is superseded by m2 AND its turn has ended; m2 is the latest (not superseded)
-  // but its turn has ended too. `superseded` is listed first.
-  const history: ChatMessage[] = [
-    asstCall('m1', 'read', { path: 'A' }),
-    toolMsg('m1', big()),
-    asstCall('m2', 'read', { path: 'A' }),
-    toolMsg('m2', big()),
-  ];
-  const on0: CondensePolicy = {
-    on: [{ kind: 'superseded', by: 'A' }, { kind: 'turnEnd' }],
-    response: 'pointer',
-  };
-  const policies = new Map<string, RegisteredCondensePolicy>([
-    ['m1', reg(on0, { turn: 1 })],
-    ['m2', reg(on0, { turn: 1 })],
-  ]);
-  const { events, on } = sink();
-  applyCondensation(history, policies, ctx({ turn: 2 }), on);
-
-  assert.is(
-    events.find((e) => e.toolCallId === 'm1')?.trigger,
-    'superseded:A',
-    'first-listed firing trigger wins as the reason',
-  );
-  assert.is(
-    events.find((e) => e.toolCallId === 'm2')?.trigger,
-    'turnEnd',
-    'the supersession survivor still collapses via the next trigger',
-  );
-});
-
-// ── batched collapse (GENC-1476) ───────────────────────────────────────────
-// Condensation rewrites history in place, so collapsing the instant a trigger fires
-// breaks the prompt cache on nearly every call of a re-read loop. Batching holds the
-// collapse set still between boundaries.
-
-const batch = createLogicSuite('applyCondensation batching');
-
-/** A re-read loop: `n` reads of the same path, each registered one model-call apart. */
-const reReadLoop = (n: number) => {
-  const history: ChatMessage[] = [];
-  const policies = new Map<string, RegisteredCondensePolicy>();
-  for (let i = 1; i <= n; i += 1) {
-    history.push(asstCall(`r${i}`, 'vfs_read', { path: 'A.tsx' }), toolMsg(`r${i}`, big()));
-    policies.set(
-      `r${i}`,
-      reg({ on: { kind: 'superseded', by: 'A.tsx' }, response: 'pointer' }, { iteration: i }),
-    );
-  }
-  return { history, policies };
-};
-
-/** Result content of every tool message, in order. */
-const results = (out: ChatMessage[]): string[] =>
-  out.filter((m) => m.role === 'tool').map((m) => m.toolResult?.content ?? '');
-
-batch('without batching every superseded read collapses immediately', () => {
-  const { history, policies } = reReadLoop(4);
-  const out = results(applyCondensation(history, policies, ctx({ modelCall: 4 }), sink().on));
-  // Only the newest survives; the other three are already stubs.
-  assert.is(out.filter((c) => c.startsWith('[')).length, 3);
-  assert.is(out[3].length, big().length);
-});
-
-batch('batching leaves the prefix untouched between boundaries', () => {
-  const { history, policies } = reReadLoop(4);
-  // Boundary is floor(4/10)*10 = 0, so no call is within the batch yet.
-  const out = results(
-    applyCondensation(history, policies, ctx({ modelCall: 4, batchCalls: 10 }), sink().on),
-  );
-  assert.equal(
-    out.map((c) => c.length),
-    [big().length, big().length, big().length, big().length],
-  );
-});
-
-batch('the batch boundary collapses the backlog in one step', () => {
-  const { history, policies } = reReadLoop(12);
-  const before = results(
-    applyCondensation(history, policies, ctx({ modelCall: 9, batchCalls: 10 }), sink().on),
-  );
-  const after = results(
-    applyCondensation(history, policies, ctx({ modelCall: 10, batchCalls: 10 }), sink().on),
-  );
-  assert.is(before.filter((c) => c.startsWith('[')).length, 0);
-  // At the boundary, reads 1-9 collapse together; 10-12 are past it and stay full.
-  assert.is(after.filter((c) => c.startsWith('[')).length, 9);
-});
-
-batch('a call past the boundary neither collapses nor supersedes an older one', () => {
-  // The regression this guards: excluding the new call as a SUPERSEDER but still letting
-  // it collapse would elide the very result the agent just fetched.
-  const { history, policies } = reReadLoop(2);
-  policies.set(
-    'r2',
-    reg({ on: { kind: 'superseded', by: 'A.tsx' }, response: 'pointer' }, { iteration: 7 }),
-  );
-  const out = results(
-    applyCondensation(history, policies, ctx({ modelCall: 7, batchCalls: 5 }), sink().on),
-  );
-  assert.is(out[1].length, big().length, 'the newest read must stay full');
-  assert.is(out[0].length, big().length, 'the older read must not collapse early either');
-});
-
-batch('age is measured against the boundary, not the live clock', () => {
-  const history = [asstCall('g1', 'grep', {}), toolMsg('g1', big())];
-  const policies = new Map([
-    ['g1', reg({ on: { kind: 'age', turns: 1 }, response: 'pointer' }, { iteration: 1 })],
-  ]);
-  // Live clock says age 4 > 1 (would collapse); the boundary says 0, so it holds.
-  const held = results(
-    applyCondensation(history, policies, ctx({ modelCall: 5, batchCalls: 10 }), sink().on),
-  );
-  assert.is(held[0].length, big().length);
-  const collapsed = results(
-    applyCondensation(history, policies, ctx({ modelCall: 10, batchCalls: 10 }), sink().on),
-  );
-  assert.ok(collapsed[0].startsWith('['));
-});
-
-batch('batchCalls of 1, 0 or absent all keep the historical behaviour', () => {
-  for (const batchCalls of [1, 0, undefined]) {
-    const { history, policies } = reReadLoop(3);
-    const out = results(
-      applyCondensation(history, policies, ctx({ modelCall: 3, batchCalls }), sink().on),
-    );
-    assert.is(out.filter((c) => c.startsWith('[')).length, 2, `batchCalls=${batchCalls}`);
-  }
-});
-
-batch('agentEnd is exempt from batching — it collapses as it fires', () => {
-  // An agent swap changes the system prompt and tool defs, which invalidates the cached
-  // prefix anyway, so deferring the collapse would hold a stale payload for nothing.
-  const history = [asstCall('a1', 'read_context', {}), toolMsg('a1', big())];
-  const policies = new Map([
-    ['a1', reg({ on: { kind: 'agentEnd' }, response: 'pointer' }, { iteration: 7, activation: 1 })],
-  ]);
-  const out = results(
-    applyCondensation(
-      history,
-      policies,
-      ctx({ modelCall: 7, batchCalls: 10, activationEnded: () => true }),
-      sink().on,
-    ),
-  );
-  // Boundary is 0 and the call sits at 7, so a batched trigger would have been deferred.
-  assert.ok(out[0].startsWith('['));
-});
-
-batch('phaseEnd is exempt too', () => {
-  const history = [asstCall('p1', 'read_docs', {}), toolMsg('p1', big())];
-  const policies = new Map([
-    ['p1', reg({ on: { kind: 'phaseEnd' }, response: 'pointer' }, { iteration: 7, phaseEpoch: 1 })],
-  ]);
-  const out = results(
-    applyCondensation(
-      history,
-      policies,
-      ctx({ modelCall: 7, batchCalls: 10, phaseEnded: () => true }),
-      sink().on,
-    ),
-  );
-  assert.ok(out[0].startsWith('['));
-});
-
-batch('a mixed policy batches superseded but still honours agentEnd immediately', () => {
-  // The vfs shape: `on: [{ superseded }, { agentEnd }]`. Mid-run the supersession is
-  // deferred; once the agent ends the payload collapses regardless of the boundary.
-  const { history, policies } = reReadLoop(2);
-  for (const id of ['r1', 'r2'])
-    policies.set(
-      id,
-      reg(
-        { on: [{ kind: 'superseded', by: 'A.tsx' }, { kind: 'agentEnd' }], response: 'pointer' },
-        { iteration: id === 'r1' ? 1 : 2, activation: 1 },
-      ),
-    );
-  const midRun = results(
-    applyCondensation(history, policies, ctx({ modelCall: 4, batchCalls: 10 }), sink().on),
-  );
-  assert.is(midRun.filter((c) => c.startsWith('[')).length, 0, 'supersession is deferred');
-
-  const afterSwap = results(
-    applyCondensation(
-      history,
-      policies,
-      ctx({ modelCall: 4, batchCalls: 10, activationEnded: () => true }),
-      sink().on,
-    ),
-  );
-  assert.is(afterSwap.filter((c) => c.startsWith('[')).length, 2, 'agentEnd collapses both');
-});
-
-batch.run();
-
-// ---------------------------------------------------------------------------
-// image-bearing tool results (GENC-1508)
-//
-// A render tool returns a few words of text plus ~15KB of base64. Sizing the payload
-// on `content` alone leaves it permanently under the floor, so the image rides every
-// later turn — the exact bytes condensation exists to shed. And a stub that leaves the
-// attachments in place claims a collapse that did not happen.
-// ---------------------------------------------------------------------------
-
-/** A tool result shaped like a mockup render: short text, one large image. */
-const imageToolMsg = (toolCallId: string, dataLen: number): ChatMessage => ({
-  role: 'tool',
-  content: 'rendered',
-  toolResult: {
-    toolCallId,
-    content: 'rendered',
-    attachments: [
-      { kind: 'image', name: 'mockup.png', mimeType: 'image/png', data: 'a'.repeat(dataLen) },
-    ],
-  },
-});
-
-suite('image bytes count toward the condense floor, so a short-text render condenses', () => {
-  const history: ChatMessage[] = [
-    asstCall('m1', 'render_mockup', { html: '<p/>' }),
-    imageToolMsg('m1', CONDENSE_MIN_CHARS + 500),
-    asstCall('m2', 'render_mockup', { html: '<p/>' }),
-    imageToolMsg('m2', CONDENSE_MIN_CHARS + 500),
-  ];
-  const policies = new Map<string, RegisteredCondensePolicy>([
-    ['m1', reg({ on: { kind: 'superseded', by: 'mockup' }, response: 'pointer' })],
-    ['m2', reg({ on: { kind: 'superseded', by: 'mockup' }, response: 'pointer' })],
-  ]);
-  const { on } = sink();
-  const out = applyCondensation(history, policies, ctx(), on);
-  assert.ok(
-    out[1].toolResult!.content.startsWith('['),
-    'the superseded render is collapsed to a stub — sizing on content alone would skip it',
-  );
-});
-
-suite('a condensed image result drops its attachments, not just its text', () => {
-  const history: ChatMessage[] = [
-    asstCall('m1', 'render_mockup', { html: '<p/>' }),
-    imageToolMsg('m1', CONDENSE_MIN_CHARS + 500),
-    asstCall('m2', 'render_mockup', { html: '<p/>' }),
-    imageToolMsg('m2', CONDENSE_MIN_CHARS + 500),
-  ];
-  const policies = new Map<string, RegisteredCondensePolicy>([
-    ['m1', reg({ on: { kind: 'superseded', by: 'mockup' }, response: 'pointer' })],
-    ['m2', reg({ on: { kind: 'superseded', by: 'mockup' }, response: 'pointer' })],
-  ]);
-  const { on } = sink();
-  const out = applyCondensation(history, policies, ctx(), on);
-  assert.is(
-    out[1].toolResult!.attachments,
-    undefined,
-    'leaving the image attached would shed none of the bytes the stub claims were elided',
-  );
-  assert.equal(
-    out[3].toolResult!.attachments?.length,
-    1,
-    'the surviving latest render keeps its image',
-  );
-});
-
-suite('a short text-only result is still below the floor with no attachments', () => {
-  const history: ChatMessage[] = [
-    asstCall('s1', 'render_mockup', {}),
-    toolMsg('s1', 'rendered'),
-    asstCall('s2', 'render_mockup', {}),
-    toolMsg('s2', 'rendered'),
-  ];
-  const policies = new Map<string, RegisteredCondensePolicy>([
-    ['s1', reg({ on: { kind: 'superseded', by: 'mockup' }, response: 'pointer' })],
-    ['s2', reg({ on: { kind: 'superseded', by: 'mockup' }, response: 'pointer' })],
-  ]);
-  const { on } = sink();
-  const out = applyCondensation(history, policies, ctx(), on);
-  assert.is(out[1].toolResult!.content, 'rendered', 'the floor still protects small payloads');
-});
-
-suite.run();