@genesislcap/ai-assistant 15.10.3 → 15.10.4

package/dist/custom-elements.json

@@ -5334,7 +5334,7 @@
               "description": "Invoked once per payload at its full→stub transition."
             }
           ],
-          "description": "Collapse stale tool payloads (declared via `condenseWhen`) out of the\nmodel-bound history. Pure over the `history` array — it emits new message\nobjects and never mutates the input messages (mirroring the agent-masking\ntransform). It DOES, however, flip the `reported*` flag on the matching\n`policies` entry the first time a payload collapses — the report-once gate that\nkeeps `onCondensed` firing once per (tool call, payload) even though the\ncollapse itself re-runs before every provider call.\n\nTriggers (a policy may list several via `on: Trigger[]` — the FIRST to fire\ncollapses the payload; all are monotonic, so the collapse never reverts):\n- `superseded` — among all registered calls sharing a `by` key, the LAST in\n  history order survives; every earlier one's targeted payload collapses. A\n  re-call with the same key becomes the new survivor and re-arms the rest.\n- `age` — the result is first visible one model-call after the call, so `turns`\n  is how many model-calls may see the full result before it collapses\n  (fires when `modelCall − callModelCall > turns`): `turns: 1` is seen once,\n  then collapses. The clock is monotonic across turns.\n- `turnEnd` — collapses once the turn (`sendMessage`) that made the call has\n  ended (fires when `turn > callTurn`): full for the rest of that request,\n  gone on every later one.\n- `agentEnd` — collapses once the agent activation that made the call has ended\n  (a swap to another agent, or `releaseAgent`/`completeSubAgent`): kept across\n  all of the agent's turns, dropped when its flow finishes.\n- `phaseEnd` — collapses once the app advances its phase epoch via `endPhase()`\n  after the call (a sub-`agentEnd` boundary the author declares), OR at\n  `agentEnd` as a backstop if no boundary is ever declared.\n\nThe tool-call/result envelope is never removed (providers reject orphaned\ncalls/results) — only the args object or the result content is replaced."
+          "description": "Collapse stale tool payloads (declared via `condenseWhen`) out of the\nmodel-bound history. Pure over the `history` array — it emits new message\nobjects and never mutates the input messages (mirroring the agent-masking\ntransform). It DOES, however, write two latches onto the matching `policies`\nentry the first time a payload collapses, both because the collapse itself\nre-runs before every provider call: the `reported*` flag (the report-once gate\nthat keeps `onCondensed` firing once per (tool call, payload)) and\n`firedTrigger` (which pins the reason so a reason-bearing stub is rendered\nonce and never rewritten).\n\nTriggers (a policy may list several via `on: Trigger[]` — the FIRST to fire\ncollapses the payload; all are monotonic, so the collapse never reverts):\n- `superseded` — among all registered calls sharing a `by` key, the LAST in\n  history order survives; every earlier one's targeted payload collapses. A\n  re-call with the same key becomes the new survivor and re-arms the rest.\n- `age` — the result is first visible one model-call after the call, so `turns`\n  is how many model-calls may see the full result before it collapses\n  (fires when `modelCall − callModelCall > turns`): `turns: 1` is seen once,\n  then collapses. The clock is monotonic across turns.\n- `turnEnd` — collapses once the turn (`sendMessage`) that made the call has\n  ended (fires when `turn > callTurn`): full for the rest of that request,\n  gone on every later one.\n- `agentEnd` — collapses once the agent activation that made the call has ended\n  (a swap to another agent, or `releaseAgent`/`completeSubAgent`): kept across\n  all of the agent's turns, dropped when its flow finishes.\n- `phaseEnd` — collapses once the app advances its phase epoch via `endPhase()`\n  after the call (a sub-`agentEnd` boundary the author declares), OR at\n  `agentEnd` as a backstop if no boundary is ever declared.\n\nThe tool-call/result envelope is never removed (providers reject orphaned\ncalls/results) — only the args object or the result content is replaced."
         }
       ],
       "exports": [

package/dist/dts/utils/condense-history.d.ts

@@ -1,4 +1,4 @@
-import type { ChatMessage, CondensePolicy } from '@genesislcap/foundation-ai';
+import type { ChatMessage, CondensePolicy, CondenseTrigger } from '@genesislcap/foundation-ai';
 /**
  * Tool-context condensation: collapse stale tool payloads out of the history
  * sent to the model, while leaving stored history untouched.
@@ -46,6 +46,28 @@ export interface RegisteredCondensePolicy {
     reportedArgs?: boolean;
     /** `context.condensed` already emitted for the response payload (fire-once). */
     reportedResponse?: boolean;
+    /**
+     * The first trigger to fire for this call, latched on the pass it fired.
+     *
+     * "Fired", not "collapsed": it is written during trigger resolution, before the
+     * per-payload size floor is applied, so an entry whose payloads are all below the floor
+     * can latch without anything ever rendering. That is deliberate and safe — both payloads
+     * of a call resolve off the same clocks in the same pass, so they can never disagree
+     * about which trigger fired, and a payload's size is fixed for the life of the call
+     * (condensation never touches stored history), so a below-floor payload can never later
+     * become a large one under a stale reason.
+     *
+     * Trigger resolution picks the first LISTED trigger that is *currently* true, so without
+     * this it re-evaluates on every provider call and can change after the collapse: with the
+     * usual `on: [{superseded}, {agentEnd}]`, a payload collapsed at `agentEnd` silently
+     * re-resolves to `superseded` as soon as a newer call on the same key lands. Any stub that
+     * embeds the reason (`pointer` does) is then rewritten — an in-place history mutation that
+     * invalidates the prompt cache from that position a second time, for a payload that had
+     * already collapsed. Latching keeps the rendered stub stable, which is sound because a
+     * collapse is monotonic and never reverts, so the first trigger to fire is the correct
+     * one to keep.
+     */
+    firedTrigger?: CondenseTrigger;
 }
 /**
  * The driver's live state at the moment of a provider call — the clocks every
@@ -106,10 +128,12 @@ export interface CondensedEventDetail {
  * Collapse stale tool payloads (declared via `condenseWhen`) out of the
  * model-bound history. Pure over the `history` array — it emits new message
  * objects and never mutates the input messages (mirroring the agent-masking
- * transform). It DOES, however, flip the `reported*` flag on the matching
- * `policies` entry the first time a payload collapses — the report-once gate that
- * keeps `onCondensed` firing once per (tool call, payload) even though the
- * collapse itself re-runs before every provider call.
+ * transform). It DOES, however, write two latches onto the matching `policies`
+ * entry the first time a payload collapses, both because the collapse itself
+ * re-runs before every provider call: the `reported*` flag (the report-once gate
+ * that keeps `onCondensed` firing once per (tool call, payload)) and
+ * `firedTrigger` (which pins the reason so a reason-bearing stub is rendered
+ * once and never rewritten).
  *
  * Triggers (a policy may list several via `on: Trigger[]` — the FIRST to fire
  * collapses the payload; all are monotonic, so the collapse never reverts):

package/dist/dts/utils/condense-history.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"condense-history.d.ts","sourceRoot":"","sources":["../../../src/utils/condense-history.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAmB,MAAM,4BAA4B,CAAC;AAE/F;;;;;;;;;;;;;GAaG;AAEH;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,OAAO,CAAC;AAEvC,uFAAuF;AACvF,eAAO,MAAM,kBAAkB,cAAc,CAAC;AAQ9C;;;;;GAKG;AACH,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,cAAc,CAAC;IACvB;;;;;OAKG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB,kFAAkF;IAClF,IAAI,EAAE,MAAM,CAAC;IACb,+EAA+E;IAC/E,UAAU,EAAE,MAAM,CAAC;IACnB,gFAAgF;IAChF,UAAU,EAAE,MAAM,CAAC;IACnB,4EAA4E;IAC5E,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,gFAAgF;IAChF,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,2DAA2D;IAC3D,SAAS,EAAE,MAAM,CAAC;IAClB,yEAAyE;IACzE,IAAI,EAAE,MAAM,CAAC;IACb,4FAA4F;IAC5F,eAAe,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC;IACjD;;;OAGG;IACH,UAAU,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC;IAC5C;;;;;;;;;;;;;;;;OAgBG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IACvB,0DAA0D;IAC1D,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC;IAC5B,oEAAoE;IACpE,OAAO,EAAE,MAAM,CAAC;IAChB,sCAAsC;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,mFAAmF;IACnF,WAAW,EAAE,MAAM,CAAC;CACrB;AAgED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,WAAW,EAAE,EACtB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,wBAAwB,CAAC,EAC/C,GAAG,EAAE,eAAe,EACpB,WAAW,EAAE,CAAC,MAAM,EAAE,oBAAoB,KAAK,IAAI,GAClD,WAAW,EAAE,CA0Jf"}
+{"version":3,"file":"condense-history.d.ts","sourceRoot":"","sources":["../../../src/utils/condense-history.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE/F;;;;;;;;;;;;;GAaG;AAEH;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,OAAO,CAAC;AAEvC,uFAAuF;AACvF,eAAO,MAAM,kBAAkB,cAAc,CAAC;AAQ9C;;;;;GAKG;AACH,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,cAAc,CAAC;IACvB;;;;;OAKG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB,kFAAkF;IAClF,IAAI,EAAE,MAAM,CAAC;IACb,+EAA+E;IAC/E,UAAU,EAAE,MAAM,CAAC;IACnB,gFAAgF;IAChF,UAAU,EAAE,MAAM,CAAC;IACnB,4EAA4E;IAC5E,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,gFAAgF;IAChF,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,YAAY,CAAC,EAAE,eAAe,CAAC;CAChC;AAED;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,2DAA2D;IAC3D,SAAS,EAAE,MAAM,CAAC;IAClB,yEAAyE;IACzE,IAAI,EAAE,MAAM,CAAC;IACb,4FAA4F;IAC5F,eAAe,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC;IACjD;;;OAGG;IACH,UAAU,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC;IAC5C;;;;;;;;;;;;;;;;OAgBG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IACvB,0DAA0D;IAC1D,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC;IAC5B,oEAAoE;IACpE,OAAO,EAAE,MAAM,CAAC;IAChB,sCAAsC;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,mFAAmF;IACnF,WAAW,EAAE,MAAM,CAAC;CACrB;AA2ED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,WAAW,EAAE,EACtB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,wBAAwB,CAAC,EAC/C,GAAG,EAAE,eAAe,EACpB,WAAW,EAAE,CAAC,MAAM,EAAE,oBAAoB,KAAK,IAAI,GAClD,WAAW,EAAE,CAwKf"}

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

@@ -40,11 +40,21 @@ function triggerReason(trigger) {
             return 'superseded';
     }
 }
-/** Framework-generated `pointer` stub — advertises that re-calling restores the content. */
-function condenseStub(target, tool, trigger, origLen) {
+/**
+ * Framework-generated stub, shared by `pointer` and `drop`. Names the tool, the superseded key
+ * (the only surviving identifier once args are elided — the model cannot otherwise tell WHICH
+ * file a collapsed `vfs_write` wrote) and the original size.
+ *
+ * `restorable` is the ONLY difference between the two modes: `pointer` promises that re-calling
+ * reproduces the content and is valid solely for idempotent tools; `drop` makes no such promise
+ * and must not carry the clause. Identifying information is not what separates them — a stub too
+ * bare to say what the call did is how GENC-1494 started.
+ */
+function condenseStub(target, tool, trigger, origLen, restorable) {
     const what = target === 'args' ? 'args' : 'result';
     const key = trigger.kind === 'superseded' ? ` ${trigger.by}` : '';
-    return `[${tool}${key} — ${what} elided, ~${origLen} chars (${triggerReason(trigger)}); re-call to restore]`;
+    const restore = restorable ? '; re-call to restore' : '';
+    return `[${tool}${key} — ${what} elided, ~${origLen} chars (${triggerReason(trigger)})${restore}]`;
 }
 /** Stable label for the `context.condensed` meta-event's `trigger` field. */
 function triggerLabel(trigger) {
@@ -81,10 +91,12 @@ function marksDiscontinuity(kind) {
  * Collapse stale tool payloads (declared via `condenseWhen`) out of the
  * model-bound history. Pure over the `history` array — it emits new message
  * objects and never mutates the input messages (mirroring the agent-masking
- * transform). It DOES, however, flip the `reported*` flag on the matching
- * `policies` entry the first time a payload collapses — the report-once gate that
- * keeps `onCondensed` firing once per (tool call, payload) even though the
- * collapse itself re-runs before every provider call.
+ * transform). It DOES, however, write two latches onto the matching `policies`
+ * entry the first time a payload collapses, both because the collapse itself
+ * re-runs before every provider call: the `reported*` flag (the report-once gate
+ * that keeps `onCondensed` firing once per (tool call, payload)) and
+ * `firedTrigger` (which pins the reason so a reason-bearing stub is rendered
+ * once and never rewritten).
  *
  * Triggers (a policy may list several via `on: Trigger[]` — the FIRST to fire
  * collapses the payload; all are monotonic, so the collapse never reverts):
@@ -172,7 +184,20 @@ export function applyCondensation(history, policies, ctx, onCondensed) {
     };
     // The first listed trigger that fires — drives the collapse, the stub reason,
     // and the event label. `undefined` means the payload stays full.
-    const firstFired = (toolCallId, entry) => triggersOf(entry).find((t) => (marksDiscontinuity(t.kind) || withinBatch(entry)) && triggerFires(toolCallId, entry, t));
+    //
+    // Latched on first fire (see `firedTrigger`): re-resolving on every pass lets the reason
+    // change under a payload that has already collapsed, which rewrites any reason-bearing stub
+    // and costs a second cache break. Both payloads of a call share the latch — they are
+    // evaluated in the same pass off the same clocks, so they never disagree about which
+    // trigger fired; only the size floor decides whether each one renders.
+    const firstFired = (toolCallId, entry) => {
+        if (entry.firedTrigger)
+            return entry.firedTrigger;
+        const fired = triggersOf(entry).find((t) => (marksDiscontinuity(t.kind) || withinBatch(entry)) && triggerFires(toolCallId, entry, t));
+        if (fired)
+            entry.firedTrigger = fired;
+        return fired;
+    };
     return history.map((msg) => {
         var _a, _b, _c, _d;
         // Tool-call ARGS live on the assistant message.
@@ -191,16 +216,23 @@ export function applyCondensation(history, policies, ctx, onCondensed) {
                     return tc;
                 changed = true;
                 const result = entry.policy.args;
-                // Args must stay a Record; `drop` is an empty object, otherwise stash the
-                // stub under a single key. Spread `tc` so providerMetadata (e.g. the
-                // Gemini reasoning signature that must round-trip) and UI fields survive.
-                const args = result === 'drop'
-                    ? {}
-                    : {
-                        [CONDENSED_ARGS_KEY]: result === 'pointer'
-                            ? condenseStub('args', tc.name, fired, origLen)
-                            : result.replaceWith,
-                    };
+                // Args must stay a Record, so every mode stashes its stub under a single key.
+                // Spread `tc` so providerMetadata (e.g. the Gemini reasoning signature that must
+                // round-trip) and UI fields survive.
+                //
+                // GENC-1494: `drop` used to collapse args to a bare `{}`. That is indistinguishable
+                // from a call the model made with NO arguments, and the model reads its own history
+                // as fact: a ui-builder run saw its elided `vfs_write` calls as `vfs_write {}` beside
+                // a live `{"status":"buffered","path":"…"}` result, concluded it was calling the tool
+                // without content, and burned two hours re-writing files that were already correct.
+                // A bare marker is not enough either — it still fails to say WHICH file the call
+                // wrote, since `path` went with the args. So `drop` renders the same identifying stub
+                // as `pointer`, minus only the restore promise it cannot honour.
+                const args = {
+                    [CONDENSED_ARGS_KEY]: result === 'drop' || result === 'pointer'
+                        ? condenseStub('args', tc.name, fired, origLen, result === 'pointer')
+                        : result.replaceWith,
+                };
                 if (!entry.reportedArgs) {
                     entry.reportedArgs = true;
                     const stubLen = JSON.stringify(args).length;
@@ -231,11 +263,9 @@ export function applyCondensation(history, policies, ctx, onCondensed) {
                 const tool = (_d = nameById.get(msg.toolResult.toolCallId)) !== null && _d !== void 0 ? _d : msg.toolResult.toolCallId;
                 const result = entry.policy.response; // `fired` is only set when response is declared
                 // Kept non-empty — Anthropic rejects empty tool_result content.
-                const content = result === 'drop'
-                    ? '[elided]'
-                    : result === 'pointer'
-                        ? condenseStub('response', tool, fired, origLen)
-                        : result.replaceWith;
+                const content = result === 'drop' || result === 'pointer'
+                    ? condenseStub('response', tool, fired, origLen, result === 'pointer')
+                    : result.replaceWith;
                 if (!entry.reportedResponse) {
                     entry.reportedResponse = true;
                     onCondensed({

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

@@ -1,5 +1,5 @@
 import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { applyCondensation, CONDENSE_MIN_CHARS, } from './condense-history';
+import { applyCondensation, CONDENSE_MIN_CHARS, CONDENSED_ARGS_KEY, } 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);
@@ -154,11 +154,20 @@ suite('drop / pointer / replaceWith produce distinct collapsed forms', () => {
     ]);
     const { on } = sink();
     const out = applyCondensation(history, policies, ctx(), on);
-    assert.is(out[1].toolResult.content, '[elided]', 'drop is a minimal non-empty placeholder');
+    // `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');
 });
-suite('args drop yields an empty object; pointer stashes a stub under one key', () => {
+// 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 = [
         asstCall('w1', 'vfs_write', { path: 'A', content: big() }),
         toolMsg('w1', 'ok'),
@@ -171,9 +180,45 @@ suite('args drop yields an empty object; pointer stashes a stub under one key',
     ]);
     const { on } = sink();
     const out = applyCondensation(history, policies, ctx(), on);
-    assert.equal(out[0].toolCalls[0].args, {}, 'dropped args is an empty object');
+    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 = [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([['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 = [
+        ...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
 // ---------------------------------------------------------------------------

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@genesislcap/ai-assistant",
   "description": "Genesis AI Assistant micro-frontend",
-  "version": "15.10.3",
+  "version": "15.10.4",
   "license": "SEE LICENSE IN license.txt",
   "main": "dist/esm/index.js",
   "types": "dist/ai-assistant.d.ts",
@@ -73,26 +73,26 @@
     }
   },
   "devDependencies": {
-    "@genesislcap/foundation-testing": "15.10.3",
-    "@genesislcap/genx": "15.10.3",
-    "@genesislcap/rollup-builder": "15.10.3",
-    "@genesislcap/ts-builder": "15.10.3",
-    "@genesislcap/uvu-playwright-builder": "15.10.3",
-    "@genesislcap/vite-builder": "15.10.3",
-    "@genesislcap/webpack-builder": "15.10.3",
+    "@genesislcap/foundation-testing": "15.10.4",
+    "@genesislcap/genx": "15.10.4",
+    "@genesislcap/rollup-builder": "15.10.4",
+    "@genesislcap/ts-builder": "15.10.4",
+    "@genesislcap/uvu-playwright-builder": "15.10.4",
+    "@genesislcap/vite-builder": "15.10.4",
+    "@genesislcap/webpack-builder": "15.10.4",
     "@types/dompurify": "^3.0.5",
     "@types/marked": "^5.0.2",
     "esbuild": "0.25.12"
   },
   "dependencies": {
-    "@genesislcap/foundation-ai": "15.10.3",
-    "@genesislcap/foundation-logger": "15.10.3",
-    "@genesislcap/foundation-notifications": "15.10.3",
-    "@genesislcap/foundation-redux": "15.10.3",
-    "@genesislcap/foundation-ui": "15.10.3",
-    "@genesislcap/foundation-utils": "15.10.3",
-    "@genesislcap/rapid-design-system": "15.10.3",
-    "@genesislcap/web-core": "15.10.3",
+    "@genesislcap/foundation-ai": "15.10.4",
+    "@genesislcap/foundation-logger": "15.10.4",
+    "@genesislcap/foundation-notifications": "15.10.4",
+    "@genesislcap/foundation-redux": "15.10.4",
+    "@genesislcap/foundation-ui": "15.10.4",
+    "@genesislcap/foundation-utils": "15.10.4",
+    "@genesislcap/rapid-design-system": "15.10.4",
+    "@genesislcap/web-core": "15.10.4",
     "dompurify": "^3.3.1",
     "marked": "^17.0.3"
   },
@@ -105,5 +105,5 @@
     "access": "public"
   },
   "customElements": "dist/custom-elements.json",
-  "gitHead": "6e5c9bb135b3da6792c4c3a8e632b09b0bc3fbca"
+  "gitHead": "2747f342a1681832c041ac612b854039ef908ab7"
 }

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

@@ -3,6 +3,7 @@ import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
 import {
   applyCondensation,
   CONDENSE_MIN_CHARS,
+  CONDENSED_ARGS_KEY,
   type CondenseContext,
   type CondensedEventDetail,
   type RegisteredCondensePolicy,
@@ -193,7 +194,15 @@ suite('drop / pointer / replaceWith produce distinct collapsed forms', () => {
   const { on } = sink();
   const out = applyCondensation(history, policies, ctx(), on);
 
-  assert.is(out[1].toolResult!.content, '[elided]', 'drop is a minimal non-empty placeholder');
+  // `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/,
@@ -202,7 +211,12 @@ suite('drop / pointer / replaceWith produce distinct collapsed forms', () => {
   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', () => {
+// 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'),
@@ -215,10 +229,58 @@ suite('args drop yields an empty object; pointer stashes a stub under one key',
   ]);
   const { on } = sink();
   const out = applyCondensation(history, policies, ctx(), on);
-  assert.equal(out[0].toolCalls![0].args, {}, 'dropped args is an empty object');
+  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
 // ---------------------------------------------------------------------------

package/src/utils/condense-history.ts

@@ -56,6 +56,28 @@ export interface RegisteredCondensePolicy {
   reportedArgs?: boolean;
   /** `context.condensed` already emitted for the response payload (fire-once). */
   reportedResponse?: boolean;
+  /**
+   * The first trigger to fire for this call, latched on the pass it fired.
+   *
+   * "Fired", not "collapsed": it is written during trigger resolution, before the
+   * per-payload size floor is applied, so an entry whose payloads are all below the floor
+   * can latch without anything ever rendering. That is deliberate and safe — both payloads
+   * of a call resolve off the same clocks in the same pass, so they can never disagree
+   * about which trigger fired, and a payload's size is fixed for the life of the call
+   * (condensation never touches stored history), so a below-floor payload can never later
+   * become a large one under a stale reason.
+   *
+   * Trigger resolution picks the first LISTED trigger that is *currently* true, so without
+   * this it re-evaluates on every provider call and can change after the collapse: with the
+   * usual `on: [{superseded}, {agentEnd}]`, a payload collapsed at `agentEnd` silently
+   * re-resolves to `superseded` as soon as a newer call on the same key lands. Any stub that
+   * embeds the reason (`pointer` does) is then rewritten — an in-place history mutation that
+   * invalidates the prompt cache from that position a second time, for a payload that had
+   * already collapsed. Latching keeps the rendered stub stable, which is sound because a
+   * collapse is monotonic and never reverts, so the first trigger to fire is the correct
+   * one to keep.
+   */
+  firedTrigger?: CondenseTrigger;
 }
 
 /**
@@ -131,16 +153,27 @@ function triggerReason(trigger: CondenseTrigger): string {
   }
 }
 
-/** Framework-generated `pointer` stub — advertises that re-calling restores the content. */
+/**
+ * Framework-generated stub, shared by `pointer` and `drop`. Names the tool, the superseded key
+ * (the only surviving identifier once args are elided — the model cannot otherwise tell WHICH
+ * file a collapsed `vfs_write` wrote) and the original size.
+ *
+ * `restorable` is the ONLY difference between the two modes: `pointer` promises that re-calling
+ * reproduces the content and is valid solely for idempotent tools; `drop` makes no such promise
+ * and must not carry the clause. Identifying information is not what separates them — a stub too
+ * bare to say what the call did is how GENC-1494 started.
+ */
 function condenseStub(
   target: 'args' | 'response',
   tool: string,
   trigger: CondenseTrigger,
   origLen: number,
+  restorable: boolean,
 ): string {
   const what = target === 'args' ? 'args' : 'result';
   const key = trigger.kind === 'superseded' ? ` ${trigger.by}` : '';
-  return `[${tool}${key} — ${what} elided, ~${origLen} chars (${triggerReason(trigger)}); re-call to restore]`;
+  const restore = restorable ? '; re-call to restore' : '';
+  return `[${tool}${key} — ${what} elided, ~${origLen} chars (${triggerReason(trigger)})${restore}]`;
 }
 
 /** Stable label for the `context.condensed` meta-event's `trigger` field. */
@@ -181,10 +214,12 @@ function marksDiscontinuity(kind: CondenseTrigger['kind']): boolean {
  * Collapse stale tool payloads (declared via `condenseWhen`) out of the
  * model-bound history. Pure over the `history` array — it emits new message
  * objects and never mutates the input messages (mirroring the agent-masking
- * transform). It DOES, however, flip the `reported*` flag on the matching
- * `policies` entry the first time a payload collapses — the report-once gate that
- * keeps `onCondensed` firing once per (tool call, payload) even though the
- * collapse itself re-runs before every provider call.
+ * transform). It DOES, however, write two latches onto the matching `policies`
+ * entry the first time a payload collapses, both because the collapse itself
+ * re-runs before every provider call: the `reported*` flag (the report-once gate
+ * that keeps `onCondensed` firing once per (tool call, payload)) and
+ * `firedTrigger` (which pins the reason so a reason-bearing stub is rendered
+ * once and never rewritten).
  *
  * Triggers (a policy may list several via `on: Trigger[]` — the FIRST to fire
  * collapses the payload; all are monotonic, so the collapse never reverts):
@@ -284,14 +319,24 @@ export function applyCondensation(
 
   // The first listed trigger that fires — drives the collapse, the stub reason,
   // and the event label. `undefined` means the payload stays full.
+  //
+  // Latched on first fire (see `firedTrigger`): re-resolving on every pass lets the reason
+  // change under a payload that has already collapsed, which rewrites any reason-bearing stub
+  // and costs a second cache break. Both payloads of a call share the latch — they are
+  // evaluated in the same pass off the same clocks, so they never disagree about which
+  // trigger fired; only the size floor decides whether each one renders.
   const firstFired = (
     toolCallId: string,
     entry: RegisteredCondensePolicy,
-  ): CondenseTrigger | undefined =>
-    triggersOf(entry).find(
+  ): CondenseTrigger | undefined => {
+    if (entry.firedTrigger) return entry.firedTrigger;
+    const fired = triggersOf(entry).find(
       (t) =>
         (marksDiscontinuity(t.kind) || withinBatch(entry)) && triggerFires(toolCallId, entry, t),
     );
+    if (fired) entry.firedTrigger = fired;
+    return fired;
+  };
 
   return history.map((msg) => {
     // Tool-call ARGS live on the assistant message.
@@ -306,18 +351,24 @@ export function applyCondensation(
         if (origLen < CONDENSE_MIN_CHARS) return tc;
         changed = true;
         const result = entry.policy.args;
-        // Args must stay a Record; `drop` is an empty object, otherwise stash the
-        // stub under a single key. Spread `tc` so providerMetadata (e.g. the
-        // Gemini reasoning signature that must round-trip) and UI fields survive.
-        const args: Record<string, unknown> =
-          result === 'drop'
-            ? {}
-            : {
-                [CONDENSED_ARGS_KEY]:
-                  result === 'pointer'
-                    ? condenseStub('args', tc.name, fired, origLen)
-                    : result.replaceWith,
-              };
+        // Args must stay a Record, so every mode stashes its stub under a single key.
+        // Spread `tc` so providerMetadata (e.g. the Gemini reasoning signature that must
+        // round-trip) and UI fields survive.
+        //
+        // GENC-1494: `drop` used to collapse args to a bare `{}`. That is indistinguishable
+        // from a call the model made with NO arguments, and the model reads its own history
+        // as fact: a ui-builder run saw its elided `vfs_write` calls as `vfs_write {}` beside
+        // a live `{"status":"buffered","path":"…"}` result, concluded it was calling the tool
+        // without content, and burned two hours re-writing files that were already correct.
+        // A bare marker is not enough either — it still fails to say WHICH file the call
+        // wrote, since `path` went with the args. So `drop` renders the same identifying stub
+        // as `pointer`, minus only the restore promise it cannot honour.
+        const args: Record<string, unknown> = {
+          [CONDENSED_ARGS_KEY]:
+            result === 'drop' || result === 'pointer'
+              ? condenseStub('args', tc.name, fired, origLen, result === 'pointer')
+              : result.replaceWith,
+        };
         if (!entry.reportedArgs) {
           entry.reportedArgs = true;
           const stubLen = JSON.stringify(args).length;
@@ -350,11 +401,9 @@ export function applyCondensation(
         const result = entry.policy.response!; // `fired` is only set when response is declared
         // Kept non-empty — Anthropic rejects empty tool_result content.
         const content =
-          result === 'drop'
-            ? '[elided]'
-            : result === 'pointer'
-              ? condenseStub('response', tool, fired, origLen)
-              : result.replaceWith;
+          result === 'drop' || result === 'pointer'
+            ? condenseStub('response', tool, fired, origLen, result === 'pointer')
+            : result.replaceWith;
         if (!entry.reportedResponse) {
           entry.reportedResponse = true;
           onCondensed({