@genesislcap/ai-assistant 14.467.2 → 14.468.0

package/dist/esm/utils/condense-history.test.js

@@ -0,0 +1,297 @@
+import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
+import { applyCondensation, CONDENSE_MIN_CHARS, } from './condense-history';
+const suite = createLogicSuite('applyCondensation');
+// Payloads must clear the driver-level floor to be condensed.
+const big = (n = CONDENSE_MIN_CHARS + 500) => 'x'.repeat(n);
+const asstCall = (id, name, args = {}, extra = {}) => ({ role: 'assistant', content: '', toolCalls: [Object.assign({ id, name, args }, extra)] });
+const toolMsg = (toolCallId, content) => ({
+    role: 'tool',
+    content: '',
+    toolResult: { toolCallId, content },
+});
+const reg = (policy, clocks = {}) => {
+    var _a, _b, _c;
+    return ({
+        policy,
+        iteration: (_a = clocks.iteration) !== null && _a !== void 0 ? _a : 1,
+        turn: (_b = clocks.turn) !== null && _b !== void 0 ? _b : 1,
+        activation: (_c = clocks.activation) !== null && _c !== void 0 ? _c : 1,
+    });
+};
+/** A CondenseContext for the pure transform. Defaults fire nothing; override per test. */
+const ctx = (o = {}) => {
+    var _a, _b, _c;
+    return ({
+        modelCall: (_a = o.modelCall) !== null && _a !== void 0 ? _a : 0,
+        turn: (_b = o.turn) !== null && _b !== void 0 ? _b : 0,
+        activationEnded: (_c = o.activationEnded) !== null && _c !== void 0 ? _c : (() => false),
+    });
+};
+const sink = () => {
+    const events = [];
+    return { events, on: (d) => events.push(d) };
+};
+// ---------------------------------------------------------------------------
+// supersession
+// ---------------------------------------------------------------------------
+suite('superseded response: collapses the earlier call, keeps the latest full', () => {
+    const history = [
+        asstCall('r1', 'vfs_read', { path: 'A' }),
+        toolMsg('r1', big()),
+        asstCall('r2', 'vfs_read', { path: 'A' }),
+        toolMsg('r2', big()),
+    ];
+    const policies = new Map([
+        ['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 = [
+        asstCall('w1', 'vfs_write', { path: 'A', content: big() }),
+        toolMsg('w1', 'written'),
+        asstCall('r1', 'vfs_read', { path: 'A' }),
+        toolMsg('r1', big()),
+    ];
+    const policies = new Map([
+        ['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 = [asstCall('g1', 'grep_source', {}), toolMsg('g1', big())];
+    const policies = new Map([
+        ['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 = [
+        asstCall('r1', 'vfs_read', { path: 'A' }),
+        toolMsg('r1', 'tiny'),
+        asstCall('r2', 'vfs_read', { path: 'A' }),
+        toolMsg('r2', big()),
+    ];
+    const policies = new Map([
+        ['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, result) => [
+        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 = [
+        ...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([
+        ['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);
+    assert.is(out[1].toolResult.content, '[elided]', 'drop is a minimal non-empty placeholder');
+    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');
+});
+suite('args drop yields an empty object; pointer stashes a stub under one key', () => {
+    const history = [
+        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([
+        ['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);
+    assert.equal(out[0].toolCalls[0].args, {}, 'dropped args is an empty object');
+    assert.equal(out[2].toolCalls[0].args, { path: 'A', content: big() }, 'latest write kept');
+});
+// ---------------------------------------------------------------------------
+// envelope + metadata invariants
+// ---------------------------------------------------------------------------
+suite('collapsing args preserves the tool-call envelope and providerMetadata', () => {
+    const history = [
+        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([
+        ['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 = [
+        asstCall('r1', 'vfs_read', { path: 'A' }),
+        toolMsg('r1', big()),
+        asstCall('r2', 'vfs_read', { path: 'A' }),
+        toolMsg('r2', big()),
+    ];
+    const policies = new Map([
+        ['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 = [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 = [asstCall('t1', 'read'), toolMsg('t1', big())];
+    const policies = new Map([
+        ['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 = [asstCall('a1', 'load'), toolMsg('a1', big())];
+    const policies = new Map([
+        ['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');
+});
+// ---------------------------------------------------------------------------
+// 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 = [asstCall('m1', 'read', { path: 'A' }), toolMsg('m1', big())];
+    const policies = new Map([
+        [
+            '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', () => {
+    var _a, _b;
+    // 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 = [
+        asstCall('m1', 'read', { path: 'A' }),
+        toolMsg('m1', big()),
+        asstCall('m2', 'read', { path: 'A' }),
+        toolMsg('m2', big()),
+    ];
+    const on0 = {
+        on: [{ kind: 'superseded', by: 'A' }, { kind: 'turnEnd' }],
+        response: 'pointer',
+    };
+    const policies = new Map([
+        ['m1', reg(on0, { turn: 1 })],
+        ['m2', reg(on0, { turn: 1 })],
+    ]);
+    const { events, on } = sink();
+    applyCondensation(history, policies, ctx({ turn: 2 }), on);
+    assert.is((_a = events.find((e) => e.toolCallId === 'm1')) === null || _a === void 0 ? void 0 : _a.trigger, 'superseded:A', 'first-listed firing trigger wins as the reason');
+    assert.is((_b = events.find((e) => e.toolCallId === 'm2')) === null || _b === void 0 ? void 0 : _b.trigger, 'turnEnd', 'the supersession survivor still collapses via the next trigger');
+});
+suite.run();

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/index.ts","../src/channel/ai-activity-bus.ts","../src/channel/ai-activity-channel.ts","../src/components/flowing-waves-indicator.ts","../src/components/halo-overlay.ts","../src/components/plasma-orb-indicator.ts","../src/components/waves-indicator.ts","../src/components/activity-halo/activity-halo.ts","../src/components/agent-picker/agent-picker.constants.ts","../src/components/agent-picker/agent-picker.styles.ts","../src/components/agent-picker/agent-picker.template.ts","../src/components/agent-picker/agent-picker.ts","../src/components/agent-picker/index.ts","../src/components/ai-driver/ai-driver.ts","../src/components/ai-driver/index.ts","../src/components/chat-bubble/chat-bubble.styles.ts","../src/components/chat-bubble/chat-bubble.template.ts","../src/components/chat-bubble/chat-bubble.ts","../src/components/chat-bubble/index.ts","../src/components/chat-driver/align-event-globals.ts","../src/components/chat-driver/chat-driver.test.ts","../src/components/chat-driver/chat-driver.ts","../src/components/chat-driver/index.ts","../src/components/chat-interaction-wrapper/chat-interaction-wrapper.styles.ts","../src/components/chat-interaction-wrapper/chat-interaction-wrapper.template.ts","../src/components/chat-interaction-wrapper/chat-interaction-wrapper.test.ts","../src/components/chat-interaction-wrapper/chat-interaction-wrapper.ts","../src/components/chat-interaction-wrapper/index.ts","../src/components/chat-markdown/chat-markdown.ts","../src/components/chat-markdown/index.ts","../src/components/orchestrating-driver/index.ts","../src/components/orchestrating-driver/orchestrating-driver.ts","../src/components/popout-manager/index.ts","../src/components/popout-manager/popout-manager.ts","../src/config/config.ts","../src/config/define-stateful-agent.test.ts","../src/config/define-stateful-agent.ts","../src/config/fallback-agents.ts","../src/config/index.ts","../src/config/validate-providers.test.ts","../src/config/validate-providers.ts","../src/main/index.ts","../src/main/main.styles.ts","../src/main/main.template.ts","../src/main/main.ts","../src/main/main.types.ts","../src/state/ai-assistant-slice.ts","../src/state/debug-event-log.test.ts","../src/state/debug-event-log.ts","../src/state/driver-registry.ts","../src/state/session-store.ts","../src/styles/ai-colours.ts","../src/styles/index.ts","../src/styles/styles.ts","../src/suggestions/chat-suggestions.ts","../src/tags/index.ts","../src/types/ai-chat-widget.ts","../src/utils/animated-panel-toggle.ts","../src/utils/animation-exclusivity.test.ts","../src/utils/animation-exclusivity.ts","../src/utils/flatten-sub-agent-messages.test.ts","../src/utils/flatten-sub-agent-messages.ts","../src/utils/history-transform.ts","../src/utils/index.ts","../src/utils/logger.ts","../src/utils/message-partition.test.ts","../src/utils/message-partition.ts","../src/utils/strip-agent-handlers.test.ts","../src/utils/strip-agent-handlers.ts","../src/utils/sum-costs.test.ts","../src/utils/sum-costs.ts","../src/utils/tool-fold.ts"],"version":"5.9.2"}
+{"root":["../src/index.ts","../src/channel/ai-activity-bus.ts","../src/channel/ai-activity-channel.ts","../src/components/flowing-waves-indicator.ts","../src/components/halo-overlay.ts","../src/components/plasma-orb-indicator.ts","../src/components/waves-indicator.ts","../src/components/activity-halo/activity-halo.ts","../src/components/agent-picker/agent-picker.constants.ts","../src/components/agent-picker/agent-picker.styles.ts","../src/components/agent-picker/agent-picker.template.ts","../src/components/agent-picker/agent-picker.ts","../src/components/agent-picker/index.ts","../src/components/ai-driver/ai-driver.ts","../src/components/ai-driver/index.ts","../src/components/chat-bubble/chat-bubble.styles.ts","../src/components/chat-bubble/chat-bubble.template.ts","../src/components/chat-bubble/chat-bubble.ts","../src/components/chat-bubble/index.ts","../src/components/chat-driver/align-event-globals.ts","../src/components/chat-driver/chat-driver.test.ts","../src/components/chat-driver/chat-driver.ts","../src/components/chat-driver/index.ts","../src/components/chat-interaction-wrapper/chat-interaction-wrapper.styles.ts","../src/components/chat-interaction-wrapper/chat-interaction-wrapper.template.ts","../src/components/chat-interaction-wrapper/chat-interaction-wrapper.test.ts","../src/components/chat-interaction-wrapper/chat-interaction-wrapper.ts","../src/components/chat-interaction-wrapper/index.ts","../src/components/chat-markdown/chat-markdown.ts","../src/components/chat-markdown/index.ts","../src/components/orchestrating-driver/index.ts","../src/components/orchestrating-driver/orchestrating-driver.ts","../src/components/popout-manager/index.ts","../src/components/popout-manager/popout-manager.ts","../src/config/config.ts","../src/config/define-stateful-agent.test.ts","../src/config/define-stateful-agent.ts","../src/config/fallback-agents.ts","../src/config/index.ts","../src/config/validate-providers.test.ts","../src/config/validate-providers.ts","../src/main/index.ts","../src/main/main.styles.ts","../src/main/main.template.ts","../src/main/main.ts","../src/main/main.types.ts","../src/state/ai-assistant-slice.ts","../src/state/debug-event-log.test.ts","../src/state/debug-event-log.ts","../src/state/driver-registry.ts","../src/state/session-store.ts","../src/styles/ai-colours.ts","../src/styles/index.ts","../src/styles/styles.ts","../src/suggestions/chat-suggestions.ts","../src/tags/index.ts","../src/types/ai-chat-widget.ts","../src/utils/animated-panel-toggle.ts","../src/utils/animation-exclusivity.test.ts","../src/utils/animation-exclusivity.ts","../src/utils/condense-history.test.ts","../src/utils/condense-history.ts","../src/utils/flatten-sub-agent-messages.test.ts","../src/utils/flatten-sub-agent-messages.ts","../src/utils/history-transform.ts","../src/utils/index.ts","../src/utils/logger.ts","../src/utils/message-partition.test.ts","../src/utils/message-partition.ts","../src/utils/strip-agent-handlers.test.ts","../src/utils/strip-agent-handlers.ts","../src/utils/sum-costs.test.ts","../src/utils/sum-costs.ts","../src/utils/tool-fold.ts"],"version":"5.9.2"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@genesislcap/ai-assistant",
   "description": "Genesis AI Assistant micro-frontend",
-  "version": "14.467.2",
+  "version": "14.468.0",
   "license": "SEE LICENSE IN license.txt",
   "main": "dist/esm/index.js",
   "types": "dist/ai-assistant.d.ts",
@@ -64,24 +64,24 @@
     }
   },
   "devDependencies": {
-    "@genesislcap/foundation-testing": "14.467.2",
-    "@genesislcap/genx": "14.467.2",
-    "@genesislcap/rollup-builder": "14.467.2",
-    "@genesislcap/ts-builder": "14.467.2",
-    "@genesislcap/uvu-playwright-builder": "14.467.2",
-    "@genesislcap/vite-builder": "14.467.2",
-    "@genesislcap/webpack-builder": "14.467.2",
+    "@genesislcap/foundation-testing": "14.468.0",
+    "@genesislcap/genx": "14.468.0",
+    "@genesislcap/rollup-builder": "14.468.0",
+    "@genesislcap/ts-builder": "14.468.0",
+    "@genesislcap/uvu-playwright-builder": "14.468.0",
+    "@genesislcap/vite-builder": "14.468.0",
+    "@genesislcap/webpack-builder": "14.468.0",
     "@types/dompurify": "^3.0.5",
     "@types/marked": "^5.0.2"
   },
   "dependencies": {
-    "@genesislcap/foundation-ai": "14.467.2",
-    "@genesislcap/foundation-logger": "14.467.2",
-    "@genesislcap/foundation-redux": "14.467.2",
-    "@genesislcap/foundation-ui": "14.467.2",
-    "@genesislcap/foundation-utils": "14.467.2",
-    "@genesislcap/rapid-design-system": "14.467.2",
-    "@genesislcap/web-core": "14.467.2",
+    "@genesislcap/foundation-ai": "14.468.0",
+    "@genesislcap/foundation-logger": "14.468.0",
+    "@genesislcap/foundation-redux": "14.468.0",
+    "@genesislcap/foundation-ui": "14.468.0",
+    "@genesislcap/foundation-utils": "14.468.0",
+    "@genesislcap/rapid-design-system": "14.468.0",
+    "@genesislcap/web-core": "14.468.0",
     "dompurify": "^3.3.1",
     "marked": "^17.0.3"
   },
@@ -93,5 +93,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "2edbf1311578ebd00440aacdd362b30411428923"
+  "gitHead": "0dfb3e9bf917a6de7e74e52d86995cfcd85f3110"
 }

package/src/components/chat-driver/chat-driver.test.ts

@@ -38,6 +38,8 @@ interface ScriptedProvider extends AIProvider {
   toolChoicePerCall: Array<ChatToolChoice | undefined>;
   /** `temperature` seen on each `chat()` call, in order. */
   temperaturePerCall: Array<number | undefined>;
+  /** The model-bound history slice seen on each `chat()` call (post-transform). */
+  historyPerCall: ChatMessage[][];
 }
 
 const scriptedProvider = (responses: ChatMessage[]): ScriptedProvider => {
@@ -45,18 +47,23 @@ const scriptedProvider = (responses: ChatMessage[]): ScriptedProvider => {
   const advertisedPerCall: string[][] = [];
   const toolChoicePerCall: Array<ChatToolChoice | undefined> = [];
   const temperaturePerCall: Array<number | undefined> = [];
+  const historyPerCall: ChatMessage[][] = [];
   return {
     advertisedPerCall,
     toolChoicePerCall,
     temperaturePerCall,
+    historyPerCall,
     chat: async (
-      _history: ChatMessage[],
+      history: ChatMessage[],
       _userMessage: string,
       options?: ChatRequestOptions,
     ): Promise<ChatMessage> => {
       advertisedPerCall.push((options?.tools ?? []).map((t) => t.name));
       toolChoicePerCall.push(options?.toolChoice);
       temperaturePerCall.push(options?.temperature);
+      // Snapshot the slice (condensation produces fresh objects per call and never
+      // mutates stored history, so a shallow array copy is a stable per-call view).
+      historyPerCall.push([...history]);
       // Once the script is exhausted, end the turn with a plain text reply.
       return queue.shift() ?? { role: 'assistant', content: 'done' };
     },
@@ -1648,3 +1655,228 @@ modelAttr('omits the model key entirely when the provider reports no status', as
 });
 
 modelAttr.run();
+
+// ---------------------------------------------------------------------------
+// condenseWhen — tool-declared context condensation (wiring through the loop)
+// ---------------------------------------------------------------------------
+
+const condense = createLogicSuite('ChatDriver condenseWhen');
+condense.after(() => {
+  agenticActivityBus.close();
+});
+
+const bigBody = 'A'.repeat(2000);
+
+/** An assistant turn calling `read` with a path arg (so `by: args.path` resolves). */
+const readsPath = (id: string, path: string): ChatMessage => ({
+  role: 'assistant',
+  content: '',
+  toolCalls: [{ id, name: 'read', args: { path } }],
+});
+
+condense(
+  'collapses a superseded result in the model slice but keeps stored history full',
+  async () => {
+    const sessionKey = 'condense-supersede';
+    clearMetaEventRegistry();
+    const provider = scriptedProvider([
+      readsPath('r1', 'A'),
+      readsPath('r2', 'A'), // re-read of the same path supersedes r1
+    ]);
+    const config = agent({
+      name: 'reader',
+      systemPrompt: 'read files',
+      toolDefinitions: [def('read')],
+      toolHandlers: {
+        read: async (args, ctx) => {
+          ctx.condenseWhen({
+            on: { kind: 'superseded', by: String(args.path) },
+            response: 'pointer',
+          });
+          return bigBody;
+        },
+      },
+    });
+    const driver = makeDriver(config, provider, sessionKey);
+
+    const result = await driver.sendMessage('go');
+    assert.is(result.reason, 'done');
+
+    // The 3rd provider call (index 2) ran after both reads: r1 is superseded, r2 is latest.
+    const slice = provider.historyPerCall[2];
+    const r1 = slice.find((m) => m.toolResult?.toolCallId === 'r1');
+    const r2 = slice.find((m) => m.toolResult?.toolCallId === 'r2');
+    assert.match(
+      r1!.toolResult!.content,
+      /re-call to restore/,
+      'earlier read collapsed for the model',
+    );
+    assert.is(r2!.toolResult!.content, bigBody, 'latest read still full');
+
+    // Stored history is untouched — both reads remain full for the UI / debug export.
+    assert.is(
+      toolResultContents(driver).filter((c) => c === bigBody).length,
+      2,
+      'stored history retains both full reads',
+    );
+
+    // One context.condensed meta-event, for r1's response, recorded once.
+    const events = getMetaEvents(sessionKey).filter((e) => e.type === 'context.condensed');
+    assert.is(events.length, 1, 'the full→stub transition is reported exactly once');
+    assert.is(events[0].detail?.toolCallId, 'r1');
+    assert.is(events[0].detail?.target, 'response');
+  },
+);
+
+condense('first-wins: a second condenseWhen for the same tool call is ignored', async () => {
+  const sessionKey = 'condense-first-wins';
+  clearMetaEventRegistry();
+  const provider = scriptedProvider([readsPath('r1', 'A'), readsPath('r2', 'A')]);
+  const config = agent({
+    name: 'reader',
+    systemPrompt: 'read files',
+    toolDefinitions: [def('read')],
+    toolHandlers: {
+      read: async (args, ctx) => {
+        // First declaration wins; the second (a different mode) is dropped.
+        ctx.condenseWhen({
+          on: { kind: 'superseded', by: String(args.path) },
+          response: 'pointer',
+        });
+        ctx.condenseWhen({
+          on: { kind: 'superseded', by: String(args.path) },
+          response: { replaceWith: 'SECOND' },
+        });
+        return bigBody;
+      },
+    },
+  });
+  const driver = makeDriver(config, provider, sessionKey);
+  await driver.sendMessage('go');
+
+  const collapsed = provider.historyPerCall[2].find((m) => m.toolResult?.toolCallId === 'r1');
+  assert.match(
+    collapsed!.toolResult!.content,
+    /re-call to restore/,
+    'the first (pointer) policy applied',
+  );
+  assert.is.not(collapsed!.toolResult!.content, 'SECOND', 'the later policy was ignored');
+});
+
+condense('age clock is monotonic across turns — collapses on a later, separate turn', async () => {
+  // Regression guard for the per-turn-reset bug: the age clock is the local loop
+  // counter that resets every `sendMessage`, so an `age` payload from turn 1
+  // would never collapse across short turns. The driver now uses a monotonic
+  // model-call counter, so it does.
+  const sessionKey = 'condense-age-cross-turn';
+  clearMetaEventRegistry();
+  const provider = scriptedProvider([
+    { role: 'assistant', content: '', toolCalls: [{ id: 'n1', name: 'notes', args: {} }] }, // turn 1, call 1
+    { role: 'assistant', content: 'noted' }, // turn 1, call 2 — model sees n1 once (full), turn ends
+    { role: 'assistant', content: 'ok' }, // turn 2, call 1 — a short follow-up, no tools
+  ]);
+  const config = agent({
+    name: 'note-taker',
+    systemPrompt: 'take notes',
+    toolDefinitions: [def('notes')],
+    toolHandlers: {
+      notes: async (_args, ctx) => {
+        ctx.condenseWhen({ on: { kind: 'age', turns: 1 }, response: 'pointer' });
+        return bigBody;
+      },
+    },
+  });
+  const driver = makeDriver(config, provider, sessionKey);
+
+  await driver.sendMessage('first'); // turn 1
+  await driver.sendMessage('second'); // turn 2 — a separate, short sendMessage
+
+  // Turn 1's consume call (provider call #1) saw n1 in full — its one allowed look.
+  const turn1Consume = provider.historyPerCall[1].find((m) => m.toolResult?.toolCallId === 'n1');
+  assert.is(turn1Consume!.toolResult!.content, bigBody, 'full on its one allowed turn');
+
+  // Turn 2's first call (#2) is a SEPARATE sendMessage — the local loop counter has
+  // reset to 0, but the monotonic clock kept counting, so n1 is now collapsed.
+  // Under the old per-turn counter it would still be full here.
+  const turn2 = provider.historyPerCall[2].find((m) => m.toolResult?.toolCallId === 'n1');
+  assert.match(turn2!.toolResult!.content, /re-call to restore/, 'collapsed on the next turn');
+
+  assert.ok(toolResultContents(driver).includes(bigBody), 'stored history retains the full note');
+  const events = getMetaEvents(sessionKey).filter((e) => e.type === 'context.condensed');
+  assert.is(events.length, 1);
+  assert.is(events[0].detail?.trigger, 'age:1');
+});
+
+condense('turnEnd: full during its request, collapsed on the next user turn', async () => {
+  const sessionKey = 'condense-turn-end';
+  clearMetaEventRegistry();
+  const provider = scriptedProvider([
+    { role: 'assistant', content: '', toolCalls: [{ id: 'n1', name: 'notes', args: {} }] }, // turn 1, call 1
+    { role: 'assistant', content: 'noted' }, // turn 1, call 2 — n1 still full this turn
+    { role: 'assistant', content: 'ok' }, // turn 2 — a separate request
+  ]);
+  const config = agent({
+    name: 'note-taker',
+    systemPrompt: 'take notes',
+    toolDefinitions: [def('notes')],
+    toolHandlers: {
+      notes: async (_args, ctx) => {
+        ctx.condenseWhen({ on: { kind: 'turnEnd' }, response: 'pointer' });
+        return bigBody;
+      },
+    },
+  });
+  const driver = makeDriver(config, provider, sessionKey);
+
+  await driver.sendMessage('first'); // turn 1
+  await driver.sendMessage('second'); // turn 2
+
+  const inTurn1 = provider.historyPerCall[1].find((m) => m.toolResult?.toolCallId === 'n1');
+  assert.is(inTurn1!.toolResult!.content, bigBody, 'full for the rest of the request it served');
+  const inTurn2 = provider.historyPerCall[2].find((m) => m.toolResult?.toolCallId === 'n1');
+  assert.match(inTurn2!.toolResult!.content, /re-call to restore/, 'collapsed once the turn ended');
+
+  const events = getMetaEvents(sessionKey).filter((e) => e.type === 'context.condensed');
+  assert.is(events.length, 1);
+  assert.is(events[0].detail?.trigger, 'turnEnd');
+});
+
+condense('agentEnd: collapses once the agent releases (flow complete)', async () => {
+  const sessionKey = 'condense-agent-end';
+  clearMetaEventRegistry();
+  const provider = scriptedProvider([
+    { role: 'assistant', content: '', toolCalls: [{ id: 's1', name: 'load', args: {} }] }, // call 1
+    { role: 'assistant', content: '', toolCalls: [{ id: 'f1', name: 'finish', args: {} }] }, // call 2 — releases
+    { role: 'assistant', content: 'wrapped up' }, // call 3 — flow done
+  ]);
+  const config = agent({
+    name: 'wizard',
+    systemPrompt: 'a flow',
+    toolDefinitions: [def('load'), def('finish')],
+    toolHandlers: {
+      load: async (_args, ctx) => {
+        ctx.condenseWhen({ on: { kind: 'agentEnd' }, response: 'pointer' });
+        return bigBody;
+      },
+      finish: async (_args, ctx) => {
+        ctx.releaseAgent();
+        return 'flow complete';
+      },
+    },
+  });
+  const driver = makeDriver(config, provider, sessionKey);
+  await driver.sendMessage('run the flow');
+
+  // call #2 (index 1) ran before `finish` released — schema still full.
+  const beforeRelease = provider.historyPerCall[1].find((m) => m.toolResult?.toolCallId === 's1');
+  assert.is(beforeRelease!.toolResult!.content, bigBody, 'full while the flow is active');
+  // call #3 (index 2) ran after release — schema collapsed.
+  const afterRelease = provider.historyPerCall[2].find((m) => m.toolResult?.toolCallId === 's1');
+  assert.match(afterRelease!.toolResult!.content, /re-call to restore/, 'collapsed once released');
+
+  const events = getMetaEvents(sessionKey).filter((e) => e.type === 'context.condensed');
+  assert.is(events.length, 1);
+  assert.is(events[0].detail?.trigger, 'agentEnd');
+});
+
+condense.run();