@genesislcap/ai-assistant 15.6.0 → 15.6.2

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

@@ -76,6 +76,10 @@ export interface CondenseContext {
      * contain. Batching holds the collapse set still between boundaries so the prefix is
      * append-only in between, trading up to `batchCalls` calls' worth of extra context for
      * one cache break per batch instead of one per call.
+     *
+     * `agentEnd` and `phaseEnd` are exempt and still collapse as they fire: they mark a
+     * discontinuity that invalidates the cached prefix anyway, so deferring them would hold
+     * stale payloads longer for nothing.
      */
     batchCalls?: number;
 }

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;;;;;;;;;;;;OAYG;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;AA8CD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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,CAyJf"}
+{"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"}

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

@@ -60,6 +60,23 @@ function triggerLabel(trigger) {
 function estimateTokensSaved(origLen, stubLen) {
     return Math.max(0, Math.ceil((origLen - stubLen) / APPROX_CHARS_PER_TOKEN));
 }
+/**
+ * Whether a trigger marks a genuine discontinuity rather than firing continuously, and so is
+ * exempt from batching.
+ *
+ * `agentEnd` advances only when the active agent's name changes (or a sub-agent completes /
+ * the agent is released), which swaps the system prompt and tool definitions — those render
+ * before the messages, so the cached prefix is invalidated at that point regardless. `phaseEnd`
+ * is the app declaring the same kind of boundary explicitly, and falls back to `agentEnd`.
+ * Deferring either to the next batch would buy no cache and only hold stale payloads longer.
+ *
+ * The rest fire continuously (`superseded`, `age`) or at a point where the history is otherwise
+ * append-only (`turnEnd` — a new turn appends a user message, leaving the previous entry live),
+ * so batching them is exactly where the cache is won.
+ */
+function marksDiscontinuity(kind) {
+    return kind === 'agentEnd' || kind === 'phaseEnd';
+}
 /**
  * Collapse stale tool payloads (declared via `condenseWhen`) out of the
  * model-bound history. Pure over the `history` array — it emits new message
@@ -155,9 +172,7 @@ 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) => withinBatch(entry)
-        ? triggersOf(entry).find((t) => triggerFires(toolCallId, entry, t))
-        : undefined;
+    const firstFired = (toolCallId, entry) => triggersOf(entry).find((t) => (marksDiscontinuity(t.kind) || withinBatch(entry)) && triggerFires(toolCallId, entry, t));
     return history.map((msg) => {
         var _a, _b, _c, _d;
         // Tool-call ARGS live on the assistant message.

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

@@ -402,4 +402,34 @@ batch('batchCalls of 1, 0 or absent all keep the historical behaviour', () => {
         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();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@genesislcap/ai-assistant",
   "description": "Genesis AI Assistant micro-frontend",
-  "version": "15.6.0",
+  "version": "15.6.2",
   "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.6.0",
-    "@genesislcap/genx": "15.6.0",
-    "@genesislcap/rollup-builder": "15.6.0",
-    "@genesislcap/ts-builder": "15.6.0",
-    "@genesislcap/uvu-playwright-builder": "15.6.0",
-    "@genesislcap/vite-builder": "15.6.0",
-    "@genesislcap/webpack-builder": "15.6.0",
+    "@genesislcap/foundation-testing": "15.6.2",
+    "@genesislcap/genx": "15.6.2",
+    "@genesislcap/rollup-builder": "15.6.2",
+    "@genesislcap/ts-builder": "15.6.2",
+    "@genesislcap/uvu-playwright-builder": "15.6.2",
+    "@genesislcap/vite-builder": "15.6.2",
+    "@genesislcap/webpack-builder": "15.6.2",
     "@types/dompurify": "^3.0.5",
     "@types/marked": "^5.0.2",
     "esbuild": "0.25.12"
   },
   "dependencies": {
-    "@genesislcap/foundation-ai": "15.6.0",
-    "@genesislcap/foundation-logger": "15.6.0",
-    "@genesislcap/foundation-notifications": "15.6.0",
-    "@genesislcap/foundation-redux": "15.6.0",
-    "@genesislcap/foundation-ui": "15.6.0",
-    "@genesislcap/foundation-utils": "15.6.0",
-    "@genesislcap/rapid-design-system": "15.6.0",
-    "@genesislcap/web-core": "15.6.0",
+    "@genesislcap/foundation-ai": "15.6.2",
+    "@genesislcap/foundation-logger": "15.6.2",
+    "@genesislcap/foundation-notifications": "15.6.2",
+    "@genesislcap/foundation-redux": "15.6.2",
+    "@genesislcap/foundation-ui": "15.6.2",
+    "@genesislcap/foundation-utils": "15.6.2",
+    "@genesislcap/rapid-design-system": "15.6.2",
+    "@genesislcap/web-core": "15.6.2",
     "dompurify": "^3.3.1",
     "marked": "^17.0.3"
   },
@@ -105,5 +105,5 @@
     "access": "public"
   },
   "customElements": "dist/custom-elements.json",
-  "gitHead": "dbf070bac8a4bfc2a178e335b1faffb130e8f761"
+  "gitHead": "a5781780cb56906755ddbfc4be75e221719ae4b4"
 }

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

@@ -536,4 +536,67 @@ batch('batchCalls of 1, 0 or absent all keep the historical behaviour', () => {
   }
 });
 
+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();

package/src/utils/condense-history.ts

@@ -87,6 +87,10 @@ export interface CondenseContext {
    * contain. Batching holds the collapse set still between boundaries so the prefix is
    * append-only in between, trading up to `batchCalls` calls' worth of extra context for
    * one cache break per batch instead of one per call.
+   *
+   * `agentEnd` and `phaseEnd` are exempt and still collapse as they fire: they mark a
+   * discontinuity that invalidates the cached prefix anyway, so deferring them would hold
+   * stale payloads longer for nothing.
    */
   batchCalls?: number;
 }
@@ -155,6 +159,24 @@ function estimateTokensSaved(origLen: number, stubLen: number): number {
   return Math.max(0, Math.ceil((origLen - stubLen) / APPROX_CHARS_PER_TOKEN));
 }
 
+/**
+ * Whether a trigger marks a genuine discontinuity rather than firing continuously, and so is
+ * exempt from batching.
+ *
+ * `agentEnd` advances only when the active agent's name changes (or a sub-agent completes /
+ * the agent is released), which swaps the system prompt and tool definitions — those render
+ * before the messages, so the cached prefix is invalidated at that point regardless. `phaseEnd`
+ * is the app declaring the same kind of boundary explicitly, and falls back to `agentEnd`.
+ * Deferring either to the next batch would buy no cache and only hold stale payloads longer.
+ *
+ * The rest fire continuously (`superseded`, `age`) or at a point where the history is otherwise
+ * append-only (`turnEnd` — a new turn appends a user message, leaving the previous entry live),
+ * so batching them is exactly where the cache is won.
+ */
+function marksDiscontinuity(kind: CondenseTrigger['kind']): boolean {
+  return kind === 'agentEnd' || kind === 'phaseEnd';
+}
+
 /**
  * Collapse stale tool payloads (declared via `condenseWhen`) out of the
  * model-bound history. Pure over the `history` array — it emits new message
@@ -266,9 +288,10 @@ export function applyCondensation(
     toolCallId: string,
     entry: RegisteredCondensePolicy,
   ): CondenseTrigger | undefined =>
-    withinBatch(entry)
-      ? triggersOf(entry).find((t) => triggerFires(toolCallId, entry, t))
-      : undefined;
+    triggersOf(entry).find(
+      (t) =>
+        (marksDiscontinuity(t.kind) || withinBatch(entry)) && triggerFires(toolCallId, entry, t),
+    );
 
   return history.map((msg) => {
     // Tool-call ARGS live on the assistant message.