@genesislcap/ai-assistant 15.5.0 → 15.6.1

package/src/utils/condense-history.ts

@@ -75,6 +75,24 @@ export interface CondenseContext {
    * `phaseEnd` clock. True once `endPhase()` has been called since the call.
    */
   phaseEnded: (phaseEpoch: number) => boolean;
+  /**
+   * Collapse in batches of this many model-calls instead of continuously. A positive
+   * integer; decimals are floored and anything below `1` becomes `1`. Omit (or `1`) to
+   * collapse as soon as a trigger fires, which is the historical behaviour.
+   *
+   * Condensation rewrites a payload *in place*, so the model-bound history is not
+   * append-only and every prompt-cache entry written before the rewrite is invalidated
+   * from that position on. Collapsing the moment each trigger fires therefore breaks the
+   * cache on nearly every call of a re-read loop — the case condensation exists to
+   * 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;
 }
 
 /**
@@ -141,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
@@ -193,6 +229,20 @@ export function applyCondensation(
   // lookup. For each `superseded` key the LAST call in history order survives.
   // The name lookup lets a tool message (which carries only an id) name its tool
   // in stubs and events.
+  // Batch boundary: the collapse set is resolved as of this model-call and stays put
+  // until the next boundary, so the prefix is append-only in between. `batchCalls` of 1
+  // (the default) makes this `ctx.modelCall` — i.e. no batching.
+  const batchCalls = Math.max(1, Math.floor(ctx.batchCalls ?? 1));
+  const asOf =
+    batchCalls === 1 ? ctx.modelCall : Math.floor(ctx.modelCall / batchCalls) * batchCalls;
+  // A call made after the boundary is invisible to this pass in BOTH directions: it
+  // cannot supersede an older call (which would collapse the older payload early), and
+  // it cannot itself collapse (which would elide the very result just fetched). Unbatched,
+  // the boundary is the live clock and this gate is off entirely — a call registered on
+  // the current model-call is still eligible, as it always was.
+  const withinBatch = (entry: RegisteredCondensePolicy): boolean =>
+    batchCalls === 1 || entry.iteration <= asOf;
+
   const latestByKey = new Map<string, string>();
   const nameById = new Map<string, string>();
   for (const msg of history) {
@@ -200,7 +250,7 @@ export function applyCondensation(
     for (const tc of msg.toolCalls) {
       nameById.set(tc.id, tc.name);
       const entry = policies.get(tc.id);
-      if (!entry) continue;
+      if (!entry || !withinBatch(entry)) continue;
       for (const t of triggersOf(entry)) {
         if (t.kind === 'superseded') latestByKey.set(t.by, tc.id);
       }
@@ -217,7 +267,7 @@ export function applyCondensation(
       // past the last allowed view: turns:1 → seen once, then gone. Monotonic
       // clock, so this holds across turn boundaries too.
       case 'age':
-        return ctx.modelCall - entry.iteration > trig.turns;
+        return asOf - entry.iteration > trig.turns;
       case 'turnEnd':
         return ctx.turn > entry.turn;
       case 'agentEnd':
@@ -238,7 +288,10 @@ export function applyCondensation(
     toolCallId: string,
     entry: RegisteredCondensePolicy,
   ): CondenseTrigger | undefined =>
-    triggersOf(entry).find((t) => triggerFires(toolCallId, entry, t));
+    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.