mixdog 1.2.2 → 1.2.4

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

@@ -7,7 +7,7 @@ import { getProvider } from '../../providers/registry.mjs';
 import { invalidateContextUsageSnapshot, invalidateProviderContextBaseline } from '../loop/compact-policy.mjs';
 import { saveSession, saveSessionAsync, saveSessionAsyncDeferred, loadSession, setLiveSession } from '../store.mjs';
 import { _liveSessions } from '../store/live-state.mjs';
-import { _isActivelyOwnedElsewhere, _recoverTurnCheckpointDurably } from './session-owner-liveness.mjs';
+import { _recoverTurnCheckpointDurably } from './turn-checkpoint-recovery.mjs';
 import { isAgentOwner } from '../../agent-owner.mjs';
 import { getHiddenAgent } from '../../internal-agents.mjs';
 import { loadConfig } from '../../config.mjs';
@@ -37,13 +37,15 @@ import { getAgentRuntimeSync, warnAgentRuntimeResolveFailureOnce } from './agent
 import { ensureCodexWireSessionId, mintSessionId } from './session-id.mjs';
 import { providerCacheKey } from './provider-cache-key.mjs';
 import { buildSessionRecord, normalizeDesktopSessionMetadata, sessionOriginFields } from './session-record.mjs';
-import { refreshSessionBp3Environment } from './prompt-utils.mjs';
+import { normalizeWorkflowRoute } from '../../runtime-core/workflow.mjs';
+import { applyPendingWorkspaceReroot, refreshSessionBp3Environment } from './prompt-utils.mjs';
 import { isWorktreeBound } from '../../../../shared/worktrees/contract.mjs';
+import { applyAgentToolExposure } from '../loop/tool-exposure-migration.mjs';
+import { prewarmSessionAutoEffort } from './ask-turn-auto-effort.mjs';
 
-// Owner liveness (attach-on-resume guard) and the durable turn-checkpoint
-// recovery it gates; re-exported so prior importers of this module stay
-// unchanged.
-export { isSessionOwnerGone, recoverSessionAfterProcessRestart } from './session-owner-liveness.mjs';
+// Durable turn-checkpoint recovery; re-exported so prior importers of this
+// module stay unchanged.
+export { recoverSessionAfterProcessRestart } from './turn-checkpoint-recovery.mjs';
 // Prepared-surface cache warmers (desktop hover prefetch, pane projection);
 // re-exported so prior importers of this module stay unchanged.
 export { prefetchSession, prepareSessionProjection } from './prepared-resume-cache.mjs';
@@ -210,6 +212,11 @@ export function createSession(opts) {
   const { profile } = resolved;
   const route = resolveSessionRoute(opts, presetObj, profile);
   const { providerName, modelName, provider, toolPreset, id } = route;
+  const routeFallbacks = normalizeWorkflowRoute({
+    provider: providerName,
+    model: modelName,
+    fallbacks: Object.hasOwn(opts, 'routeFallbacks') ? opts.routeFallbacks : presetObj?.fallbacks,
+  })?.fallbacks;
   // Provider cache strategy — agentRuntime.resolveSync() above is a
   // best-effort injection point (setAgentRuntime() has no live caller
   // today, so that branch never fires); build it directly here so every
@@ -217,11 +224,7 @@ export function createSession(opts) {
   // 'lead', or no agent at all — raw/CLI callers) get their BP4 message
   // tail TTL linked to the user's autoClear idle-sweep config; hidden and
   // public agents keep the flat 5m default (see cache-strategy.mjs docs).
-  // Scoped to explicit-breakpoint (Anthropic-family) providers only — the
-  // non-Anthropic branches of buildProviderCacheOpts (e.g. the 'openai'
-  // cacheRetention:'24h' shape) were never exercised by createSession
-  // before this change, and are left untouched to avoid altering live
-  // OpenAI/other-provider request shape as a side effect of this fix.
+  // Scoped to explicit-breakpoint (Anthropic-family) providers only.
   const providerCacheOpts = resolved.providerCacheOpts || buildSessionProviderCacheOpts(providerName, id, opts.agent);
   const surface = resolveSessionToolSurface(opts, { profile, toolPreset, modelName });
   const prompt = composeSessionSystem(opts, { profile, providerName, modelName, surface });
@@ -243,11 +246,15 @@ export function createSession(opts) {
     origin: sessionOriginFields(opts, { profile, presetObj, providerCacheOpts, surface }),
   });
   session.providerCacheOptsOverride = Boolean(resolved.providerCacheOpts);
+  if (routeFallbacks?.length) session.routeFallbacks = routeFallbacks;
+  // A non-native agent sends core + bridge, built from its filtered tools.
+  applyAgentToolExposure(session);
   refreshSessionBp3Environment(session, opts.cwd);
   // In-process registry + async debounced save: same-process create → load
   // reads live memory; disk flush is for cross-process / restart durability.
   setLiveSession(session);
   saveSession(session);
+  prewarmSessionAutoEffort(session, provider);
   return session;
 }
 
@@ -367,6 +374,11 @@ function resetSessionForRouteChange(id, session, previousModel, previousProvider
   session.lastContextTokensUpdatedAt = Date.now();
   session.lastContextTokensStaleAfterCompact = false;
   session.providerState = undefined;
+  // The previous route's prefix snapshot measured another prompt (model line,
+  // stripped replay); the new chain baselines on its first send.
+  delete session._providerPrefixGuardState;
+  // The new route resolves its own wire before its first request.
+  session.wireRoute = null;
   const prepared = _prepareResumeTools(session, session.preset || 'full');
   session.tools = prepared.tools;
   session.toolSpec = prepared.toolSpec;
@@ -384,6 +396,7 @@ function resetSessionForRouteChange(id, session, previousModel, previousProvider
   ]) {
     if (Array.isArray(session[key])) session[key] = filterModelEditToolNames(session[key], session.model);
   }
+  applyAgentToolExposure(session, { existing: true });
   _refreshSessionRuleVariantsForModel(session, previousModel, previousProvider);
   _forgetPreparedResume(id);
 }
@@ -436,6 +449,9 @@ export function updateSessionRoute(id, route = {}, options = {}) {
   // route and set sessionStartMetaInjected, so the ask-time refresh guard
   // skips it and an empty-session route change would otherwise keep the old
   // model line in the system prompt (model self-identity confusion).
+  // A new route starts a cold cache: a staged working-folder change re-roots
+  // the prompt now instead of riding a notice.
+  if (routeChanged) applyPendingWorkspaceReroot(session);
   refreshSessionBp3Environment(session, session.cwd);
   session.updatedAt = Date.now();
   setLiveSession(session);
@@ -448,9 +464,8 @@ export function updateSessionRoute(id, route = {}, options = {}) {
 }
 
 // --- resume (reload tools for a stored session) ---
-// Whether another live process is driving the session (and therefore whether
-// this resume attaches as a viewer) is decided by session-owner-liveness.mjs;
-// the prepared tool surface it consumes is cached in prepared-resume-cache.mjs.
+// Interrupted-turn recovery lives in turn-checkpoint-recovery.mjs; the
+// prepared tool surface it consumes is cached in prepared-resume-cache.mjs.
 
 // Desktop callers pass their selected durable classification as a
 // capability check. Refuse a stale/tampered cross-class resume before any
@@ -484,25 +499,6 @@ function _applyDesktopResumeScope(session, options) {
   return true;
 }
 
-// ATTACH (viewer mode, zero ownership): hand back the live transcript
-// under the SAME id, flagged remoteAttached. No tool refresh, no save,
-// no generation claim — the session file remains exclusively the
-// owner's. session-turn-api routes this surface's submits into the
-// shared pending spool instead of running a local turn.
-function _attachViewerSession(session, sessionId) {
-  const attached = { ...session, remoteAttached: true };
-  delete attached.liveTurnMessages;
-  delete attached.toolApprovalHook;
-  if (process.env.MIXDOG_DEBUG_SESSION_LOG) {
-    try {
-      process.stderr.write(`[session] attach-on-resume: ${sessionId} is live elsewhere → viewer attach\n`);
-    } catch {
-      /* best-effort */
-    }
-  }
-  return attached;
-}
-
 // Refreshes the session's tool surface from the prepared resume when it still
 // matches, warning about tools the preset no longer offers.
 function _refreshResumedTools(session, sessionId, preset) {
@@ -513,7 +509,12 @@ function _refreshResumedTools(session, sessionId, preset) {
   // Keep the persisted tool mode in sync on resume (see createSession note).
   session.toolSpec = prepared.toolSpec;
   session.tools = prepared.tools;
-  const missing = oldTools.filter((t) => !session.tools.find((n) => n.name === t.name));
+  applyAgentToolExposure(session, { existing: true });
+  // A bridge surface keeps the rest of its tools in the catalog.
+  const available = new Set(
+    [...session.tools, ...(session.deferredToolCatalog || [])].map((tool) => tool?.name).filter(Boolean)
+  );
+  const missing = oldTools.filter((t) => !available.has(t.name));
   if (missing.length) {
     process.stderr.write(
       `[session] Warning: ${missing.length} tools no longer available: ${missing.map((t) => t.name).join(', ')}\n`
@@ -534,7 +535,6 @@ export async function resumeSession(sessionId, preset, options = {}) {
   if (Object.hasOwn(options, 'mcpScopeId')) {
     session.mcpScopeId = String(options.mcpScopeId || '').trim() || null;
   }
-  if (_isActivelyOwnedElsewhere(session, sessionId)) return _attachViewerSession(session, sessionId);
   _recoverTurnCheckpointDurably(session, sessionId);
   _refreshResumedTools(session, sessionId, preset);
   refreshSessionProviderCacheOpts(session);
@@ -546,5 +546,6 @@ export async function resumeSession(sessionId, preset, options = {}) {
       process.stderr.write(`[session] resume save failed: ${err?.message || err}\n`);
     } catch {}
   });
+  prewarmSessionAutoEffort(session, session.provider ? getProvider(session.provider) : null);
   return session;
 }

package/src/runtime/agent/orchestrator/session/manager/session-prompt-composition.mjs

@@ -18,6 +18,7 @@ import {
 } from '../../tools/builtin/runtime-capabilities.mjs';
 import { captureOriginalUserCwd } from '../../../../shared/user-cwd.mjs';
 import { delegationDisabled } from './session-tool-surface.mjs';
+import { contextAckMessage } from '../compact/user-message-kind.mjs';
 
 // Preserve the exact pre-layout environment payload: Lead carried the
 // shell preference in Profile Preferences, while any routing surface with
@@ -89,6 +90,23 @@ export function buildWorkspacePromptContext(session, cwd) {
 
 // BP1/BP2/BP3 rule blocks plus the volatile environment, composed into the
 // four system blocks; environmentTailContext is the persisted env tail.
+export function sessionRolePromptFields(identity, { ownerIsAgent, toolFreeRole, delegationFree }) {
+  const skipRules = identity.skipAgentRules || toolFreeRole;
+  let roleRules = '';
+  if (!skipRules) {
+    roleRules = ownerIsAgent
+      ? _buildAgentRules(identity.agentRulesProfile)
+      : _buildLeadRules({ includeLeadBrief: !delegationFree });
+  }
+  return {
+    roleRules,
+    userPrompt: identity.systemPrompt,
+    skipRoleCatalog: !ownerIsAgent,
+    agent: identity.agent,
+    profile: { skip: identity.profileSkip },
+  };
+}
+
 export function composeSessionSystem(opts, { profile, providerName, modelName, surface }) {
   const { ownerIsAgent, resolvedAgent, skills } = surface;
   // A tool-free hidden role (a one-shot classifier or title writer) carries
@@ -105,12 +123,14 @@ export function composeSessionSystem(opts, { profile, providerName, modelName, s
         model: modelName,
       });
   const delegationFree = delegationDisabled(opts, ownerIsAgent);
-  let roleRules = '';
-  if (!skipAgentRules) {
-    roleRules = ownerIsAgent
-      ? _buildAgentRules(surface.agentRulesProfile)
-      : _buildLeadRules({ includeLeadBrief: !delegationFree });
-  }
+  const promptIdentity = {
+    systemPrompt: opts.systemPrompt || '',
+    skipAgentRules: opts.skipAgentRules === true,
+    profileSkip: { ...profile?.skip },
+    agent: resolvedAgent,
+    agentRulesProfile: surface.agentRulesProfile,
+  };
+  const roleFields = sessionRolePromptFields(promptIdentity, { ownerIsAgent, toolFreeRole, delegationFree });
   const leadOnly = !skipAgentRules && !ownerIsAgent;
   const metaContext = leadOnly ? _buildLeadMetaContext() : '';
   // Lead-only response language; closes the environment block so no English
@@ -132,14 +152,10 @@ export function composeSessionSystem(opts, { profile, providerName, modelName, s
       ? ''
       : loadInstructionFilesContext({ mode: configuredInstructionFilesMode(), cwd: opts.cwd });
   const composed = composeSystemPrompt({
-    userPrompt: opts.systemPrompt,
+    ...roleFields,
     agentRules: injectedRules || undefined,
-    roleRules: roleRules || undefined,
     metaContext: metaContext || undefined,
     languageContext: languageContext || undefined,
-    skipRoleCatalog: !ownerIsAgent,
-    profile: profile || undefined,
-    agent: resolvedAgent,
     workflowContext: opts.workflowContext || null,
     coreMemoryContext: opts.coreMemoryContext || null,
     instructionFilesContext: instructionFilesContext || null,
@@ -147,7 +163,7 @@ export function composeSessionSystem(opts, { profile, providerName, modelName, s
     environmentContext: shellEnvironmentContext,
     provider: providerName || null,
   });
-  return { ...composed, environmentTailContext };
+  return { ...composed, environmentTailContext, promptIdentity };
 }
 
 // 4-BP layout (see composeSystemPrompt docs):
@@ -188,7 +204,7 @@ export function seedSessionMessages({ baseRules, stableSystemContext, sessionMar
   if (files?.length) {
     const fileContext = files.map((f) => `### ${f.path}\n\`\`\`\n${f.content}\n\`\`\``).join('\n\n');
     messages.push({ role: 'user', content: `Reference files:\n\n${fileContext}` });
-    messages.push({ role: 'assistant', content: '.' });
+    messages.push(contextAckMessage());
   }
   return messages;
 }

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

@@ -109,6 +109,9 @@ export function buildSessionRecord({ opts, route, presetObj, surface, prompt, me
     codexWireSessionId: providerName === 'openai-oauth' ? mintUuidV7() : null,
     provider: providerName,
     model: modelName,
+    // Resolved and pinned before the first request (wire-route.mjs). null —
+    // not absent — marks a session created under the per-model wire table.
+    wireRoute: null,
     messages,
     contextWindow: contextMeta.contextWindow,
     rawContextWindow: contextMeta.rawContextWindow,
@@ -135,6 +138,8 @@ export function buildSessionRecord({ opts, route, presetObj, surface, prompt, me
     agent: opts.agent,
     owner: opts.owner || 'user',
     bp3CoreContext: prompt.sessionMarkerCore,
+    promptIdentity: prompt.promptIdentity,
+    callerDisallowedTools: [...(opts.callerDisallowedTools ?? opts.disallowedTools ?? [])],
     bp3EnvironmentContext: prompt.environmentTailContext,
     // BP3 core and the volatile environment live in SEPARATE system
     // blocks (cacheTier 'tier3' vs 'env'). Legacy persisted sessions
@@ -159,9 +164,7 @@ export function buildSessionRecord({ opts, route, presetObj, surface, prompt, me
     totalInputTokens: 0,
     totalOutputTokens: 0,
     totalToolCalls: 0,
-    // Refreshed on each completed ask() — surfaced by agent type=list for
-    // debugging + consumed by store.mjs's idle-sweep to reclaim stalled
-    // agent sessions past RUNNING_STALL_MS.
+    // Refreshed on each completed ask() — surfaced by agent type=list.
     lastUsedAt: Date.now(),
     tokensCumulative: 0,
     ...origin,

package/src/runtime/agent/orchestrator/session/manager/tool-resolution.mjs

@@ -48,6 +48,9 @@ const SESSION_ROUTE_TOOL_RANK = new Map(
 const FILESYSTEM_TOOL_NAMES = new Set(['code_graph', 'find', 'glob', 'list', 'grep', 'read', 'edit', 'apply_patch']);
 const READONLY_FS_TOOL_NAMES = new Set(['code_graph', 'find', 'glob', 'list', 'grep', 'read']);
 
+// Lead-only control tools: never part of a worker/sub-agent session surface.
+export const AGENT_WORKER_DENIED_TOOLS = Object.freeze(new Set(['agent', 'ask_user', 'session']));
+
 export function finalizeSessionToolList(
   tools,
   { schemaAllowedTools = null, disallowedTools = null, ownerIsAgent = false } = {}
@@ -64,7 +67,7 @@ export function finalizeSessionToolList(
     out = out.filter((t) => !denySet.has(String(t?.name || '').toLowerCase()));
   }
   if (ownerIsAgent) {
-    out = out.filter((t) => String(t?.name || '').toLowerCase() !== 'agent');
+    out = out.filter((t) => !AGENT_WORKER_DENIED_TOOLS.has(String(t?.name || '').toLowerCase()));
     out = orderSessionTools(out);
   }
   return out;

package/src/runtime/agent/orchestrator/session/manager/turn-checkpoint-recovery.mjs

@@ -0,0 +1,45 @@
+// manager/turn-checkpoint-recovery.mjs
+// Durable recovery of a turn interrupted by a process restart: an interrupted
+// turn checkpoint is committed as interrupted on resume. Every session runs in
+// the daemon, so a turn is live while this process runs it or while another
+// live process owns the daemon; reads never recover a live turn.
+import { join } from 'node:path';
+import { readSingletonOwner } from '../../../../shared/singleton-owner.mjs';
+import { loadSession, saveSession } from '../store.mjs';
+import { dataDir } from '../store-summary-locations.mjs';
+import { runtimeState, isTurnInFlight } from './runtime-state.mjs';
+import { clearTurnCheckpoint, recoverTurnCheckpoint } from './turn-checkpoint.mjs';
+
+/** Whether this session's turn may still be running: in flight in this
+ *  process, or owned by another live process holding the daemon record. */
+export function isSessionTurnLive(sessionId) {
+  if (isTurnInFlight(runtimeState.get(sessionId))) return true;
+  const { owner, alive } = readSingletonOwner(join(dataDir(), 'daemon-owner.json'));
+  return alive && Number(owner.pid) !== process.pid;
+}
+
+export function _recoverTurnCheckpointDurably(session, sessionId) {
+  const recovery = recoverTurnCheckpoint(session);
+  if (!recovery.changed) return recovery;
+  // Recovery is a durable reconnect boundary, not a renderer-only view.
+  // Persist before removing the checkpoint so a second crash leaves at
+  // least one complete copy of the interrupted turn.
+  saveSession(session, {
+    sync: true,
+    expectedGeneration: session.generation,
+  });
+  if (recovery.turnToken) {
+    clearTurnCheckpoint(sessionId, recovery.turnToken);
+  }
+  return recovery;
+}
+
+// Reconnect-safe historical read used by desktop pane peeks. Unlike a normal
+// read-only load, it resolves a dead owner's durable turn checkpoint before
+// returning the transcript; a live turn is returned untouched.
+export function recoverSessionAfterProcessRestart(sessionId) {
+  const session = loadSession(sessionId);
+  if (!session || session.closed === true || isSessionTurnLive(sessionId)) return session || null;
+  _recoverTurnCheckpointDurably(session, sessionId);
+  return session;
+}

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

@@ -2,7 +2,7 @@
 // Thin facade over the split session-manager modules in ./manager/.
 //
 // Module map:
-//   manager/runtime-liveness.mjs       — in-memory stage/heartbeat + accessors
+//   manager/runtime-liveness.mjs       — in-memory stage/progress + accessors
 //   manager/tool-resolution.mjs        — tool policy resolution/narrowing
 //   manager/context-meta.mjs           — context-window / compact-trigger meta
 //   manager/prompt-utils.mjs           — prompt content shaping helpers
@@ -45,6 +45,7 @@ export {
   markSessionError,
   markSessionCancelled,
   getSessionRuntime,
+  isSessionTurnInFlight,
   isSessionCompactionBlocked,
   getSessionProgressSnapshot,
   forEachSessionRuntime,
@@ -59,19 +60,12 @@ export { previewSessionTools } from './manager/tool-resolution.mjs';
 export {
   _mergePendingMessageEntries,
   enqueuePendingMessage,
-  enqueueRemotePendingMessage,
-  drainForeignUserInjections,
   drainPendingMessages,
   // Shutdown drain so buffered/in-flight spool writes are never abandoned.
   settlePendingMessageWrites,
   markCompletionEntry,
   COMPLETION_NOTIFICATION_KIND,
-  pendingMessagesSpoolPath,
 } from './manager/pending-messages.mjs';
-// Interactive-presence sidecar (idle-open ownership signal for the
-// attach-on-resume guard) — resolved through the manager facade so the
-// session-runtime turn API reaches it as mgr.publishSessionPresence.
-export { publishSessionPresence, deleteSessionPresence } from './store.mjs';
 
 // ── Usage-metrics surface — re-exported unchanged so loop.mjs / smoke scripts
 //    keep resolving these through the facade. ────────────────────────────────
@@ -105,7 +99,6 @@ export {
   prefetchSession,
   prepareSessionProjection,
   resumeSession,
-  isSessionOwnerGone,
   recoverSessionAfterProcessRestart,
 } from './manager/session-lifecycle.mjs';
 export { askSession, _api_call_with_interrupt } from './manager/ask-session.mjs';
@@ -123,9 +116,10 @@ export {
   updateSessionStatus,
   updateSessionGeneratedTitle,
   updateSessionManualTitle,
+  updateSessionAiTitle,
   flushSessionMetrics,
 } from './manager/session-crud.mjs';
-export { deleteSession, listOwnedAgentSessionIds } from './store.mjs';
+export { deleteSession, listOwnedAgentSessionIds, fenceSessionWrites } from './store.mjs';
 // Read-only parsed-session access (desktop pane peek): no resume, no
 // ownership, no liveness side effects.
 export { loadSession } from './store.mjs';

package/src/runtime/agent/orchestrator/session/pre-send-compact.mjs

@@ -31,6 +31,8 @@ import { bumpUsageMetricsEpoch } from './manager/usage-metrics.mjs';
 import { resetReadStateAfterCompaction } from './read-dedup.mjs';
 import { scheduleCompactionArchive, stampCompactionMessageIds } from './compaction-archive-capture.mjs';
 import { writeStderrBestEffort } from '../../../shared/best-effort-stderr.mjs';
+import { applyPendingWorkspaceReroot } from './manager/prompt-utils.mjs';
+import { backfillFallbackSessionTitle } from './manager/session-fallback-title.mjs';
 import {
   acknowledgePendingGoalReminder,
   markPendingGoalReminder,
@@ -378,6 +380,7 @@ function adoptCompactedTranscript(ctx, run) {
   const { state } = ctx;
   const { messages, sessionRef, sessionId, opts } = state;
   const replaced = messages.slice();
+  if (sessionRef) backfillFallbackSessionTitle(sessionRef, replaced);
   messages.length = 0;
   messages.push(...run.compacted);
   // Display-only archive of the dropped conversation; the projection and the
@@ -388,6 +391,9 @@ function adoptCompactedTranscript(ctx, run) {
   ctx.droppedMessages = archived?.dropped ?? 0;
   ctx.droppedIdentities = archived?.identities ?? null;
   acknowledgeGoalReminder(sessionRef, run);
+  // The compacted transcript breaks the cache anyway: a staged working-folder
+  // change re-roots the system prompt now and needs no notice any more.
+  if (sessionRef) applyPendingWorkspaceReroot(sessionRef, messages);
   resetReadStateAfterCompaction(sessionId);
   // Cross-turn receipts reference tool results that compaction just removed
   // from context; a stub for them would point at nothing. Clear in place so

package/src/runtime/agent/orchestrator/session/send-instrumentation.mjs

@@ -3,6 +3,7 @@
 // wrappers are installed on the caller's opts in place for ONE send, and the
 // returned restore unwinds only our own wrappers.
 import { isVisibleStreamProgress } from '../../../shared/stream-progress.mjs';
+import { MODEL_THINKING_STAGE } from '../../../shared/quiet-progress.mjs';
 
 // Bench-only turn timing (MIXDOG_TURN_TIMING=1): one stderr line per
 // provider request — TTFT (first visible model progress) and total stream
@@ -61,7 +62,7 @@ function retryVisibilityWrappers(opts, timedOpts, retryAttemptNumber, retryMaxFo
   if (!(retryAttemptNumber > 0 && prevOnStageChange)) return wrappers;
   let progressObserved = false;
   wrappers.onStageChange = (stage, detail) => {
-    if (!progressObserved && (stage === 'requesting' || stage === 'streaming')) {
+    if (!progressObserved && (stage === 'requesting' || stage === 'streaming' || stage === MODEL_THINKING_STAGE)) {
       return prevOnStageChange('reconnecting', {
         ...(detail && typeof detail === 'object' ? detail : {}),
         attempt: retryAttemptNumber,

package/src/runtime/agent/orchestrator/session/send-with-recovery.mjs

@@ -37,13 +37,14 @@ import {
   isThinkingReplayRejection,
   repairThinkingReplayInPlace,
 } from './thinking-replay-recovery.mjs';
-import { readStreamOutcome } from '../providers/lib/stream-outcome.mjs';
+import { readStreamOutcome, stampStreamOutcome } from '../providers/lib/stream-outcome.mjs';
 import { cloneProviderReplay } from '../providers/lib/provider-replay.mjs';
 import { resolveWorkerCompactPolicy } from './loop/compact-policy.mjs';
 import { agentContextOverflowError } from './loop/context-overflow.mjs';
 import { estimateMessagesTokensSafe } from './loop/compact-debug.mjs';
 import { isOutputLimitStopReason } from './loop/termination.mjs';
 import { instrumentSendCallbacks } from './send-instrumentation.mjs';
+import { rejectedToolSchema } from './tool-schema-rejection.mjs';
 
 function normalizedIncompleteUsage(raw) {
   if (!raw || typeof raw !== 'object') return undefined;
@@ -259,6 +260,7 @@ export async function sendWithRecovery(ctx) {
       hooks.logTurnTiming('ok');
     } catch (sendErr) {
       hooks.logTurnTiming(`err:${sendErr?.code || sendErr?.name || 'unknown'}`);
+      stampStreamOutcome(sendErr, hooks.relayWitness);
       return await recoverFromSendError(sendErr, { ...ctx, relayWitness: hooks.relayWitness });
     }
     return { action: 'proceed', response };
@@ -405,6 +407,7 @@ async function recoverFromSendError(sendErr, state) {
     transportRetriesUsed = 0,
     imageStripUsed = false,
     thinkingReplayRepairUsed = false,
+    toolSchemaDropUsed = false,
     relayWitness,
   } = state;
   const outcome = readStreamOutcome(sendErr, relayWitness);
@@ -446,6 +449,19 @@ async function recoverFromSendError(sendErr, state) {
   ) {
     return retryTransport(sendErr, state);
   }
+  // A 400 naming one tool's input schema: the session drops that tool (with
+  // the notice) and the turn is replayed once without it. Nothing was
+  // generated, and the same body would fail every later turn.
+  if (toolSchemaDropUsed !== true) {
+    const exclusion = rejectedToolSchema(sendErr, state);
+    if (exclusion) {
+      logLoop(
+        `[loop] provider rejected tool schema "${exclusion.name}" (${loopTag(state)}); dropping it and replaying once`
+      );
+      traceLoop(state, 'tool_schema_drop', { tool: exclusion.name });
+      return { action: 'retry_tool_schema_drop', exclusion };
+    }
+  }
   // Anthropic replay-shape refusal: the latest assistant turn carries
   // thinking blocks the API will not accept back (a thinking run it did not
   // produce, or an empty text block). This is deterministic — the same body

package/src/runtime/agent/orchestrator/session/side-question-store.mjs

@@ -0,0 +1,96 @@
+// side-question-store.mjs — the in-memory state behind /btw side questions:
+// per session, the latest provider request the main loop sent (the request a
+// side question forks) and the side question in flight. It holds live
+// provider/tool objects, so it never reaches the session record or disk.
+import { isAgentOwner } from '../agent-owner.mjs';
+
+// sessionId -> { provider, model, messages, tools, opts, response }
+const requests = new Map();
+// sessionId -> AbortController of the side question in flight.
+const inFlight = new Map();
+
+// Send options that steer the live loop rather than shape the request: its
+// abort signal, a one-shot cache-break trace tag and the per-request stall
+// budget. A forced tool choice is dropped too (a side question must be able
+// to answer in text); the hard-cap `none` choice is kept.
+const LOOP_ONLY_OPTIONS = new Set(['signal', 'cacheBreakIntent', '_stallRetryBudget', 'toolChoice']);
+
+function requestOptions(opts) {
+  const out = {};
+  for (const [key, value] of Object.entries(opts || {})) {
+    if (typeof value === 'function' || LOOP_ONLY_OPTIONS.has(key)) continue;
+    out[key] = value;
+  }
+  if (opts?.toolChoice === 'none') out.toolChoice = 'none';
+  return out;
+}
+
+/** A request in the stored shape: its own message list and only the send
+ *  options a fork may reuse. `response` is null until the reply settles. */
+export function sideQuestionRequestSnapshot({ provider, model, messages, tools, opts }) {
+  return {
+    provider,
+    model,
+    messages: [...messages],
+    tools: Array.isArray(tools) ? tools : [],
+    opts: requestOptions(opts),
+    response: null,
+  };
+}
+
+/**
+ * Record a provider request the main loop is sending as the session's latest
+ * one. Agent sessions record nothing (/btw is a Lead command). The handle
+ * attaches the reply once the send proceeds, or puts the previous request
+ * back when this one fails, so only a successfully sent request is kept.
+ */
+export function captureSideQuestionRequest({ sessionId, sessionRef, provider, model, messages, tools, opts }) {
+  if (!sessionId || !provider || isAgentOwner(sessionRef)) return null;
+  const previous = requests.get(sessionId);
+  const request = sideQuestionRequestSnapshot({ provider, model, messages, tools, opts });
+  requests.set(sessionId, request);
+  return {
+    settle(response) {
+      request.response = response || null;
+    },
+    discard() {
+      if (requests.get(sessionId) !== request) return;
+      if (previous) requests.set(sessionId, previous);
+      else requests.delete(sessionId);
+    },
+  };
+}
+
+export function sideQuestionRequest(sessionId) {
+  return (sessionId && requests.get(sessionId)) || null;
+}
+
+/** Start the session's side question, aborting the one still in flight. */
+export function beginSideQuestion(sessionId) {
+  cancelSideQuestion(sessionId);
+  const controller = new AbortController();
+  inFlight.set(sessionId, controller);
+  return {
+    signal: controller.signal,
+    end() {
+      if (inFlight.get(sessionId) === controller) inFlight.delete(sessionId);
+    },
+  };
+}
+
+export function cancelSideQuestion(sessionId) {
+  const controller = sessionId ? inFlight.get(sessionId) : null;
+  if (!controller) return false;
+  inFlight.delete(sessionId);
+  controller.abort(new Error('Side question canceled.'));
+  return true;
+}
+
+/** The transcript the saved request carried is gone (clear, rewind): a later
+ *  side question waits for the next request. `cancel` also aborts the side
+ *  question in flight (session close / runtime unload). */
+export function forgetSideQuestion(sessionId, { cancel = false } = {}) {
+  if (!sessionId) return;
+  requests.delete(sessionId);
+  if (cancel) cancelSideQuestion(sessionId);
+}