@genesislcap/ai-assistant 15.19.6 → 15.20.0-alpha.3

package/dist/chat-driver.cjs

@@ -1553,6 +1553,61 @@ function abortableDelay(ms, signal) {
   });
 }
 
+// ../../foundation-ai/dist/esm/transports/context-overflow-error.js
+var CONTEXT_OVERFLOW_PHRASES = Object.freeze([
+  /prompt is too long/i,
+  /input token count .* exceeds/i,
+  /maximum context length/i,
+  /context[_ ]length[_ ]exceeded/i,
+  /too many (input )?tokens/i
+]);
+var TOKEN_FIGURES = /(\d[\d,]{2,})\D{0,40}?(?:>|exceeds)\D{0,80}?(\d[\d,]{2,})/i;
+var OVERFLOW_STATUS = 400;
+var DEFAULT_CONTEXT_OVERFLOW_MESSAGE = "This conversation has grown larger than the model can accept in one request. Compact it to free up room, then try again.";
+var ContextOverflowError = class extends Error {
+  constructor(vendorLabel, promptTokens, limitTokens, detail) {
+    super(`${vendorLabel} rejected the request \u2014 the prompt exceeds the model context window` + (promptTokens != null && limitTokens != null ? ` (${promptTokens} > ${limitTokens})` : "") + (detail ? `: ${detail}` : "") + ". Retrying will not clear this \u2014 the conversation must be compacted.");
+    this.vendorLabel = vendorLabel;
+    this.promptTokens = promptTokens;
+    this.limitTokens = limitTokens;
+    this.detail = detail;
+    this.name = "ContextOverflowError";
+  }
+};
+var MAX_ENVELOPE_DEPTH = 4;
+function messagesIn(payload) {
+  if (!payload || typeof payload !== "object")
+    return [];
+  const found = [];
+  const visit = (node, depth) => {
+    if (depth > MAX_ENVELOPE_DEPTH || !node || typeof node !== "object")
+      return;
+    for (const value of Object.values(node)) {
+      if (typeof value === "string")
+        found.push(value);
+      else if (typeof value === "object")
+        visit(value, depth + 1);
+    }
+  };
+  visit(payload, 0);
+  return found;
+}
+function contextOverflowOf(_vendor, status, payload) {
+  if (status !== OVERFLOW_STATUS)
+    return void 0;
+  for (const message of messagesIn(payload)) {
+    if (!CONTEXT_OVERFLOW_PHRASES.some((phrase) => phrase.test(message)))
+      continue;
+    const figures = TOKEN_FIGURES.exec(message);
+    return {
+      promptTokens: figures ? Number(figures[1].replace(/,/g, "")) : void 0,
+      limitTokens: figures ? Number(figures[2].replace(/,/g, "")) : void 0,
+      message
+    };
+  }
+  return void 0;
+}
+
 // ../../foundation-ai/dist/esm/transports/ndjson-frames.js
 var MALFORMED_FRAME_PREVIEW_CHARS = 120;
 function readFramedBody(stream, onChunk, vendorLabel, stallTimeout) {
@@ -1681,7 +1736,7 @@ function serverBackoffSpentMs(resolvedMs, ladderMs) {
 var MAX_RETRIES = 5;
 function postWithRetry(options) {
   return __awaiter(this, void 0, void 0, function* () {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
     const { url, headers, body, credentials, vendorLabel, retryableStatuses, timeout, stallTimeout, backoffBaseMs, signal } = options;
     const vendor = vendorOfTransportLabel(vendorLabel);
     let serverBackoffSpent = 0;
@@ -1734,6 +1789,10 @@ function postWithRetry(options) {
           if (refusal) {
             throw providerRefusedFrom(vendorLabel, refusal, response.status, parsed, errText || void 0);
           }
+          const overflow = contextOverflowOf(vendor, response.status, parsed);
+          if (overflow) {
+            throw new ContextOverflowError(vendorLabel, overflow.promptTokens, overflow.limitTokens, (_d = overflow.message) !== null && _d !== void 0 ? _d : errText || void 0);
+          }
           if (isBudgetRejection(response.status, codeOf(parsed))) {
             throw budgetExhaustedFrom(vendorLabel, parsed, errText || void 0);
           }
@@ -1746,18 +1805,22 @@ function postWithRetry(options) {
           }
           throw new Error(`${vendorLabel} request error ${response.status}: ${errText}`);
         }
-        if (((_e = (_d = response.headers) === null || _d === void 0 ? void 0 : _d.get("content-type")) === null || _e === void 0 ? void 0 : _e.toLowerCase().includes("application/x-ndjson")) && response.body) {
+        if (((_f = (_e = response.headers) === null || _e === void 0 ? void 0 : _e.get("content-type")) === null || _f === void 0 ? void 0 : _f.toLowerCase().includes("application/x-ndjson")) && response.body) {
           rearmStallTimer();
           const frame = yield readFramedBody(response.body, rearmStallTimer, vendorLabel, stallTimeout);
           if (frame.t === "ok")
             return frame.body;
           if (frame.code === "UPSTREAM_STALLED") {
-            throw new DOMException(`${vendorLabel} request stalled: ${(_f = frame.error) !== null && _f !== void 0 ? _f : "no upstream data"}`, "TimeoutError");
+            throw new DOMException(`${vendorLabel} request stalled: ${(_g = frame.error) !== null && _g !== void 0 ? _g : "no upstream data"}`, "TimeoutError");
           }
           const framedRefusal = providerRefusalOf(vendor, frame.code, frame);
           if (framedRefusal) {
             throw providerRefusedFrom(vendorLabel, framedRefusal, frame.status, frame, frame.error);
           }
+          const framedOverflow = contextOverflowOf(vendor, frame.status, frame);
+          if (framedOverflow) {
+            throw new ContextOverflowError(vendorLabel, framedOverflow.promptTokens, framedOverflow.limitTokens, (_h = framedOverflow.message) !== null && _h !== void 0 ? _h : frame.error);
+          }
           if (isBudgetRejection(frame.status, frame.code)) {
             throw budgetExhaustedFrom(vendorLabel, frame);
           }
@@ -1767,7 +1830,7 @@ function postWithRetry(options) {
             yield backoff(attempt, retryInfoMs(frame));
             continue;
           }
-          throw new Error(`${vendorLabel} request error ${frame.status}: ${(_g = frame.error) !== null && _g !== void 0 ? _g : JSON.stringify(frame.details)}`);
+          throw new Error(`${vendorLabel} request error ${frame.status}: ${(_j = frame.error) !== null && _j !== void 0 ? _j : JSON.stringify(frame.details)}`);
         }
         return yield response.json();
       } catch (e) {
@@ -3732,10 +3795,126 @@ function createInteractionContext(interactionId) {
   };
 }
 
+// src/utils/context-tokens.ts
+var APPROX_CHARS_PER_TOKEN = 4;
+var IMAGE_TOKEN_ESTIMATE = 1600;
+var PER_MESSAGE_FRAMING_TOKENS = 4;
+var COMPACTION_SUMMARY_TOKEN_ESTIMATE = 1200;
+function reachesProvider(m) {
+  if (m.role === "system-event" || m.role === "synthetic-user") return false;
+  if (m.category === "reasoning" || m.category === "narration") return false;
+  return !m.thinking;
+}
+function imageCount(m) {
+  const onMessage = m.attachments?.filter((a) => a.kind === "image").length ?? 0;
+  const onResult = m.toolResult?.attachments?.filter((a) => a.kind === "image").length ?? 0;
+  return onMessage + onResult;
+}
+var TEXT_ATTACHMENT_FRAMING_CHARS = 9;
+function wireChars(m) {
+  let chars = m.content?.length ?? 0;
+  for (const attachment of m.attachments ?? []) {
+    if (attachment.kind === "image") continue;
+    chars += TEXT_ATTACHMENT_FRAMING_CHARS + attachment.name.length + (attachment.content?.length ?? 0);
+  }
+  for (const tc of m.toolCalls ?? []) {
+    chars += tc.name.length;
+    try {
+      chars += JSON.stringify(tc.args ?? {}).length;
+    } catch {
+    }
+  }
+  chars += m.toolResult?.content?.length ?? 0;
+  return chars;
+}
+function baselineTokens(m) {
+  if (!reachesProvider(m)) return 0;
+  return Math.ceil(wireChars(m) / APPROX_CHARS_PER_TOKEN) + imageCount(m) * IMAGE_TOKEN_ESTIMATE + PER_MESSAGE_FRAMING_TOKENS;
+}
+function compactedAtOf(history) {
+  return history.find((m) => m.role === "compacted-summary")?.compaction?.createdAt;
+}
+function usableAnchor(m, compactedAt) {
+  if (m.inputTokens == null) return false;
+  if (!compactedAt) return true;
+  return !!m.timestamp && m.timestamp >= compactedAt;
+}
+function firstAnchor(history, compactedAt) {
+  return history.findIndex((m) => usableAnchor(m, compactedAt));
+}
+function estimateMessageTokens(history) {
+  const estimates = history.map(baselineTokens);
+  const compactedAt = compactedAtOf(history);
+  const anchors = [];
+  history.forEach((m, i) => {
+    if (usableAnchor(m, compactedAt)) anchors.push(i);
+  });
+  for (let a = 0; a < anchors.length - 1; a += 1) {
+    const from = anchors[a];
+    const to = anchors[a + 1];
+    const measured = history[to].inputTokens - history[from].inputTokens;
+    if (measured <= 0) continue;
+    let baseline = 0;
+    for (let i = from; i < to; i += 1) baseline += estimates[i];
+    if (baseline <= 0) {
+      estimates[from] = measured;
+      continue;
+    }
+    const scale = measured / baseline;
+    let assigned = 0;
+    for (let i = from; i < to - 1; i += 1) {
+      estimates[i] = Math.round(estimates[i] * scale);
+      assigned += estimates[i];
+    }
+    estimates[to - 1] = measured - assigned;
+  }
+  return estimates;
+}
+function estimateSystemOverhead(history) {
+  const first = firstAnchor(history, compactedAtOf(history));
+  if (first < 0) return 0;
+  const estimates = estimateMessageTokens(history);
+  let messages = 0;
+  for (let i = 0; i < first; i += 1) messages += estimates[i];
+  return Math.max(0, history[first].inputTokens - messages);
+}
+function estimateContextTokens(history) {
+  const estimates = estimateMessageTokens(history);
+  let total = estimateSystemOverhead(history);
+  for (const t of estimates) total += t;
+  return total;
+}
+function estimateRequestTokens(storedHistory, requestHistory) {
+  const overhead = estimateSystemOverhead(storedHistory);
+  const calibratedMessages = Math.max(0, estimateContextTokens(storedHistory) - overhead);
+  let storedBaseline = 0;
+  for (const m of storedHistory) storedBaseline += baselineTokens(m);
+  let requestBaseline = 0;
+  for (const m of requestHistory) requestBaseline += baselineTokens(m);
+  if (storedBaseline <= 0) return overhead + requestBaseline;
+  return Math.round(overhead + calibratedMessages * (requestBaseline / storedBaseline));
+}
+function projectCompaction(history, cut, summaryTokens = COMPACTION_SUMMARY_TOKEN_ESTIMATE) {
+  const estimates = estimateMessageTokens(history);
+  const overhead = estimateSystemOverhead(history);
+  let tail = 0;
+  for (let i = cut; i < estimates.length; i += 1) tail += estimates[i];
+  let all = 0;
+  for (const t of estimates) all += t;
+  const tokensBefore = overhead + all;
+  const tokensAfter = overhead + summaryTokens + tail;
+  return {
+    cut,
+    compactedCount: cut,
+    tokensBefore,
+    tokensAfter,
+    reclaimed: Math.max(0, tokensBefore - tokensAfter)
+  };
+}
+
 // src/utils/condense-history.ts
 var CONDENSE_MIN_CHARS = 1e3;
 var CONDENSED_ARGS_KEY = "condensed";
-var APPROX_CHARS_PER_TOKEN = 4;
 function triggerReason(trigger) {
   switch (trigger.kind) {
     case "age":
@@ -3750,13 +3929,21 @@ function triggerReason(trigger) {
       return "superseded";
   }
 }
-function condenseStub(target, tool, trigger, origLen, restorable, imageCount = 0) {
+function condenseStub(target, tool, trigger, origLen, restorable, imageCount2 = 0) {
   const what = target === "args" ? "args" : "result";
   const key = trigger.kind === "superseded" ? ` ${trigger.by}` : "";
   const restore = restorable ? "; re-call to restore" : "";
-  const images = imageCount > 0 ? ` + ${imageCount} image${imageCount === 1 ? "" : "s"}` : "";
+  const images = imageCount2 > 0 ? ` + ${imageCount2} image${imageCount2 === 1 ? "" : "s"}` : "";
   return `[${tool}${key} \u2014 ${what} elided, ~${origLen} chars${images} (${triggerReason(trigger)})${restore}]`;
 }
+function renderCondensedArgs(policy, tool, fired, origLen) {
+  return {
+    [CONDENSED_ARGS_KEY]: policy === "drop" || policy === "pointer" ? condenseStub("args", tool, fired, origLen, policy === "pointer") : policy.replaceWith
+  };
+}
+function renderCondensedResult(policy, tool, fired, textLen, imageCount2) {
+  return policy === "drop" || policy === "pointer" ? condenseStub("response", tool, fired, textLen, policy === "pointer", imageCount2) : policy.replaceWith;
+}
 function triggerLabel(trigger) {
   switch (trigger.kind) {
     case "age":
@@ -3831,10 +4018,7 @@ function applyCondensation(history, policies, ctx, onCondensed) {
         const origLen = JSON.stringify(tc.args ?? {}).length;
         if (origLen < CONDENSE_MIN_CHARS) return tc;
         changed = true;
-        const result = entry.policy.args;
-        const args = {
-          [CONDENSED_ARGS_KEY]: result === "drop" || result === "pointer" ? condenseStub("args", tc.name, fired, origLen, result === "pointer") : result.replaceWith
-        };
+        const args = renderCondensedArgs(entry.policy.args, tc.name, fired, origLen);
         if (!entry.reportedArgs) {
           entry.reportedArgs = true;
           const stubLen = JSON.stringify(args).length;
@@ -3860,8 +4044,13 @@ function applyCondensation(history, policies, ctx, onCondensed) {
       const fired = entry?.policy.response ? firstFired(msg.toolResult.toolCallId, entry) : void 0;
       if (entry && fired && origLen >= CONDENSE_MIN_CHARS) {
         const tool = nameById.get(msg.toolResult.toolCallId) ?? msg.toolResult.toolCallId;
-        const result = entry.policy.response;
-        const content = result === "drop" || result === "pointer" ? condenseStub("response", tool, fired, textLen, result === "pointer", images.length) : result.replaceWith;
+        const content = renderCondensedResult(
+          entry.policy.response,
+          tool,
+          fired,
+          textLen,
+          images.length
+        );
         if (!entry.reportedResponse) {
           entry.reportedResponse = true;
           onCondensed({
@@ -3881,6 +4070,53 @@ function applyCondensation(history, policies, ctx, onCondensed) {
     return msg;
   });
 }
+function condenseForPersistence(history, policies) {
+  if (policies.size === 0) return history;
+  const nameById = /* @__PURE__ */ new Map();
+  for (const msg of history) {
+    for (const tc of msg.toolCalls ?? []) nameById.set(tc.id, tc.name);
+  }
+  let changed = false;
+  const projected = history.map((msg) => {
+    if (msg.toolCalls?.length) {
+      let callsChanged = false;
+      const toolCalls = msg.toolCalls.map((tc) => {
+        const entry = policies.get(tc.id);
+        if (!entry?.reportedArgs || !entry.firedTrigger || !entry.policy.args) return tc;
+        callsChanged = true;
+        const origLen = JSON.stringify(tc.args ?? {}).length;
+        return {
+          ...tc,
+          args: renderCondensedArgs(entry.policy.args, tc.name, entry.firedTrigger, origLen)
+        };
+      });
+      if (callsChanged) {
+        changed = true;
+        return { ...msg, toolCalls };
+      }
+      return msg;
+    }
+    if (msg.toolResult) {
+      const entry = policies.get(msg.toolResult.toolCallId);
+      if (entry?.reportedResponse && entry.firedTrigger && entry.policy.response) {
+        changed = true;
+        const tool = nameById.get(msg.toolResult.toolCallId) ?? msg.toolResult.toolCallId;
+        const images = msg.toolResult.attachments ?? [];
+        const content = renderCondensedResult(
+          entry.policy.response,
+          tool,
+          entry.firedTrigger,
+          msg.toolResult.content?.length ?? 0,
+          images.length
+        );
+        const { attachments: _elided, ...restOfResult } = msg.toolResult;
+        return { ...msg, toolResult: { ...restOfResult, content } };
+      }
+    }
+    return msg;
+  });
+  return changed ? projected : history;
+}
 
 // src/utils/history-transform.ts
 function maskToolPayload(msg) {
@@ -3906,20 +4142,43 @@ function applyHistoryCap(history, cap) {
   const cutoff = history.length - cap;
   return history.map((msg, i) => i < cutoff ? maskToolPayload(msg) : msg);
 }
-var COMPACT_KEEP_RECENT_MESSAGES = 4;
-var COMPACT_MIN_MESSAGES_TO_COMPACT = 4;
-function findCompactionCut(history) {
-  if (history.length < COMPACT_KEEP_RECENT_MESSAGES + COMPACT_MIN_MESSAGES_TO_COMPACT) {
-    return null;
+var DEFAULT_TAIL_TOKEN_BUDGET = 3e4;
+var DEFAULT_MIN_RECLAIM_TOKENS = 5e3;
+function isSafeCompactionCut(history, i) {
+  if (i <= 0 || i >= history.length) return false;
+  for (let j = i; j < history.length; j += 1) {
+    if (!reachesProvider(history[j])) continue;
+    return history[j].role !== "tool";
   }
-  const target = history.length - COMPACT_KEEP_RECENT_MESSAGES;
-  for (let i = target; i > 0; i -= 1) {
-    if (history[i].role === "user") {
-      return i >= COMPACT_MIN_MESSAGES_TO_COMPACT ? i : null;
-    }
+  return true;
+}
+function findCompactionCut(history, tailTokenBudget = DEFAULT_TAIL_TOKEN_BUDGET) {
+  const estimates = estimateMessageTokens(history);
+  let messagesTotal = 0;
+  for (const t of estimates) messagesTotal += t;
+  if (messagesTotal <= tailTokenBudget) return null;
+  let tail = 0;
+  let raw = history.length;
+  for (let i = history.length - 1; i > 0; i -= 1) {
+    if (tail + estimates[i] > tailTokenBudget) break;
+    tail += estimates[i];
+    raw = i;
+  }
+  for (let i = raw; i < history.length; i += 1) {
+    if (isSafeCompactionCut(history, i)) return i;
   }
   return null;
 }
+function planCompaction(history, options = {}) {
+  const {
+    tailTokenBudget = DEFAULT_TAIL_TOKEN_BUDGET,
+    minReclaimTokens = DEFAULT_MIN_RECLAIM_TOKENS
+  } = options;
+  const cut = findCompactionCut(history, tailTokenBudget);
+  if (cut == null) return null;
+  const projection = projectCompaction(history, cut);
+  return projection.reclaimed >= minReclaimTokens ? projection : null;
+}
 function renderMessageForSummary(m) {
   switch (m.role) {
     case "compacted-summary":
@@ -4649,6 +4908,7 @@ var ChatDriver = class _ChatDriver extends EventTarget {
     const status = await this.resolveStatusForProvider(resolvedName, provider);
     this.lastResolvedModel = status.model;
     this.lastResolvedProvider = status.provider;
+    this.lastResolvedContextLimit = status.contextLimit;
     if (resolvedName !== this.lastDispatchedProviderName) {
       this.lastDispatchedProviderName = resolvedName;
       recordMetaEvent(this.sessionKey, "provider.selected", {
@@ -4680,7 +4940,13 @@ var ChatDriver = class _ChatDriver extends EventTarget {
     try {
       const resolved = await provider.getStatus?.();
       if (resolved) {
-        status = { model: resolved.model, provider: resolved.provider };
+        status = {
+          model: resolved.model,
+          provider: resolved.provider,
+          // Carried so the mid-loop guard can measure against the window of the
+          // provider this call actually resolved to (GENC-1567).
+          contextLimit: resolved.contextLimit
+        };
       }
     } catch {
       status = {};
@@ -4837,9 +5103,48 @@ var ChatDriver = class _ChatDriver extends EventTarget {
     return snapshot;
   }
   /**
-   * Optional transform applied to conversation history immediately before each LLM request.
-   * Cleared when `undefined`. Does not alter stored history.
+   * Set the mid-loop context guard. Its margin is deliberately far smaller than
+   * the reserve that blocks NEW turns: that reserve exists so an accepted turn can
+   * spend it, and a guard set at the same line would kill every turn that used
+   * the headroom it was given.
+   */
+  setContextGuard(policy) {
+    this.contextGuard = policy && policy.marginTokens > 0 ? policy : void 0;
+  }
+  /**
+   * Whether issuing `requestHistory` would run the context window out.
+   *
+   * Inert unless a margin has been set AND the resolved provider reports a
+   * window — with no window there is nothing to measure against, and inventing
+   * one to refuse a request is worse than letting the provider answer.
+   *
+   * Stopping here is strictly better than letting the request go: the provider
+   * would reject an oversized prompt outright, leaving a transcript still too
+   * large to retry and no explanation the user can act on, whereas ending the
+   * turn keeps history intact so compaction is still available and the work so
+   * far is not lost.
    */
+  contextExhausted(requestHistory, pendingInput) {
+    const guard = this.contextGuard;
+    if (!guard) return void 0;
+    const limit = this.lastResolvedContextLimit ?? guard.fallbackLimit;
+    if (limit == null || limit <= 0) return void 0;
+    const threshold = Math.max(0, limit - guard.marginTokens);
+    const request = pendingInput && (pendingInput.content || pendingInput.attachments?.length) ? [
+      ...requestHistory,
+      {
+        role: "user",
+        content: pendingInput.content,
+        attachments: pendingInput.attachments
+      }
+    ] : requestHistory;
+    const estimated = estimateRequestTokens(this.history, request);
+    if (estimated < threshold) return void 0;
+    logger2.error(
+      `ChatDriver: ending the turn \u2014 the request would fill the context window (~${estimated} of ${limit})`
+    );
+    return { estimated, threshold };
+  }
   setProviderHistoryTransform(transform) {
     this.providerHistoryTransform = transform;
   }
@@ -4853,6 +5158,26 @@ var ChatDriver = class _ChatDriver extends EventTarget {
   getActiveFoldNames() {
     return this.foldStack.map((f) => f.foldName);
   }
+  /**
+   * The transcript as it should be **stored**: every tool payload the model has already stopped
+   * seeing replaced by the same stub it was sent (GENC-1566). Live history is untouched — this
+   * returns a copy.
+   *
+   * Condensation deliberately spares stored history, because the live transcript and the debug
+   * export both read it. A host writing that transcript to durable storage inherits the other
+   * half of that decision: it stores payloads the driver has already retired, on every autosave,
+   * for the life of the session. Measured on one small Create session — 58,187 chars, 7.4% of a
+   * 790 KB session object, across five payloads worth 14,434 tokens of context, written 86 times.
+   *
+   * Only already-collapsed payloads are touched, so this can never store a stub for something the
+   * model can still see, and it has no side effects (see `condenseForPersistence`, which is
+   * internal). A host that wants the unredacted transcript still calls
+   * {@link ChatDriver.getRawHistory}, and a diagnostics stream that keeps full payloads is
+   * unaffected — which is what makes the elision recoverable.
+   */
+  getHistoryForPersistence() {
+    return condenseForPersistence([...this.history], this.condensePolicies);
+  }
   async getSuggestions(history, prompt2, count, allAgentInfo) {
     const defaultProvider = this.providerRegistry.default();
     if (!defaultProvider.prompt) {
@@ -4918,8 +5243,19 @@ Output format (strict):
    * turns exists behind a clean boundary. Uses the same `history` `compact()`
    * acts on, so the UI's gate can't disagree with the action (GENC-1351 follow-up).
    */
-  canCompact() {
-    return findCompactionCut(this.history) != null;
+  canCompact(options) {
+    return this.getCompactionPlan(options) != null;
+  }
+  /**
+   * {@inheritDoc AiDriver.getCompactionPlan}
+   *
+   * Runs against the driver's own `history` — the exact list `compact()` acts on
+   * — so a projection and the compaction it describes can never be computed from
+   * different transcripts (the GENC-1351 follow-up that first made `canCompact`
+   * read `history` rather than a mirrored copy).
+   */
+  getCompactionPlan(options) {
+    return planCompaction(this.history, options);
   }
   /**
    * Destructively compact older turns into a single `compacted-summary` message
@@ -4930,7 +5266,7 @@ Output format (strict):
    * the new one. Returns the created summary message, or `null` when there is
    * nothing worth compacting or the default provider cannot summarize.
    */
-  async compact() {
+  async compact(options) {
     if (this.busy) return null;
     const defaultProvider = this.providerRegistry.default();
     if (!defaultProvider.prompt) {
@@ -4938,7 +5274,7 @@ Output format (strict):
       return null;
     }
     const history = this.history;
-    const cut = findCompactionCut(history);
+    const cut = planCompaction(history, options)?.cut;
     if (cut == null) return null;
     const toCompact = history.slice(0, cut);
     const tail = history.slice(cut);
@@ -5409,6 +5745,7 @@ Output format (strict):
       activityBus: this.activityBus
     });
     child.markAsSubAgent();
+    child.setContextGuard(this.contextGuard);
     const disposeChild = () => child.dispose();
     if (this.lifecycleController.signal.aborted) {
       disposeChild();
@@ -5889,6 +6226,30 @@ ${tailBody}
       if (this.lastResolvedProvider !== void 0)
         turnSnapshot.provider = this.lastResolvedProvider;
       if (this.lastResolvedModel !== void 0) turnSnapshot.model = this.lastResolvedModel;
+      const contextStop = this.contextExhausted(historyForCall, {
+        content: userInputForCall,
+        attachments: attachmentsForCall
+      });
+      if (contextStop) {
+        recordTurnError(this.sessionKey, "context-exhausted", {
+          agent: this.activeAgentName,
+          provider: this.lastResolvedProviderName,
+          contextTokens: contextStop.estimated,
+          guard: contextStop.threshold,
+          limit: this.lastResolvedContextLimit,
+          iterations,
+          isSubAgent: this.isSubAgent
+        });
+        if (this.isSubAgent) {
+          this.failSubAgent("context_exhausted");
+        } else {
+          this.appendToHistory({
+            role: "assistant",
+            content: "I had to stop here \u2014 this conversation has filled the available context. Compact it to free up room, then ask me to continue."
+          });
+        }
+        return this.turnDone("context-exhausted");
+      }
       let response;
       try {
         response = await activeProvider.chat(historyForCall, userInputForCall, options);
@@ -5948,6 +6309,27 @@ ${tailBody}
           }
           return this.turnDone("response-truncated");
         }
+        if (e instanceof ContextOverflowError) {
+          logger2.error("ChatDriver: the prompt exceeded the model context window", e);
+          recordTurnError(this.sessionKey, "context-exhausted", {
+            agent: this.activeAgentName,
+            provider: this.lastResolvedProviderName,
+            vendor: vendorTypeOfLabel(e.vendorLabel) ?? this.lastResolvedProvider,
+            promptTokens: e.promptTokens,
+            limitTokens: e.limitTokens,
+            via: "provider",
+            isSubAgent: this.isSubAgent
+          });
+          if (this.isSubAgent) {
+            this.failSubAgent("context_exhausted");
+          } else {
+            this.appendToHistory({
+              role: "assistant",
+              content: DEFAULT_CONTEXT_OVERFLOW_MESSAGE
+            });
+          }
+          return this.turnDone("context-exhausted");
+        }
         if (e instanceof ProviderRefusedError) {
           if (this.isSubAgent) {
             logger2.error("ChatDriver: provider refused the request", e);
@@ -6619,13 +7001,37 @@ var OrchestratingDriver = class extends EventTarget {
   getRawHistory() {
     return this.chatDriver.getHistory();
   }
+  /**
+   * Delegates to the inner {@link ChatDriver} — condensation policies are registered there, so it
+   * is the only object that knows which payloads the model has stopped seeing (GENC-1566).
+   *
+   * **This forward is the whole feature, for any multi-agent host.** `AiDriver` declares
+   * `getHistoryForPersistence` optional, and `SessionPersister` calls it through `?.`, falling back
+   * to {@link OrchestratingDriver.getRawHistory}. This class does NOT extend `ChatDriver` — it
+   * wraps one — so without an explicit forward the optional call resolves to `undefined` and every
+   * host on an orchestrating driver silently keeps persisting the full payloads. Measured exactly
+   * that way on a Create run: 10 `context.condensed` events fired, and the session still stored
+   * the two largest `read_context` results at 26,907 and 23,060 chars. The method existed, the
+   * tests passed, and the feature did nothing.
+   */
+  getHistoryForPersistence() {
+    return this.chatDriver.getHistoryForPersistence();
+  }
+  /** {@inheritDoc AiDriver.setContextGuard} */
+  setContextGuard(policy) {
+    this.chatDriver.setContextGuard(policy);
+  }
   /** {@inheritDoc AiDriver.compact} */
-  compact() {
-    return this.chatDriver.compact();
+  compact(options) {
+    return this.chatDriver.compact(options);
   }
   /** {@inheritDoc AiDriver.canCompact} */
-  canCompact() {
-    return this.chatDriver.canCompact();
+  canCompact(options) {
+    return this.chatDriver.canCompact(options);
+  }
+  /** {@inheritDoc AiDriver.getCompactionPlan} */
+  getCompactionPlan(options) {
+    return this.chatDriver.getCompactionPlan(options);
   }
   /** Delegates to the inner {@link ChatDriver} — turns are captured there. */
   getTurnSnapshots() {