mixdog 1.3.2 → 1.3.4

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;

package/src/runtime/agent/orchestrator/session/loop/send-phase.mjs

@@ -186,10 +186,16 @@ export async function sendProviderRequest(state, round) {
   // included: the span the usage ledger recorded as `duration_ms` (stamped on
   // the response); wall time only for a response no ledger row timed.
   const requestStartedAt = Date.now();
+  // The output-limit escalation is one-shot: take it off the shared options
+  // before sending, so this attempt alone carries it whatever the outcome
+  // (retry, route fallback, thrown error, abort).
+  const maxOutputTokensOverride = opts.maxOutputTokensOverride;
+  delete opts.maxOutputTokensOverride;
   let result;
   try {
     result = await runWithProviderRequestToolsScope(round.requestToolScope, () =>
       sendWithRecovery({
+        maxOutputTokensOverride,
         provider,
         messages: providerMessages,
         recoveryMessages: messageSource,
@@ -384,6 +390,7 @@ export function settleSendResult(state, round, sent) {
   if (state.imageStrip) settleImageStrip(state, round, sent);
   opts.onToolCall = undefined;
   delete opts.cacheBreakIntent;
+  state.lastStreamedChars = sent.result.streamedChars || 0;
   state.contextOverflowRetryUsed = false;
   // A completed send ends the outage this budget was covering; the next
   // iteration is a fresh request and must get the full replay budget again.

package/src/runtime/agent/orchestrator/session/loop/tool-exec/before-hook.mjs

@@ -7,12 +7,7 @@ import { runAbortable, throwIfAborted } from '../../../../../shared/abort-race.m
 import { evaluateExecPolicy } from '../../../tools/bash-policy-scan.mjs';
 import { beginSessionApprovalWait } from '../../manager/runtime-liveness.mjs';
 import { agentMcpToolPermission, writeAgentMcpToolPermission } from '../../../mcp/agent-connectors.mjs';
-import {
-  actingContactBotId,
-  humanGateDecision,
-  recordHumanDecision,
-  rememberSurfaceOf,
-} from '../../human-gate/gate.mjs';
+import { actingBotId, actingContactBotId, humanGateDecision, recordHumanDecision } from '../../human-gate/gate.mjs';
 import { applyEditedArgs } from '../../human-gate/requests.mjs';
 
 const isArgsObject = (value) => value && typeof value === 'object' && !Array.isArray(value);
@@ -60,18 +55,22 @@ export const ALLOW_NOT_SAVED_NOTICE = 'Allowed this once. The setting could not
 export const CONNECTOR_APPROVAL_REASON = 'This connector tool is set to ask before it runs for this agent.';
 
 /**
- * A connector tool the running agent set to `needs_approval` asks through the
- * ordinary approval hook, whatever the PreToolUse hooks decided. Run after
- * them, on the final call: a renamed call is judged under its final name.
- * A call the outbound gate owns (its card approved it, or a remembered
- * outbound grant answered it) is not asked a second time.
+ * A connector tool a bot's own session (its home chat or room seat; a
+ * schedule/webhook run, which the approval hook then answers by run policy)
+ * runs, and the bot set to `needs_approval`, asks through the ordinary
+ * approval hook, whatever the PreToolUse hooks decided. Any other session (a
+ * coding Lead, a task session, a workflow agent, a sub-agent) runs it unasked.
+ * Run after the hooks, on the final call: a renamed call is judged under its
+ * final name. A call the outbound gate owns (its card approved it, or a
+ * remembered outbound grant answered it) is not asked a second time.
  * @returns {Promise<{ denial: string } | null>} the denial, or null to run
  */
 export function applyConnectorApproval(call, { agentId, callerSessionId, executeOpts, toolApprovalHook }) {
   if (call.outboundApproved) return null;
+  if (!actingBotId(callerSessionId)) return null;
   if (agentMcpToolPermission(agentId, call.name) !== 'needs_approval') return null;
   // "Always allow" is offered only to the contact bot that is acting, for its
-  // own policy entry for this one tool: never another bot, Mixy or the Lead.
+  // own policy entry for this one tool: never another bot or Mixy.
   const botId = actingContactBotId(callerSessionId);
   const rememberable = Boolean(botId) && botId === agentId;
   return askApproval(call, {
@@ -79,14 +78,7 @@ export function applyConnectorApproval(call, { agentId, callerSessionId, execute
     executeOpts,
     toolApprovalHook,
     decision: { reason: CONNECTOR_APPROVAL_REASON },
-    request: rememberable
-      ? {
-          kind: 'approval',
-          agentId: botId,
-          remember: ['once', 'agent'],
-          rememberAt: rememberSurfaceOf(callerSessionId),
-        }
-      : null,
+    request: rememberable ? { kind: 'approval', agentId: botId, remember: ['once', 'agent'] } : null,
     onApproved: async (approval) => {
       if (!rememberable || approval?.remember !== 'agent') return;
       try {

package/src/runtime/agent/orchestrator/session/loop/tool-exec/call-prep.mjs

@@ -7,6 +7,7 @@ import { enqueuePendingMessage, markCompletionEntry } from '../../manager/pendin
 import { markSessionToolOutputTail } from '../../manager/runtime-liveness.mjs';
 import { createScopedCacheOutcome } from '../../cache/scoped-cache-outcome.mjs';
 import { modelVisibleToolCompletionMessage } from '../../../../../shared/tool-execution-contract.mjs';
+import { turnHopOf } from '../../../../../shared/bot-hops.mjs';
 import { _isScopedCacheableTool } from '../tool-classify.mjs';
 import { refreshDeferredMcpToolCatalog } from '../../../runtime-core/tool-catalog.mjs';
 import { coerceToolArgsForSession } from '../arg-schema-coerce.mjs';
@@ -84,8 +85,12 @@ export function prepareToolCall(name, args, cwd, callerSessionId, sessionRef, ex
   const notificationSessionId = resolveToolCompletionSessionId({ callerSessionId });
   const notifyFn =
     typeof executeOpts.notifyFn === 'function' ? executeOpts.notifyFn : completionNotifier(notificationSessionId);
+  // Background work launched in a bot-descended turn reports back at that hop:
+  // it rides the job's notify context, so every completion's meta carries it.
+  const hop = turnHopOf(sessionRef);
   const completionToolOpts = {
     ...toolOpts,
+    ...(hop > 0 ? { hop } : {}),
     sessionId: callerSessionId,
     agent: sessionRef?.agent || null,
     callerSessionId: notificationSessionId || callerSessionId,

package/src/runtime/agent/orchestrator/session/loop/tool-exec/dispatch.mjs

@@ -17,7 +17,7 @@ import { isOnDeferredToolSurface } from '../deferred-call-through.mjs';
 import { _executeCodeGraphToolLazy } from '../../manager/runtime-loaders.mjs';
 import { requiresReadBody } from '../tool-classify.mjs';
 import { executeCursorNativeBuiltin } from '../../../tools/builtin/external-tool-adapters.mjs';
-import { providerNativePdf, providerReadsImages } from '../../../providers/registry.mjs';
+import { providerModelVisionOverride, providerNativePdf, providerReadsImages } from '../../../providers/registry.mjs';
 import { getModelMetadataSync } from '../../../../../shared/llm/model-catalog.mjs';
 
 /**
@@ -25,16 +25,22 @@ import { getModelMetadataSync } from '../../../../../shared/llm/model-catalog.mj
  * only whether a short PDF may arrive whole as a document block. A scanned
  * page arrives as a page image whenever the model sees images — the provider
  * sends image input (only the text-only local runtime does not) and the
- * catalog does not say the model lacks it — and as OCR text otherwise.
+ * catalog does not say the model lacks it — and as OCR text otherwise. A
+ * custom model's own image-input setting (on or off) beats the catalog.
  */
 export function pdfReadModes(
   sessionRef,
-  { nativePdf = providerNativePdf, readsImages = providerReadsImages, catalogRow = getModelMetadataSync } = {}
+  {
+    nativePdf = providerNativePdf,
+    readsImages = providerReadsImages,
+    catalogRow = getModelMetadataSync,
+    visionOverride = providerModelVisionOverride,
+  } = {}
 ) {
   const provider = sessionRef?.provider;
   const model = sessionRef?.model;
-  const seesImages =
-    readsImages(provider) && (model ? catalogRow(model, provider)?.supportsVision : undefined) !== false;
+  const vision = model ? (visionOverride(provider, model) ?? catalogRow(model, provider)?.supportsVision) : undefined;
+  const seesImages = readsImages(provider) && vision !== false;
   return { pdfPageMode: seesImages ? 'image' : 'ocr', pdfNativeDocument: nativePdf(provider) };
 }
 

package/src/runtime/agent/orchestrator/session/manager/agent-listing-notice.mjs

@@ -0,0 +1,102 @@
+// manager/agent-listing-notice.mjs
+// The agents a coding Lead may delegate to, kept current without touching the
+// request prefix (the workflow switch's pattern, workflow-switch-notice.mjs).
+// What the conversation was told is read from the conversation itself, every
+// turn: the "# Available Agents" list the system prompt carries (the one the
+// session was built with: a rebuilt prompt keeps it, prompt-utils.mjs
+// presentedAgentCatalogSlice), then each agent list reminder still in
+// `session.messages`, in order (the user turn that carried one records its
+// change as `meta.agentListing`). A turn whose message stays (answered or
+// failed) counts; one rolled back or compacted away does not, so its change is
+// told again. When the agents enabled at this turn's start (resolved by the
+// session runtime, passed in with the turn) differ from that, the turn carries
+// one reminder naming the agents added and removed.
+import { agentListEntries, presentedAgentCatalogSlice, suffixUserTurnReminders } from './prompt-utils.mjs';
+import { stripRuntimeUserContext, withRuntimeUserContext } from '../runtime-user-context.mjs';
+
+/** The agent list the system prompt carries: one complete generated slice of
+ *  the BP3 block, [] when it carries none (or none valid). */
+function promptAgentList(session) {
+  return (session && agentListEntries(presentedAgentCatalogSlice(session) || '')) || [];
+}
+
+const ref = (entry) => ({ id: String(entry.id), name: String(entry.name) });
+
+/** The agents the conversation was told about: the prompt's list, then every
+ *  agent list reminder the conversation still holds, in order. */
+export function announcedAgents(session) {
+  const told = new Map(promptAgentList(session).map((entry) => [entry.id, ref(entry)]));
+  for (const message of Array.isArray(session?.messages) ? session.messages : []) {
+    const change = message?.role === 'user' ? message.meta?.agentListing : null;
+    if (!change) continue;
+    for (const entry of Array.isArray(change.removed) ? change.removed : []) told.delete(entry?.id);
+    for (const entry of Array.isArray(change.added) ? change.added : []) {
+      if (entry?.id) told.set(entry.id, ref(entry));
+    }
+  }
+  return [...told.values()];
+}
+
+function agentListingContent(added, removed, current) {
+  return [
+    '<system-reminder>',
+    '# Available Agents Changed',
+    'This updates the Available Agents list in the system prompt and every earlier Available Agents Changed reminder.',
+    ...(added.length
+      ? ['New agents are now available to delegate to with `agent`:', ...added.map((entry) => entry.line)]
+      : []),
+    ...(removed.length
+      ? [
+          'These agents are no longer available; an `agent` call naming one is refused:',
+          ...removed.map((entry) => `- ${entry.name} (${entry.id})`),
+        ]
+      : []),
+    ...(current.length ? [] : ['No agents are enabled now: do the work yourself until one is enabled.']),
+    '</system-reminder>',
+  ].join('\n');
+}
+
+/**
+ * The agent list reminder this user turn carries, or null when the
+ * conversation already knows `current`, the agents enabled at this turn's
+ * start (`agentListEntries` entries, from the session runtime's ask options;
+ * absent for agent-mode threads and delegated workers: no reminder).
+ * @returns {{ content: string, meta: { added: object[], removed: object[] } } | null}
+ */
+export function buildAgentListingNotice(session, current) {
+  if (!Array.isArray(current)) return null;
+  const announced = announcedAgents(session);
+  const now = new Set(current.map((entry) => entry.id));
+  const told = new Set(announced.map((entry) => entry.id));
+  const added = current.filter((entry) => !told.has(entry.id));
+  const removed = announced.filter((entry) => !now.has(entry.id));
+  if (!added.length && !removed.length) return null;
+  return {
+    content: agentListingContent(added, removed, current),
+    meta: { added: added.map(ref), removed: removed.map(ref) },
+  };
+}
+
+/**
+ * A retained failed turn resubmitted as it was (its own message, its input
+ * untouched) learns what changed since: the reminder joins its runtime
+ * context, and `meta.agentListing` becomes the net change against what the
+ * conversation was told before that message, so later turns read it back as a
+ * normal turn's. `index` is the message's place in `session.messages`.
+ */
+export function withAgentListingNotice(session, index, message, current) {
+  const notice = buildAgentListingNotice(session, current);
+  if (!notice) return message;
+  const before = { ...session, messages: session.messages.filter((_, i) => i !== index) };
+  const net = buildAgentListingNotice(before, current);
+  const { agentListing: _told, ...meta } = message.meta || {};
+  const stripped = stripRuntimeUserContext({ ...message, meta });
+  const owned = stripped.meta?.runtimeUserContext ? null : message.meta?.runtimeUserContext;
+  return withRuntimeUserContext(
+    { ...stripped, meta: { ...stripped.meta, ...(net ? { agentListing: net.meta } : {}) } },
+    {
+      prefix: owned?.prefix || '',
+      suffix: `${owned?.suffix || ''}${suffixUserTurnReminders('', notice.content)}`,
+    }
+  );
+}

package/src/runtime/agent/orchestrator/session/manager/ask-queue.mjs

@@ -34,6 +34,7 @@ const promptSourceFields = (source, execution) => {
 const tailTurnFor = (group) => ({
   content: group.content,
   entries: group.entries,
+  ...(group.hop ? { hop: group.hop } : {}),
   ...(group.mode === PENDING_MODE_TASK_NOTIFICATION
     ? promptSourceFields(PENDING_MODE_TASK_NOTIFICATION, group.execution)
     : {}),
@@ -46,6 +47,7 @@ const queuedTurnInput = (tailTurn) => ({
   context: null,
   explicitPrefetch: null,
   pendingEntries: tailTurn.entries,
+  ...(tailTurn.hop ? { hop: tailTurn.hop } : {}),
   promptSource: promptSourceFields(tailTurn.source, tailTurn.execution),
 });
 

package/src/runtime/agent/orchestrator/session/manager/ask-session.mjs

@@ -84,7 +84,19 @@ async function runAskTurn({ sessionId, opened, input, askOpts, onToolCall, cwdOv
       cwdOverride || opened.turn.session.cwd || process.cwd(),
       opened.runtime.controller?.signal
     );
-    const prepared = await prepareAskTurn({ sessionId, opened, input, cwdOverride, transcriptMeta: transcript.user });
+    const prepared = await prepareAskTurn({
+      sessionId,
+      opened,
+      input,
+      cwdOverride,
+      // A task notification resumes the bot-chain hop of the turn that launched its work.
+      transcriptMeta: input.hop ? { ...transcript.user, hop: input.hop } : transcript.user,
+      // The agents enabled as this user turn is prepared (the session
+      // runtime's resolver; coding Leads): the agent list reminder compares
+      // them with what the model was told. Asked again for every user turn
+      // the ask runs, queued and background follow-ups included.
+      currentAgents: askOpts?.agentsNow?.(),
+    });
     const result = await runAskAgentLoop({
       sessionId,
       opened,

package/src/runtime/agent/orchestrator/session/manager/ask-turn-execute.mjs

@@ -15,6 +15,7 @@ import { filterModelVisibleSessionMessages } from './message-sanitize.mjs';
 import { _getAgentLoop } from './runtime-loaders.mjs';
 import { runAbortable, throwIfAborted } from '../../../../shared/abort-race.mjs';
 import { applyTurnContextMeta, buildUserTurn, startProviderPrewarm, traceTurnContext } from './ask-turn-prepare.mjs';
+import { withAgentListingNotice } from './agent-listing-notice.mjs';
 import { retainedFailedTurnInput, rewindUnansweredPrompt } from './failed-turn-rewind.mjs';
 import { buildAgentLoopOptions, trackedToolCallHook } from './ask-turn-loop-options.mjs';
 import { _api_call_with_interrupt } from './ask-call-interrupt.mjs';
@@ -23,11 +24,11 @@ import { stampTurnHop } from '../../../../shared/bot-hops.mjs';
 
 /** Resolves the provider, builds the user turn and pre-commits it; returns
  *  what the loop and the commit need from this preparation. */
-export async function prepareAskTurn({ sessionId, opened, input, cwdOverride, transcriptMeta }) {
+export async function prepareAskTurn({ sessionId, opened, input, cwdOverride, transcriptMeta, currentAgents }) {
   const { turn, runtime, turnSignal, askGeneration, checkpoint, turnToken, startedAt, codexTurnId } = opened;
   const session = turn.session;
   // Where the turn sits in a bot-to-bot chain (session-runtime/bot-hops.mjs).
-  stampTurnHop(session, transcriptMeta, input.promptSource);
+  stampTurnHop(session, transcriptMeta);
   const retained = input.retryTurnId
     ? retainedFailedTurnInput(session.messages, input.retryTurnId, input.retryAttemptId)
     : null;
@@ -71,21 +72,28 @@ export async function prepareAskTurn({ sessionId, opened, input, cwdOverride, tr
       ? (() => {
           const historyMessages = filterModelVisibleSessionMessages(session.messages.slice(0, retained.index));
           const { completion, ...previousTranscript } = retained.message.meta.transcript;
-          const userTurnMessage = {
-            ...retained.message,
-            meta: {
-              ...retained.message.meta,
-              transcript: {
-                ...previousTranscript,
-                ...transcriptMeta,
-                messageId: previousTranscript.messageId,
-                previousCompletions: [
-                  ...(previousTranscript.previousCompletions || []),
-                  { ...completion, at: completion.at ?? previousTranscript.at },
-                ],
+          // The retained message keeps its input; agents enabled or switched
+          // off since it was built ride its runtime context.
+          const userTurnMessage = withAgentListingNotice(
+            session,
+            retained.index,
+            {
+              ...retained.message,
+              meta: {
+                ...retained.message.meta,
+                transcript: {
+                  ...previousTranscript,
+                  ...transcriptMeta,
+                  messageId: previousTranscript.messageId,
+                  previousCompletions: [
+                    ...(previousTranscript.previousCompletions || []),
+                    { ...completion, at: completion.at ?? previousTranscript.at },
+                  ],
+                },
               },
             },
-          };
+            currentAgents
+          );
           return { historyMessages, userTurnMessage, outgoing: [...historyMessages, userTurnMessage] };
         })()
       : buildUserTurn({
@@ -97,6 +105,7 @@ export async function prepareAskTurn({ sessionId, opened, input, cwdOverride, tr
           transcriptMeta,
           turnPromptSource: input.promptSource,
           effortConfiguration: null,
+          currentAgents,
         }),
     wireRoutePending,
   ]);

package/src/runtime/agent/orchestrator/session/manager/ask-turn-prepare.mjs

@@ -21,6 +21,7 @@ import {
 } from './prompt-utils.mjs';
 import { snapshotPendingWorkflowNotice } from './workflow-switch-notice.mjs';
 import { snapshotPendingOrchestrationModeNotice } from './orchestration-mode-switch-notice.mjs';
+import { buildAgentListingNotice } from './agent-listing-notice.mjs';
 import { codexWireSendOpts } from './session-id.mjs';
 import { _tryBridgeExplicitPrefetch } from './prefetch-bridge.mjs';
 import { filterModelVisibleSessionMessages } from './message-sanitize.mjs';
@@ -150,6 +151,7 @@ export async function buildUserTurn({
   transcriptMeta,
   turnPromptSource,
   effortConfiguration,
+  currentAgents,
 }) {
   const explicitPrefetchResult = await _tryBridgeExplicitPrefetch(session, explicitPrefetch, turnSignal);
   let contextBlock = '';
@@ -188,9 +190,12 @@ export async function buildUserTurn({
   // A mid-conversation orchestration mode switch, after the workflow notice
   // so the mode it names wins over the one a workflow reminder carries.
   const orchestrationModeNotice = snapshotPendingOrchestrationModeNotice(session);
+  // Agents enabled or switched off since the conversation was last told.
+  const agentListingNotice = buildAgentListingNotice(session, currentAgents);
   const reminderBlock = [
     workflowNotice?.content || '',
     orchestrationModeNotice?.content || '',
+    agentListingNotice?.content || '',
     workspaceNotice?.content || '',
     setupNotice?.content || '',
     currentTimeBlock ? `<system-reminder>\n# Current Time\n${currentTimeBlock}\n</system-reminder>` : '',
@@ -205,6 +210,8 @@ export async function buildUserTurn({
     ...(transcriptMeta ? { transcript: transcriptMeta } : {}),
     ...(turnPromptSource || {}),
     ...(effortConfiguration ? { effortConfiguration } : {}),
+    // What its reminder told, read back by later turns (agent-listing-notice.mjs).
+    ...(agentListingNotice ? { agentListing: agentListingNotice.meta } : {}),
   };
   const userTurnMessage = withRuntimeUserContext(
     {
@@ -221,6 +228,7 @@ export async function buildUserTurn({
     goalReminder,
     workflowNotice,
     orchestrationModeNotice,
+    agentListingNotice,
     workspaceNotice,
     setupNotice,
     userTurnMessage,

package/src/runtime/agent/orchestrator/session/manager/ask-turn-steering-drain.mjs

@@ -59,6 +59,7 @@ export function createAskSteeringDrain({ sessionId, turn, askOpts }) {
               ids: group.ids,
               mode: group.mode,
               ...(group.execution ? { execution: group.execution } : {}),
+              ...(group.hop ? { transcriptMeta: { hop: group.hop } } : {}),
             });
           }
         } else {