mixdog 1.3.1 → 1.3.3

package/src/runtime/agent/orchestrator/session/loop/fresh-context.mjs

@@ -5,7 +5,6 @@ import { getProvider, initProviders } from '../../providers/registry.mjs';
 import { resolveMaintenanceRoute } from '../../agent-runtime/maintenance-route.mjs';
 import { resolveSessionContextMeta } from '../manager/context-meta.mjs';
 import { isAccountQuotaError } from '../../providers/account-pool.mjs';
-import { builtinFeatureActive } from '../../runtime-core/builtin-features.mjs';
 import { positiveInt } from '../../../../shared/numbers.mjs';
 import { estimateMessagesTokens, providerTokenCalibration } from '../context-utils.mjs';
 import {
@@ -16,6 +15,8 @@ import {
   COMPACT_TARGET_MIN_TOKENS,
 } from '../compact.mjs';
 import { summarizeOnSharedPrefix } from '../compact/forked-summary.mjs';
+import { normalizeCompactionSummaryMode } from '../compact/summary-mode.mjs';
+import { compactionCacheWarm, lighterSubscriptionModel } from '../compact/summary-route.mjs';
 import { retireCompactionFork } from '../side-question-store.mjs';
 
 // Conversation summarization triggers independently of the post-compact target:
@@ -24,52 +25,103 @@ import { retireCompactionFork } from '../side-question-store.mjs';
 const CONVERSATION_COMPACT_TRIGGER_RATIO = 0.05;
 const CONVERSATION_COMPACT_TRIGGER_MAX_TOKENS = 20_000;
 
-// Select an explicitly configured, enabled maintenance route only. An absent
-// or disabled maintenance role falls back to the conversation's own model,
-// not an unrelated global default. Provider failures/cancellation are not
-// absence and must propagate without silently routing around them.
-export async function resolveCompactionRoute({
+// One summary route: the provider, its model and the window the summary
+// request must fit. `source` names the step: 'session' (the conversation's
+// own model), 'maintenance' (the Maintainer) or 'lighter' (the subscription
+// provider's lighter model).
+function summaryRoute({ sessionRef, provider, providerName, model, fast, source }) {
+  if (!provider || typeof provider.send !== 'function' || !model) {
+    throw new Error(`compact summary route unavailable: ${providerName || 'unknown'}/${model || 'unknown'}`);
+  }
+  const sameModel = providerName === sessionRef?.provider && model === sessionRef?.model;
+  const contextWindow =
+    sameModel && positiveInt(sessionRef?.contextWindow)
+      ? positiveInt(sessionRef.contextWindow)
+      : resolveSessionContextMeta(provider, model, {}, { wholeWindow: true }).contextWindow;
+  return { provider, providerName, model, contextWindow, fast, source };
+}
+
+// The Maintainer's own model when one is set and enabled, whatever the memory
+// or recap settings; null otherwise (an unrelated global default is never
+// borrowed). Provider failures/cancellation are not absence and propagate.
+async function resolveMaintainerRoute({ sessionRef, config, signal, getProviderFn, initProvidersFn }) {
+  const route = resolveMaintenanceRoute({ agent: 'cycle1-agent', config, includeDefault: false });
+  if (!(route?.provider && route?.model && config.providers?.[route.provider]?.enabled !== false)) return null;
+  await initProvidersFn(config.providers || {}, { signal });
+  signal?.throwIfAborted();
+  return summaryRoute({
+    sessionRef,
+    provider: getProviderFn(route.provider),
+    providerName: route.provider,
+    model: route.model,
+    fast: route.fast === true,
+    source: 'maintenance',
+  });
+}
+
+function resolveSessionRoute({ sessionRef, provider, model, getProviderFn }) {
+  const providerName = sessionRef?.provider || provider?.name;
+  return summaryRoute({
+    sessionRef,
+    provider: provider || getProviderFn(providerName),
+    providerName,
+    model: model || sessionRef?.model,
+    source: 'session',
+  });
+}
+
+// The newest lighter model of a subscription provider's saved account
+// catalog; null on any other provider, without a saved catalog, when none is
+// listed, or when the conversation already runs on it.
+async function resolveLighterRoute(input) {
+  const session = resolveSessionRoute(input);
+  const lighter = await lighterSubscriptionModel(session.providerName);
+  input.signal?.throwIfAborted();
+  if (!lighter || lighter === session.model) return null;
+  return summaryRoute({
+    sessionRef: input.sessionRef,
+    provider: session.provider,
+    providerName: session.providerName,
+    model: lighter,
+    source: 'lighter',
+  });
+}
+
+/**
+ * The compaction summary plan (compact/summary-mode.mjs): the saved mode,
+ * whether the session's prompt cache is warm, and the routes in the order
+ * they are tried, each resolved only when reached (null = unavailable, the
+ * next one runs). The conversation's own model is always the last step.
+ */
+export function compactionSummaryPlan({
   sessionRef,
+  sessionId = sessionRef?.id,
   provider,
   model,
   config = loadConfig(),
   signal,
   getProviderFn = getProvider,
   initProvidersFn = initProviders,
-  allowMaintenance = true,
+  now = Date.now(),
 } = {}) {
   signal?.throwIfAborted();
-  const route =
-    allowMaintenance && builtinFeatureActive(config, 'memory') && config.recap?.enabled !== false
-      ? resolveMaintenanceRoute({ agent: 'cycle1-agent', config, includeDefault: false })
-      : null;
-  const useMaintenance = !!(route?.provider && route?.model && config.providers?.[route.provider]?.enabled !== false);
-  const providerName = useMaintenance ? route.provider : sessionRef?.provider || provider?.name;
-  const selectedModel = useMaintenance ? route.model : model || sessionRef?.model;
-  if (useMaintenance) await initProvidersFn(config.providers || {}, { signal });
-  signal?.throwIfAborted();
-  const selectedProvider = useMaintenance ? getProviderFn(providerName) : provider || getProviderFn(providerName);
-  if (!selectedProvider || typeof selectedProvider.send !== 'function' || !selectedModel) {
-    throw new Error(`compact summary route unavailable: ${providerName || 'unknown'}/${selectedModel || 'unknown'}`);
-  }
-  const sameModel = providerName === sessionRef?.provider && selectedModel === sessionRef?.model;
-  const contextWindow =
-    sameModel && positiveInt(sessionRef?.contextWindow)
-      ? positiveInt(sessionRef.contextWindow)
-      : resolveSessionContextMeta(selectedProvider, selectedModel, {}, { wholeWindow: true }).contextWindow;
-  return {
-    provider: selectedProvider,
-    providerName,
-    model: selectedModel,
-    contextWindow,
-    fast: useMaintenance ? route.fast === true : undefined,
-    source: useMaintenance ? 'maintenance' : 'session',
-  };
+  const input = { sessionRef, provider, model, config, signal, getProviderFn, initProvidersFn };
+  const mode = normalizeCompactionSummaryMode(config.compaction);
+  const warm = compactionCacheWarm(sessionId, now);
+  const session = async () => resolveSessionRoute(input);
+  const maintainer = () => resolveMaintainerRoute(input);
+  const lighter = () => resolveLighterRoute(input);
+  let steps = [session];
+  if (mode === 'maintainer') steps = [maintainer, session];
+  else if (mode === 'smart' && !warm) steps = [maintainer, lighter, session];
+  return { mode, warm, steps };
 }
 
-// The isolated summary request on one route. Its input budget belongs to
-// its OWN model, whereas the rebuilt conversation must fit the original
-// session's target/window.
+// The summary request on one route: the conversation alone (earlier summary,
+// dialogue, runtime conversation rows and one bounded line per tool call;
+// skills and injections excluded), never the cached context. Its input budget belongs to its OWN model, split into
+// batches when the conversation is larger, whereas the rebuilt conversation
+// must fit the original session's target/window.
 function summarizeConversation(target, ctx) {
   const { sessionRef, sessionId, signal, sendOpts, compactPolicy } = ctx;
   const summaryWindow = positiveInt(target.contextWindow) || ctx.contextWindow;
@@ -107,7 +159,6 @@ function summarizeConversation(target, ctx) {
       fast: target.fast,
       timeoutMs: compactPolicy.handoffTimeoutMs,
       force: true,
-      filterOldHistoryForIngest: true,
     }
   );
 }
@@ -117,24 +168,24 @@ function sumUsage(a, b) {
   return Object.fromEntries(Object.keys(a).map((key) => [key, (a[key] || 0) + (Number(b[key]) || 0)]));
 }
 
-// Summary policy. On the session's own provider and model the summary forks
-// the latest cached request (compact/forked-summary.mjs): the context is
-// already in the prompt cache, so reading it costs a tenth to a twentieth of
-// sending the text-only transcript uncached, and the summary sees the full
-// execution context. A different summary route (the maintenance model)
-// cannot share that cache; there the isolated text-only request runs: on
-// the usage ledger it cost a median $0.16 and 24.5 s against a projected
-// $0.19 and 27 s for a cache-read fork of the main model's median 500k-token
-// context (the fork is cheaper than a same-model isolated request, $0.20).
-// A fork that cannot run or fails falls back to the isolated request.
-async function summarizeOnRoute(route, ctx) {
-  const shared = await summarizeOnSharedPrefix({
-    sessionId: ctx.sessionId,
-    route,
-    conversationInput: ctx.conversationInput,
-    signal: ctx.signal,
-    timeoutMs: ctx.compactPolicy.handoffTimeoutMs,
-  });
+// The summary on one route. While the session's prompt cache is warm, the
+// summary forks the latest cached request on the conversation's own model
+// (compact/forked-summary.mjs): reading the cached context costs a tenth to a
+// twentieth of sending the text-only transcript uncached, and the summary
+// sees the full execution context. A cold cache would be rewritten in full,
+// so the isolated text-only request runs instead; so does any other route
+// (a cache is never shared across models). A fork that cannot run or fails
+// falls back to the isolated request on the same route.
+async function summarizeOnRoute(route, ctx, warm) {
+  const shared = warm
+    ? await summarizeOnSharedPrefix({
+        sessionId: ctx.sessionId,
+        route,
+        conversationInput: ctx.conversationInput,
+        signal: ctx.signal,
+        timeoutMs: ctx.compactPolicy.handoffTimeoutMs,
+      })
+    : { fallback: 'cold_cache' };
   if (shared.generated) return shared.generated;
   ctx.signal?.throwIfAborted();
   const generated = await summarizeConversation(route, ctx);
@@ -145,34 +196,45 @@ async function summarizeOnRoute(route, ctx) {
   };
 }
 
-// A maintenance summary model that is out of quota must not take the whole
-// turn down: the conversation's own model still has budget and can
-// summarize. Only exhaustion reroutes — every other compaction failure
-// (overflow, malformed summary, transport) keeps its existing handling, and
-// an aborted turn stays aborted.
-async function summarizeWithQuotaFallback(ctx, routeInput) {
-  const route = await resolveCompactionRoute(routeInput);
-  try {
-    return { route, generated: await summarizeOnRoute(route, ctx) };
-  } catch (error) {
-    ctx.signal?.throwIfAborted();
-    const status = Number(error?.status || error?.httpStatus || error?.response?.status || 0);
-    const exhausted = error?.code === 'provider_accounts_exhausted' || status === 429 || isAccountQuotaError(error);
-    const fallback =
-      route.source === 'maintenance' && exhausted
-        ? await resolveCompactionRoute({ ...routeInput, allowMaintenance: false })
-        : null;
-    if (!fallback || (fallback.providerName === route.providerName && fallback.model === route.model)) {
-      error.compactRoute = { provider: route.providerName, model: route.model };
-      throw error;
-    }
+// A Maintainer or lighter model that is out of quota or not available to the
+// account must not take the whole turn down: the next route still can
+// summarize. Every other compaction failure (overflow, malformed summary,
+// transport) keeps its existing handling, and an aborted turn stays aborted.
+function fallsToNextRoute(error) {
+  const status = Number(error?.status || error?.httpStatus || error?.response?.status || 0);
+  return (
+    error?.code === 'provider_accounts_exhausted' ||
+    error?.code === 'model_not_found' ||
+    status === 429 ||
+    status === 404 ||
+    isAccountQuotaError(error)
+  );
+}
+
+// Resolving a route (provider init, catalog lookup) is part of its step: a
+// quota or availability failure there moves to the next route like one from
+// the summary request. The conversation's own model is the last step, so its
+// failure always ends the compaction.
+async function summarizeOnPlan(ctx, plan) {
+  const tried = new Set();
+  let failure = null;
+  for (const step of plan.steps) {
+    let route = null;
     try {
-      return { route: fallback, generated: await summarizeOnRoute(fallback, ctx) };
-    } catch (fallbackError) {
-      fallbackError.compactRoute = { provider: fallback.providerName, model: fallback.model };
-      throw fallbackError;
+      route = await step();
+      ctx.signal?.throwIfAborted();
+      const key = route && `${route.providerName}\u0000${route.model}`;
+      if (!route || tried.has(key)) continue;
+      tried.add(key);
+      return { route, generated: await summarizeOnRoute(route, ctx, plan.warm) };
+    } catch (error) {
+      ctx.signal?.throwIfAborted();
+      if (route) error.compactRoute = { provider: route.providerName, model: route.model };
+      if (route?.source === 'session' || !fallsToNextRoute(error)) throw error;
+      failure = error;
     }
   }
+  throw failure;
 }
 
 // The window this compaction must fit (calibrated to the provider's token
@@ -200,7 +262,10 @@ function freshContextBudget({ compactPolicy, sessionRef, provider, compactBudget
   return { contextWindow, hardBudget, conversationInput, conversationTokens, conversationThresholdTokens };
 }
 
-function freshContextBuildOptions({ compactPolicy = {}, sessionId, goalReminderText, activeTurn }, budget) {
+function freshContextBuildOptions(
+  { compactPolicy = {}, sessionId, goalReminderText, activeTurn, referenceLatestAttachments },
+  budget
+) {
   return {
     reserveTokens: compactPolicy.reserveTokens,
     maxBudgetTokens: budget.hardBudget,
@@ -209,6 +274,7 @@ function freshContextBuildOptions({ compactPolicy = {}, sessionId, goalReminderT
     sessionId,
     latestUserPrefix: goalReminderText,
     activeTurn,
+    referenceLatestAttachments: referenceLatestAttachments === true,
   };
 }
 
@@ -230,6 +296,27 @@ export function previewFreshContextCompaction(input) {
   return { beforeTokens, afterTokens, reducesTokens: afterTokens < beforeTokens, summaryTriggered };
 }
 
+function buildFreshContextResult(
+  { messages, compactBudgetTokens, buildOptions, requireReduction, sessionId },
+  handoffText
+) {
+  const result = freshContextCompactMessages(messages, compactBudgetTokens, { ...buildOptions, handoffText });
+  // A generated summary can differ from its prediction. Never replace the
+  // original with an automatic result that is equal-sized or larger.
+  if (requireReduction && estimateMessagesTokens(result.messages) >= estimateMessagesTokens(messages)) {
+    return {
+      ...result,
+      messages,
+      freshContext: false,
+      skipped: true,
+      diagnostics: { ...result.diagnostics, noOp: true, reason: 'no_token_reduction' },
+    };
+  }
+  // The rewritten transcript is no longer what the saved request carried.
+  if (result.freshContext) retireCompactionFork(sessionId);
+  return result;
+}
+
 export async function runFreshContextCompact({
   sessionRef,
   messages,
@@ -246,35 +333,24 @@ export async function runFreshContextCompact({
   getProviderFn,
   initProvidersFn,
   requireReduction = false,
+  referenceLatestAttachments = false,
 } = {}) {
   const startedAt = Date.now();
   signal?.throwIfAborted();
-  const { contextWindow, hardBudget, conversationInput, conversationTokens, conversationThresholdTokens } =
-    freshContextBudget({ compactPolicy, sessionRef, provider, compactBudgetTokens, messages });
+  const { contextWindow, hardBudget, conversationTokens, conversationThresholdTokens } = freshContextBudget({
+    compactPolicy,
+    sessionRef,
+    provider,
+    compactBudgetTokens,
+    messages,
+  });
   const summaryTriggered = conversationTokens >= conversationThresholdTokens;
-  const build = (handoffText) => {
-    const result = freshContextCompactMessages(messages, compactBudgetTokens, {
-      ...freshContextBuildOptions(
-        { compactPolicy, sessionId, goalReminderText, activeTurn },
-        { contextWindow, hardBudget }
-      ),
-      handoffText,
-    });
-    // A generated summary can differ from its prediction. Never replace the
-    // original with an automatic result that is equal-sized or larger.
-    if (requireReduction && estimateMessagesTokens(result.messages) >= estimateMessagesTokens(messages)) {
-      return {
-        ...result,
-        messages,
-        freshContext: false,
-        skipped: true,
-        diagnostics: { ...result.diagnostics, noOp: true, reason: 'no_token_reduction' },
-      };
-    }
-    // The rewritten transcript is no longer what the saved request carried.
-    if (result.freshContext) retireCompactionFork(sessionId);
-    return result;
-  };
+  const buildOptions = freshContextBuildOptions(
+    { compactPolicy, sessionId, goalReminderText, activeTurn, referenceLatestAttachments },
+    { contextWindow, hardBudget }
+  );
+  const build = (handoffText) =>
+    buildFreshContextResult({ messages, compactBudgetTokens, buildOptions, requireReduction, sessionId }, handoffText);
   const pipeline = {
     mode: summaryTriggered ? 'conversation-summary' : 'rules',
     conversationTokens,
@@ -291,7 +367,17 @@ export async function runFreshContextCompact({
       pipeline: { ...pipeline, totalMs: Date.now() - startedAt },
     });
   }
-  const { route, generated } = await summarizeWithQuotaFallback(
+  const plan = compactionSummaryPlan({
+    sessionRef,
+    sessionId,
+    provider,
+    model,
+    config,
+    signal,
+    getProviderFn,
+    initProvidersFn,
+  });
+  const { route, generated } = await summarizeOnPlan(
     {
       sessionRef,
       sessionId,
@@ -301,9 +387,11 @@ export async function runFreshContextCompact({
       compactBudgetTokens,
       hardBudget,
       contextWindow,
-      conversationInput,
+      // What the summary is written from: the measured conversation plus one
+      // bounded line per tool call (conversationCompactionInput).
+      conversationInput: conversationCompactionInput(messages, { summary: true }),
     },
-    { sessionRef, provider, model, config, signal, getProviderFn, initProvidersFn }
+    plan
   );
   signal?.throwIfAborted();
   const result = build(generated.summary);
@@ -315,6 +403,8 @@ export async function runFreshContextCompact({
     pipeline: {
       ...pipeline,
       handoffSource: 'session-local',
+      summaryMode: plan.mode,
+      cacheWarm: plan.warm,
       summaryRoute: route.source,
       summaryProvider: route.providerName,
       summaryModel: route.model,

package/src/runtime/agent/orchestrator/session/loop/loop-state.mjs

@@ -58,6 +58,7 @@ export function createLoopState({ provider, messages, model, tools, cwd, sendOpt
     lastUsage: undefined,
     firstTurnUsage: undefined,
     response: undefined,
+    lastStreamedChars: 0,
     lastSendTools: tools,
     contextOverflowRetryUsed: false,
     // Set when a provider context-overflow refusal triggers the in-turn
@@ -133,6 +134,10 @@ export function createLoopState({ provider, messages, model, tools, cwd, sendOpt
     sessionId,
     sessionAgent: state.sessionAgent,
     drainSteering: state.drainSteering,
+    // Only a provider that can offer a higher max_tokens implements this.
+    escalateMaxTokens: () => state.provider?.escalatedMaxTokens?.(state.model, state.opts, state.lastSendTools) ?? null,
+    // Characters the latest send put on screen through the live text stream.
+    streamedChars: () => state.lastStreamedChars,
   });
   return state;
 }

package/src/runtime/agent/orchestrator/session/loop/no-tool-turn/continuation.mjs

@@ -6,6 +6,7 @@
 // continuations with no intervening tool batch, the current text is accepted
 // as the final answer.
 import { writeLoopDiagnostic } from './diagnostic.mjs';
+import { resetOutputLimitRecovery } from './output-limit.mjs';
 
 const PROVIDER_CONTINUATION_NO_TOOL_LIMIT = Math.max(
   1,
@@ -38,6 +39,7 @@ export function resumeContinuation(
   state.providerContinuationCount += 1;
   state.continuationsSinceToolBatch += 1;
   state.emptyNudgeStreak = 0;
+  resetOutputLimitRecovery(state);
   trace(iteration, 'provider_continuation', {
     signal,
     stop_reason: stopReason,

package/src/runtime/agent/orchestrator/session/loop/no-tool-turn/empty-nudge.mjs

@@ -25,7 +25,7 @@ export function nudgeEmptyTurn(response, { stopReason, isIncompleteStop }, { sta
   messages.push({
     role: 'user',
     content: isIncompleteStop
-      ? `[mixdog-runtime] Empty truncated continuation (stopReason=${stopReason}). Return the remaining final handoff; use tools only for required evidence still missing.`
+      ? `[mixdog-runtime] Empty incomplete turn (stopReason=${stopReason}). Return the remaining final handoff; use tools only for required evidence still missing.`
       : `[mixdog-runtime] Empty response (${state.emptyNudgeStreak}/${EMPTY_NUDGE_MAX}). Return final text, or use tools only for required evidence still missing.`,
   });
   return { action: 'continue', response };

package/src/runtime/agent/orchestrator/session/loop/no-tool-turn/output-limit.mjs

@@ -1,13 +1,22 @@
-// Max-output ladder.
+// Max-output recovery — the single rule for every turn the provider cut at its
+// output ceiling, with or without visible text.
 //
-// A provider max-output stop is not a completed assistant turn, even when it
-// contains useful text. Preserve each partial in the provider transcript and
-// grant at most MAX_OUTPUT_RECOVERY_LIMIT direct continuations before
-// surfacing a hard truncation.
+// A max-output stop is not a completed assistant turn. A turn that spent its
+// whole budget (typically on thinking) would repeat identically if re-sent
+// unchanged, so recovery changes the request each time:
+//   1. Escalation, once per progress window: re-send the same transcript with
+//      a higher max_tokens when the provider has one to offer (no message
+//      added; the cut partial is discarded and regenerated).
+//   2. Up to MAX_OUTPUT_RECOVERY_LIMIT resume prompts at the normal
+//      max_tokens, preserving any partial text in the transcript.
+//   3. Then the turn ends with a visible notice that the output limit was hit.
+// Real progress (a tool-call turn, a continued text turn) resets both steps.
+import { isOutputLimitStopReason } from '../termination.mjs';
+
 const MAX_OUTPUT_RECOVERY_LIMIT = 3;
-const MAX_OUTPUT_EXHAUSTED_NOTICE = `[mixdog-runtime] Output remained truncated after ${MAX_OUTPUT_RECOVERY_LIMIT} continuation attempts.`;
+const MAX_OUTPUT_EXHAUSTED_NOTICE = `[mixdog-runtime] The model hit its output limit and the response stayed truncated after ${MAX_OUTPUT_RECOVERY_LIMIT} recovery attempts.`;
 const MAX_OUTPUT_RESUME_PROMPT =
-  'Output token limit hit. Resume directly — no apology, no recap. Pick up exactly where the previous text stopped.';
+  '[mixdog-runtime] Output token limit hit. Resume directly — no apology, no recap. Pick up exactly where you left off, and break the remaining work into smaller pieces.';
 // A response whose stream was cut mid-text (and could not be withdrawn from
 // the screen) resumes through the same ladder with its own reason.
 const STREAM_CUT_RESUME_PROMPT =
@@ -19,25 +28,65 @@ function resumePrompt(response, attempt) {
     : { role: 'user', content: MAX_OUTPUT_RESUME_PROMPT, meta: { source: 'max-output-recovery', attempt } };
 }
 
-export function resolveOutputLimit(response, { state, segments, messages }) {
-  segments.record(response.content);
+// Real progress ends the recovery window: the next cut starts a fresh ladder.
+export function resetOutputLimitRecovery(state) {
+  state.maxOutputRecoveryCount = 0;
+  state.outputEscalationUsed = false;
+}
+
+// The escalation discards the cut response, so whatever it already put on the
+// live stream must be withdrawn through the owner's retraction channel — the
+// same one transport replays use. Text the owner cannot withdraw would be
+// shown twice, so that case does not escalate.
+async function withdrawStreamedText(opts, chars) {
+  if (!(chars > 0)) return true;
+  if (typeof opts?.onTextReset !== 'function') return false;
+  try {
+    return (await opts.onTextReset({ chars, reasoning: false, reason: 'output-limit-escalation' })) === true;
+  } catch {
+    return false;
+  }
+}
+
+export async function resolveOutputLimit(
+  response,
+  { state, segments, messages, opts, escalateMaxTokens, streamedChars }
+) {
+  const hasContent = typeof response.content === 'string' && response.content.trim().length > 0;
+  if (!state.outputEscalationUsed && isOutputLimitStopReason(response.stopReason ?? response.stop_reason)) {
+    state.outputEscalationUsed = true;
+    // A provider may resolve the higher limit asynchronously (route lookup);
+    // failing to find one only skips the escalation.
+    const limit = await Promise.resolve()
+      .then(escalateMaxTokens)
+      .catch(() => null);
+    if (limit > 0 && (await withdrawStreamedText(opts, streamedChars()))) {
+      // Taken off the shared options by the very next send (sendProviderRequest).
+      opts.maxOutputTokensOverride = limit;
+      return { action: 'continue', response };
+    }
+  }
+  if (hasContent) segments.record(response.content);
   if (state.maxOutputRecoveryCount < MAX_OUTPUT_RECOVERY_LIMIT) {
     // The partial assistant turn must be visible to the model so it can
     // resume at the exact cutoff instead of reconstructing or repeating
     // it. askSession persists this natural recovery chain;
     // historyContent below prevents the aggregate returned to callers
-    // from being persisted a second time.
-    segments.commitIntermediate(response);
+    // from being persisted a second time. An empty cut has no output to keep.
+    if (hasContent) segments.commitIntermediate(response);
     state.maxOutputRecoveryCount += 1;
     messages.push(resumePrompt(response, state.maxOutputRecoveryCount));
     return { action: 'continue', response };
   }
-  const terminalSegment = `${response.content}\n\n${MAX_OUTPUT_EXHAUSTED_NOTICE}`;
+  const terminalSegment = hasContent
+    ? `${response.content}\n\n${MAX_OUTPUT_EXHAUSTED_NOTICE}`
+    : MAX_OUTPUT_EXHAUSTED_NOTICE;
+  const earlier = (hasContent ? segments.parts.slice(0, -1) : segments.parts).join('');
   return {
     action: 'break',
     response: {
       ...response,
-      content: `${segments.parts.slice(0, -1).join('')}${terminalSegment}`,
+      content: `${earlier}${earlier && !hasContent ? '\n\n' : ''}${terminalSegment}`,
       historyContent: terminalSegment,
       maxOutputRecoveryAttempts: state.maxOutputRecoveryCount,
     },

package/src/runtime/agent/orchestrator/session/loop/no-tool-turn.mjs

@@ -14,16 +14,27 @@ import { HIDDEN_AGENT_NAMES } from './hidden-agents.mjs';
 import { INCOMPLETE_STOP_REASONS, isOutputLimitStopReason, providerContinuationSignal } from './termination.mjs';
 import { appendAgentTrace } from '../../agent-trace.mjs';
 import { createTurnSegments } from './no-tool-turn/segments.mjs';
-import { resolveOutputLimit } from './no-tool-turn/output-limit.mjs';
+import { resetOutputLimitRecovery, resolveOutputLimit } from './no-tool-turn/output-limit.mjs';
 import { resolveRefusal } from './no-tool-turn/refusal.mjs';
 import { resumeContinuation } from './no-tool-turn/continuation.mjs';
 import { nudgeEmptyTurn } from './no-tool-turn/empty-nudge.mjs';
 
-export function createNoToolTurnResolver({ messages, opts, sessionId, sessionAgent, drainSteering }) {
+// `escalateMaxTokens()` asks the live provider for a higher one-shot max_tokens
+// (number) or reports none (null/undefined) — the loop stays provider-agnostic.
+export function createNoToolTurnResolver({
+  messages,
+  opts,
+  sessionId,
+  sessionAgent,
+  drainSteering,
+  escalateMaxTokens = () => null,
+  streamedChars = () => 0,
+}) {
   const segments = createTurnSegments({ messages, opts });
   // Per-turn recovery counters shared by the ladders.
   const state = {
     maxOutputRecoveryCount: 0,
+    outputEscalationUsed: false,
     refusalRetryUsed: false,
     emptyNudgeStreak: 0,
     // Structured provider continuation signals honored this turn. Diagnostic
@@ -42,7 +53,7 @@ export function createNoToolTurnResolver({ messages, opts, sessionId, sessionAge
       /* best-effort telemetry */
     }
   };
-  const ladder = { state, segments, messages, sessionId, trace };
+  const ladder = { state, segments, messages, opts, sessionId, trace, escalateMaxTokens, streamedChars };
 
   // A no-tool message ends the turn. Unresolved tool failures remain visible
   // in history and can be reported directly without a synthetic continuation
@@ -66,11 +77,13 @@ export function createNoToolTurnResolver({ messages, opts, sessionId, sessionAge
     // { action: 'continue' | 'break', response }. 'continue' means the
     // recovery appended to the transcript and the loop must re-send;
     // 'break' returns the (possibly aggregated) terminal response.
-    resolve(response, iteration) {
+    async resolve(response, iteration) {
       const hasContent = typeof response.content === 'string' && response.content.trim().length > 0;
       const stopReason = response.stopReason ?? response.stop_reason ?? null;
       const isOutputLimitStop = isOutputLimitStopReason(stopReason);
-      if (hasContent && (isOutputLimitStop || response.streamCut === true)) return resolveOutputLimit(response, ladder);
+      if (isOutputLimitStop || (hasContent && response.streamCut === true)) {
+        return resolveOutputLimit(response, ladder);
+      }
       if (stopReason === 'refusal') return resolveRefusal(response, hasContent, ladder);
       // Output-limit stops keep the bounded max-output ladder above and
       // refusals (already returned) keep the bounded refusal retry; both
@@ -108,13 +121,16 @@ export function createNoToolTurnResolver({ messages, opts, sessionId, sessionAge
         })
       ) {
         state.emptyNudgeStreak = 0;
+        resetOutputLimitRecovery(state);
         return { action: 'continue', response };
       }
       return finishTurn(response);
     },
-    // A turn that produced tool calls is never an empty contract violation.
+    // A turn that produced tool calls is never an empty contract violation,
+    // and it is real progress: a later output-limit cut starts a fresh ladder.
     noteToolCallTurn() {
       state.emptyNudgeStreak = 0;
+      resetOutputLimitRecovery(state);
     },
     noteToolBatchCompleted() {
       state.continuationsSinceToolBatch = 0;