mixdog 1.2.3 → 1.2.5

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

@@ -1,13 +1,13 @@
 // Committed-but-unsealed text segments of one user turn.
 //
-// Max-output recovery parts plus (Lead/TUI only) text-only continuation
+// Max-output recovery parts plus text-only continuation
 // segments (provider pause_turn / terminal steering / stop hook). The terminal
 // response returns content = parts + terminal so the UI row that accumulated
 // every streamed segment is not overwritten down to only the last segment;
 // historyContent keeps persistence single-copy.
 import { buildIntermediateAssistantMessage, commitAssistantMessage } from '../assistant-commit.mjs';
 
-export function createTurnSegments({ messages, opts, suppressMidTurnText }) {
+export function createTurnSegments({ messages, opts }) {
   const parts = [];
   return {
     parts,
@@ -18,15 +18,9 @@ export function createTurnSegments({ messages, opts, suppressMidTurnText }) {
       return true;
     },
     // Record a mid-turn segment for the caller-facing aggregate and surface it
-    // live. A suppressed sub-agent session neither surfaces nor accumulates
-    // text — except on the max-output ladder, whose parts must still rebuild
-    // the complete answer the caller receives (keepWhenSuppressed).
+    // live for every session.
     // `committed: true` marks text that is the just-committed message's own.
-    record(text, { keepWhenSuppressed = false, committed = false } = {}) {
-      if (suppressMidTurnText) {
-        if (keepWhenSuppressed) parts.push(text);
-        return;
-      }
+    record(text, { committed = false } = {}) {
       parts.push(text);
       try {
         opts.onAssistantText?.(text, { committed });

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

@@ -19,15 +19,8 @@ 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,
-  suppressMidTurnText,
-  drainSteering,
-}) {
-  const segments = createTurnSegments({ messages, opts, suppressMidTurnText });
+export function createNoToolTurnResolver({ messages, opts, sessionId, sessionAgent, drainSteering }) {
+  const segments = createTurnSegments({ messages, opts });
   // Per-turn recovery counters shared by the ladders.
   const state = {
     maxOutputRecoveryCount: 0,

package/src/runtime/agent/orchestrator/session/loop/pre-dispatch-deny.mjs

@@ -103,7 +103,10 @@ export function preDispatchDenyForSession(sessionRef, call) {
   // its wire id with the projection error; call_tool itself never dispatches.
   if (typeof call.bridgeError === 'string') return call.bridgeError;
   if (name === BRIDGE_CALL_TOOL_NAME && isToolBridgeEnabled(sessionRef)) {
-    return bridgeErrorText('BRIDGE_RECURSION', 'call_tool runs one tool named in its arguments and cannot be dispatched itself.');
+    return bridgeErrorText(
+      'BRIDGE_RECURSION',
+      'call_tool runs one tool named in its arguments and cannot be dispatched itself.'
+    );
   }
   const schemaName = String(call?.schemaName || name);
   // A tool the provider left out of this request still exists in the session;

package/src/runtime/agent/orchestrator/session/loop/provider-tool-exclusions.mjs

@@ -13,7 +13,10 @@ import { actionInputUnionFor } from '../../providers/lib/action-input-contract.m
 import { isAntigravityClaude } from '../../providers/antigravity-request.mjs';
 import { isResponsesFreeformTool } from '../../providers/custom-tool-wire.mjs';
 import { ANTHROPIC_NATIVE_PROVIDERS } from '../../runtime-core/tool-catalog-schema.mjs';
-import { finalizeProviderRequestTools, providerNativeToolPrefixCount } from '../../runtime-core/provider-request-tools.mjs';
+import {
+  finalizeProviderRequestTools,
+  providerNativeToolPrefixCount,
+} from '../../runtime-core/provider-request-tools.mjs';
 
 const sessions = new WeakMap();
 

package/src/runtime/agent/orchestrator/session/loop/request-boundary.mjs

@@ -5,10 +5,7 @@
 import { repairTranscriptBeforeProviderSend } from './transcript-repair.mjs';
 import { messagesArrayChanged } from './tool-helpers.mjs';
 import { runPreSendCompactPass } from '../pre-send-compact.mjs';
-import {
-  refreshDeferredMcpToolCatalog,
-  snapshotProviderRequestTools,
-} from '../../runtime-core/tool-catalog.mjs';
+import { refreshDeferredMcpToolCatalog, snapshotProviderRequestTools } from '../../runtime-core/tool-catalog.mjs';
 import {
   finalizeProviderRequestTools,
   providerNativeToolPrefixCount,

package/src/runtime/agent/orchestrator/session/loop/route-fallback.mjs

@@ -0,0 +1,76 @@
+import { canFallbackRoute } from '../../../../shared/model-route-fallback.mjs';
+import { getProvider, initProviders } from '../../providers/registry.mjs';
+import { loadConfig } from '../../config.mjs';
+import { ensureProviderEnabled } from '../../runtime-core/config-helpers.mjs';
+import { updateSessionRoute } from '../manager/session-lifecycle.mjs';
+import { pinSessionWireRoute } from '../../providers/wire-route.mjs';
+import { buildRequestSendOptions } from '../manager/ask-turn-loop-options.mjs';
+import { prepareTurnEffortConfiguration } from '../../providers/effort-configuration.mjs';
+import { resolveSessionContextMeta } from '../manager/context-meta.mjs';
+
+export async function advanceAgentRoute(state, error) {
+  const session = state.sessionRef;
+  const index = session?.routeFallbackIndex || 0;
+  const next = session?.routeFallbacks?.[index];
+  const committed = state.toolCallsTotal > 0 || state.response != null;
+  if (!session?.agent || !next || !canFallbackRoute(error, { signal: state.signal, committed })) return false;
+  state.throwIfAborted();
+  const config = ensureProviderEnabled(loadConfig(), next.provider);
+  await initProviders(config.providers, { signal: state.signal });
+  state.throwIfAborted();
+  const provider = getProvider(next.provider);
+  if (!provider) throw new Error(`Provider "${next.provider}" not available`);
+  const oldOptions = buildRequestSendOptions({
+    sessionId: state.sessionId,
+    session,
+    signal: state.signal,
+  });
+  const updated = updateSessionRoute(
+    session.id,
+    {
+      ...next,
+      effort: next.effort || null,
+      fast: next.fast === true,
+      autoEffort: next.autoEffort !== false,
+      modelParameters: next.modelParameters || {},
+      contextPercent: next.contextPercent,
+      contextTokens: next.contextTokens,
+      selectedContextWindow: resolveSessionContextMeta(provider, next.model, next).rawContextWindow,
+    },
+    { crossProvider: true }
+  );
+  if (!updated) throw new Error('agent session closed during model fallback');
+  updated.routeFallbackIndex = index + 1;
+  await pinSessionWireRoute(updated, provider);
+  state.throwIfAborted();
+  state.messages.splice(0, state.messages.length, ...updated.messages);
+  updated.liveTurnMessages = state.messages;
+  state.sessionRef = updated;
+  state.provider = provider;
+  state.model = updated.model;
+  state.tools = updated.tools;
+  state.providerState = undefined;
+  state.providerStateUpdated = true;
+  state.prefixGuardState = null;
+  state.fixedProviderToolSurface = null;
+  state.cacheBreakTraceKeys.clear();
+  state.transportRetriesUsed = 0;
+  state.transportRetryMax = 0;
+  for (const key of Object.keys(oldOptions)) delete state.opts[key];
+  Object.assign(
+    state.opts,
+    buildRequestSendOptions({
+      sessionId: state.sessionId,
+      session: updated,
+      turnEffort: updated.effort,
+      effortConfiguration: prepareTurnEffortConfiguration(updated, provider),
+      signal: state.signal,
+    })
+  );
+  state.opts.onStageChange?.('connecting', {
+    provider: updated.provider,
+    model: updated.model,
+    reason: 'model-fallback',
+  });
+  return true;
+}

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

@@ -18,6 +18,7 @@ import { runWithProviderRequestToolsScope } from '../../runtime-core/provider-re
 import { REPEAT_FAIL_LIMIT } from './loop-state.mjs';
 import { createToolCallIdResolver } from './tool-call-ids.mjs';
 import { captureSideQuestionRequest } from '../side-question-store.mjs';
+import { advanceAgentRoute } from './route-fallback.mjs';
 import {
   beginProviderToolExclusions,
   dropSessionTool,
@@ -205,7 +206,8 @@ export async function sendProviderRequest(state, round) {
     );
   } catch (error) {
     sideQuestion?.discard();
-    throw error;
+    if (!(await advanceAgentRoute(state, error))) throw error;
+    result = { action: 'retry_route' };
   }
   if (result.action === 'proceed') sideQuestion?.settle(result.response);
   else sideQuestion?.discard();
@@ -233,6 +235,8 @@ function appendRecoveryNotice(state, notice) {
  *  instead of processing a response. */
 export function applyRetryAction(state, result) {
   switch (result.action) {
+    case 'retry_route':
+      return true;
     case 'retry':
       // Keep opts.cacheBreakIntent: the failed send never consumed the tag,
       // and the reactive-compact retry that follows IS the tagged transition.

package/src/runtime/agent/orchestrator/session/loop/step-auto-effort.mjs

@@ -21,15 +21,14 @@ import { judgeTurn, recordEffortDecision } from '../../../../effort-judge/judge-
 import { stepResultWindow } from '../../../../effort-judge/judge-input.mjs';
 
 const TEXT_BLOCKS = new Set(['text', 'input_text', 'output_text']);
-const textOf = (content) =>
-  typeof content === 'string'
-    ? content
-    : Array.isArray(content)
-      ? content
-          .filter((block) => block && TEXT_BLOCKS.has(block.type))
-          .map((block) => block.text)
-          .join('\n')
-      : '';
+function textOf(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  return content
+    .filter((block) => block && TEXT_BLOCKS.has(block.type))
+    .map((block) => block.text)
+    .join('\n');
+}
 // Same argument text the training data was built from (head 600 code points).
 const argText = (args) =>
   Array.from(typeof args === 'string' ? args : JSON.stringify(args ?? {}))

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

@@ -14,6 +14,12 @@ export function _stripMcpPrefix(name) {
 export function _isReadTool(name) {
   return _stripMcpPrefix(name) === 'read';
 }
+
+// Cursor's native file protocol needs source content, not a receipt saying
+// the model has already seen it. Keep actual read caching and permissions.
+export function requiresReadBody(name, sessionRef) {
+  return name === 'read' && (sessionRef?.provider === 'cursor-oauth' || sessionRef?.provider === 'cursor-api');
+}
 export function _isMutationTool(name, args = null) {
   const n = String(_stripMcpPrefix(name) || '').toLowerCase();
   return n === 'apply_patch' || n === 'edit' || _isGitMutationTool(name, args);

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

@@ -15,6 +15,8 @@ import { executeInternalTool, isInternalTool } from '../../../internal-tools.mjs
 import { buildSkillsListResponse, viewSkill } from '../tool-helpers.mjs';
 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';
 
 function dispatchMcp(name, args, { cwd, callerSessionId, sessionRef, executeOpts }) {
   const mcpScopeId = sessionRef?.mcpScopeId || null;
@@ -100,11 +102,22 @@ export function dispatchToolCall({ name, args }, ctx) {
   if (name === 'shell' || isBuiltinTool(name) || isExternalAdapterTool(name)) {
     const builtinOpts = {
       ...completionToolOpts,
-      ...(executeOpts.suppressReadUnchangedStub ? { suppressReadUnchangedStub: true } : {}),
+      ...(executeOpts.suppressReadUnchangedStub || requiresReadBody(name, sessionRef)
+        ? { suppressReadUnchangedStub: true }
+        : {}),
       // Runtime-granted only; any value inherited from executeOpts is overridden.
       elevationApproved: ctx.elevationApproved === true,
     };
-    return executeBuiltinTool(name, args, cwd, builtinOpts);
+    return executeCursorNativeBuiltin(
+      name,
+      args,
+      cwd,
+      {
+        ...builtinOpts,
+        toolCallId: executeOpts.toolCallId || null,
+      },
+      executeBuiltinTool
+    );
   }
   return formatUnknownBuiltinToolMessage(name, args, 'tool');
 }

package/src/runtime/agent/orchestrator/session/loop/tool-exposure-migration.mjs

@@ -3,10 +3,7 @@
 // applyDeferredToolSurface; this module adds what a changed request prefix
 // invalidates: provider state, the prefix guard, the context baseline and the
 // cache-break tag. Historical tool calls are never rewritten.
-import {
-  applyDeferredToolSurface,
-  rebuildDeferredToolSurfaceForProvider,
-} from '../../runtime-core/tool-catalog.mjs';
+import { applyDeferredToolSurface, rebuildDeferredToolSurfaceForProvider } from '../../runtime-core/tool-catalog.mjs';
 import {
   bridgeSurfaceOutdated,
   sessionToolExposure,

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

@@ -16,7 +16,7 @@ function isSleepLikeToolCall(call) {
 }
 
 export async function runToolPhase(state, round, sent, onToolCall) {
-  const { opts, messages, tools, sessionId, sessionRef, signal, response, suppressMidTurnText } = state;
+  const { opts, messages, tools, sessionId, sessionRef, signal, response } = state;
   state.noToolTurn.noteToolCallTurn();
   const calls = response.toolCalls;
   round.resolveToolCallId.all(calls);
@@ -25,8 +25,7 @@ export async function runToolPhase(state, round, sent, onToolCall) {
   // UI. Providers that stream via onTextDelta already rendered it; providers
   // that return text only in response.content would otherwise show nothing
   // before the tool card. The engine de-dups against already-streamed text.
-  // Sub-agent sessions suppress it entirely — Lead only consumes the answer.
-  if (!suppressMidTurnText && typeof response.content === 'string' && response.content.trim()) {
+  if (typeof response.content === 'string' && response.content.trim()) {
     try {
       opts.onAssistantText?.(response.content);
     } catch {
@@ -39,7 +38,7 @@ export async function runToolPhase(state, round, sent, onToolCall) {
   // The wire calls stay the transcript identity (assistant turn below).
   const toolBatchId = recordToolBatch(sessionId, resolveExecutionToolCalls(calls, sessionRef), state.iterations);
   await Promise.resolve(onToolCall?.(state.iterations, calls));
-  const assistantTurnMsg = buildToolCallAssistantMessage(response, { calls, suppressMidTurnText, opts });
+  const assistantTurnMsg = buildToolCallAssistantMessage(response, { calls, opts });
   commitAssistantMessage(messages, assistantTurnMsg, opts);
   try {
     opts.onToolPhaseStarted?.();

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

@@ -6,6 +6,7 @@
 // abort-aware call wrapper is ask-call-interrupt. This file owns the lock,
 // the loop and the runtime bookkeeping around each turn.
 import { createHash } from 'node:crypto';
+import { admitWorkspaceActivity } from '../../../../shared/worktrees/activity-gate.mjs';
 import {
   persistedAssistantTranscriptMetadata,
   persistedUserTranscriptMetadata,
@@ -38,6 +39,16 @@ const traceAskStart = (sessionId, explicitPrefetch) => {
   );
 };
 
+/** A background follow-up ask has no caller to reject to; its failure would
+ *  otherwise strand the pending input silently. */
+const logFollowUpFailure = (sessionId) => (error) => {
+  try {
+    process.stderr.write(`[agent-ask] follow-up ask failed session=${sessionId}: ${error?.message || error}\n`);
+  } catch {
+    /* best-effort */
+  }
+};
+
 /** The transcript timestamps the caller supplied for this ask: the persisted
  *  user metadata plus a one-shot reader for the assistant metadata. */
 export function createAskTranscriptMeta(rawTranscriptMeta) {
@@ -66,7 +77,13 @@ export function createAskTranscriptMeta(rawTranscriptMeta) {
  *  the turn state and rethrows. Returns the terminal result preview and the
  *  follow-ups drained right after the provider accepted the turn. */
 async function runAskTurn({ sessionId, opened, input, askOpts, onToolCall, cwdOverride, transcript, askStartedAt }) {
+  let releaseWorkspace;
   try {
+    releaseWorkspace = await admitWorkspaceActivity(
+      sessionId,
+      cwdOverride || opened.turn.session.cwd || process.cwd(),
+      opened.runtime.controller?.signal
+    );
     const prepared = await prepareAskTurn({ sessionId, opened, input, cwdOverride, transcriptMeta: transcript.user });
     const result = await runAskAgentLoop({
       sessionId,
@@ -105,8 +122,12 @@ async function runAskTurn({ sessionId, opened, input, askOpts, onToolCall, cwdOv
       generation: opened.askGeneration,
       turnCheckpointToken: opened.turnToken,
       runtime: opened.runtime,
+      transcriptMeta: transcript.raw,
+      askStartedAt,
     });
     throw err;
+  } finally {
+    releaseWorkspace?.();
   }
 }
 
@@ -122,9 +143,12 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
     process.stderr.write(`[agent-trace] lock-acquired waitedMs=${Date.now() - askStartedAt}\n`);
   }
   // A non-empty cross-process sweep starts an empty follow-up ask once the
-  // current session lock is released; it never delays completion.
+  // current session lock is released; it never delays completion. The
+  // failed-turn retry identity is one-shot: a follow-up runs queued input,
+  // never the retried turn. Nobody awaits it, so a failure is logged.
+  const followUpOpts = { ...askOpts, retryFailedTurn: undefined, retryTurnId: undefined, retryAttemptId: undefined };
   const kickFollowUpAsk = () => {
-    askSession(sessionId, '', null, onToolCall, cwdOverride, null, askOpts).catch(() => {});
+    askSession(sessionId, '', null, onToolCall, cwdOverride, null, followUpOpts).catch(logFollowUpFailure(sessionId));
   };
   // The mutex is held for the WHOLE askSession call, including any follow-up
   // turns drained from the pending-message queue below — the single outer
@@ -141,6 +165,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
   // A failed-turn retry rewinds only the turn it retries, never a drained
   // follow-up turn.
   let retryFailedTurn = askOpts.retryFailedTurn === true;
+  let retryTurnId = askOpts.retryTurnId;
   try {
     // Turn loop (pendingMessages pattern): run the current prompt, then drain
     // any `agent type=send` messages that were queued while this turn was in
@@ -163,6 +188,11 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
         input.retryFailedTurn = true;
         retryFailedTurn = false;
       }
+      if (retryTurnId) {
+        input.retryTurnId = retryTurnId;
+        input.retryAttemptId = askOpts.retryAttemptId;
+        retryTurnId = null;
+      }
       // Synchronous pre-await setup (must happen before any await so
       // closeSession() can't interleave between load and registration).
       const claimed = claimTurnRuntime({
@@ -217,7 +247,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             if (count <= 0) return;
             kickFollowUpAsk();
           })
-          .catch(() => {});
+          .catch(logFollowUpFailure(sessionId));
       });
       return result;
     }

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

@@ -13,10 +13,6 @@ export async function settleAskCleanup(promise, { timeoutMs } = {}) {
 }
 
 // Live Agent projection is a per-ask send opt, never a session field.
-// Callers that pass onTextDelta/onAssistantText still need `liveProjection`
-// to un-suppress provider streaming: askSession always wraps those
-// callbacks for interruption tracking, so agent-loop cannot infer intent
-// from `typeof opts.onTextDelta === 'function'`.
 export function resolveAskLiveProjection(askOpts = {}) {
   return askOpts?.liveProjection === true;
 }

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

@@ -16,7 +16,12 @@ import {
 } from '../../providers/auto-effort.mjs';
 import { builtinFeatureActive } from '../../runtime-core/builtin-features.mjs';
 import { effortOptionsFor, warnEmptyAutoEffortLadder } from '../../runtime-core/effort.mjs';
-import { effortJudgeSupportsSteps, judgeTurn, recordEffortDecision } from '../../../../effort-judge/judge-client.mjs';
+import {
+  effortJudgeSupportsSteps,
+  judgeTurn,
+  prewarmEffortJudge,
+  recordEffortDecision,
+} from '../../../../effort-judge/judge-client.mjs';
 import { promptContentText } from './prompt-utils.mjs';
 
 // Every cache-safe route judges its tool-result steps the same way. Measured
@@ -53,6 +58,21 @@ export function autoEffortMode() {
   }
 }
 
+/**
+ * Starts the judge worker when a session is created or opened on a route that
+ * Auto effort can judge, so the first judged turn does not wait for the cold
+ * load. Fire-and-forget: it never throws and never waits on the load.
+ */
+export function prewarmSessionAutoEffort(session, provider) {
+  try {
+    if (autoEffortMode() === 'off' || session?.autoEffort === false) return false;
+    if (!turnEffortConfigurationMode(session, provider)) return false;
+    return prewarmEffortJudge();
+  } catch {
+    return false;
+  }
+}
+
 function lastText(messages, role) {
   for (let i = (messages?.length || 0) - 1; i >= 0; i--) {
     const message = messages[i];

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

@@ -15,7 +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 { rewindUnansweredPrompt } from './failed-turn-rewind.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';
 import { backfillFallbackSessionTitle } from './session-fallback-title.mjs';
@@ -25,6 +25,9 @@ import { backfillFallbackSessionTitle } from './session-fallback-title.mjs';
 export async function prepareAskTurn({ sessionId, opened, input, cwdOverride, transcriptMeta }) {
   const { turn, runtime, turnSignal, askGeneration, checkpoint, turnToken, startedAt, codexTurnId } = opened;
   const session = turn.session;
+  const retained = input.retryTurnId
+    ? retainedFailedTurnInput(session.messages, input.retryTurnId, input.retryAttemptId)
+    : null;
   const provider = getProvider(session.provider);
   // Register the live session object for synchronous close snapshots.
   runtime.session = session;
@@ -44,7 +47,7 @@ export async function prepareAskTurn({ sessionId, opened, input, cwdOverride, tr
   // A failed-turn retry resubmits the prompt the failure left unanswered;
   // rewind that copy so the model sees the prompt once (an answered tail is
   // kept and the retry continues from it).
-  if (input.retryFailedTurn === true) rewindUnansweredPrompt(session, input.prompt);
+  if (input.retryFailedTurn === true && !input.retryTurnId) rewindUnansweredPrompt(session, input.prompt);
   if (session.sessionStartMetaInjected !== true && !hasUserConversationMessage(session.messages)) {
     refreshSessionBp3Environment(session, effectiveCwd);
   }
@@ -61,16 +64,37 @@ export async function prepareAskTurn({ sessionId, opened, input, cwdOverride, tr
   });
   const [autoEffort, userTurn] = await Promise.all([
     autoEffortPending,
-    buildUserTurn({
-      session,
-      prompt: input.prompt,
-      context: input.context,
-      explicitPrefetch: input.explicitPrefetch,
-      turnSignal,
-      transcriptMeta,
-      turnPromptSource: input.promptSource,
-      effortConfiguration: null,
-    }),
+    retained
+      ? (() => {
+          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 },
+                ],
+              },
+            },
+          };
+          return { historyMessages, userTurnMessage, outgoing: [...historyMessages, userTurnMessage] };
+        })()
+      : buildUserTurn({
+          session,
+          prompt: input.prompt,
+          context: input.context,
+          explicitPrefetch: input.explicitPrefetch,
+          turnSignal,
+          transcriptMeta,
+          turnPromptSource: input.promptSource,
+          effortConfiguration: null,
+        }),
     wireRoutePending,
   ]);
   const turnEffort = autoEffort?.applied ? autoEffort.effort : session.effort || null;
@@ -163,6 +187,7 @@ export async function prepareAskTurn({ sessionId, opened, input, cwdOverride, tr
     deferredToolDelta: userTurn.deferredToolDelta,
     goalReminder: userTurn.goalReminder,
     workspaceNotice: userTurn.workspaceNotice,
+    setupNotice: userTurn.setupNotice,
   };
 }
 
@@ -186,7 +211,7 @@ export async function runAskAgentLoop({
     session.toolApprovalHook = askOpts.onToolApproval;
   }
   try {
-    if (!input.promptSource) {
+    if (!input.promptSource && !input.retryTurnId) {
       const applied = await prepareExplicitSkills(input.prompt, outgoing, session, {
         cwd: effectiveCwd,
         signal: turnSignal,

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

@@ -17,6 +17,31 @@ import {
 import { _getRuntimeEntry, markSessionCancelled, markSessionError } from './runtime-liveness.mjs';
 import { SessionClosedError } from './session-errors.mjs';
 import { clearTurnCheckpoint } from './turn-checkpoint.mjs';
+import { attachFailedTurnCompletion } from './ask-turn-settle.mjs';
+import { turnFailureRecord } from '../turn-failure.mjs';
+import { transcriptRouteMetadataFields } from '../../../../shared/transcript-metadata.mjs';
+
+/** The durable end of a failed turn: the live turndone's status, reason and
+ *  quota stop, so a reopened session renders the same failure. */
+function failedTurnCompletion({ session, err, transcriptMeta, askStartedAt }) {
+  const raw = transcriptMeta && typeof transcriptMeta === 'object' ? transcriptMeta : {};
+  const route = { provider: session?.provider || raw.provider, model: session?.model || raw.modelId };
+  const { errorKind, quota, detail, errorDetails } = turnFailureRecord(err, route);
+  const startedAt = Number(raw.at || askStartedAt || Date.now());
+  return {
+    status: 'failed',
+    attemptId: raw.attemptId || globalThis.crypto.randomUUID(),
+    at: startedAt,
+    verb: typeof raw.completionVerb === 'string' && raw.completionVerb ? raw.completionVerb : 'Thought',
+    elapsedMs: Math.max(0, Date.now() - startedAt),
+    ...(typeof raw.checkpointId === 'string' && raw.checkpointId ? { checkpointId: raw.checkpointId } : {}),
+    ...transcriptRouteMetadataFields(raw),
+    ...(detail ? { detail } : {}),
+    ...(errorDetails ? { errorDetails } : {}),
+    errorKind,
+    ...(quota ? { quota } : {}),
+  };
+}
 
 /** Durable failure identity: every surfaced (non-cancel) turn error logs ONE
  *  structured line to stderr — the shard host mirrors it into daemon.log — so
@@ -118,6 +143,8 @@ async function finalizeCancelledTurn({
  * @param {number} input.generation      the ask generation every save is scoped to
  * @param {string} input.turnCheckpointToken
  * @param {object} input.runtime         the session's runtime entry at turn start
+ * @param {object} [input.transcriptMeta] the caller's raw transcript metadata
+ * @param {number} [input.askStartedAt]
  */
 export async function finalizeAskTurnFailure({
   sessionId,
@@ -129,9 +156,13 @@ export async function finalizeAskTurnFailure({
   generation,
   turnCheckpointToken,
   runtime,
+  transcriptMeta = null,
+  askStartedAt = 0,
 }) {
   checkpoint.stop();
   const session = turn.session;
+  const recordFailure = () =>
+    attachFailedTurnCompletion(session.messages, failedTurnCompletion({ session, err, transcriptMeta, askStartedAt }));
   // Cancellation/error paths bypass the commit point; drop the live-turn
   // alias so contextStatus() stops estimating from the stale in-flight array
   // once the turn unwinds.
@@ -187,6 +218,7 @@ export async function finalizeAskTurnFailure({
   let errorStateDurable = false;
   if (preserveProviderPartial && session && interruption.hasResponseStarted()) {
     const finalized = prepareCloseSnapshot('provider-error');
+    if (finalized.responsePreserved) recordFailure();
     errorStateDurable = await persistFinalizedSession({
       session,
       sessionId,
@@ -208,6 +240,7 @@ export async function finalizeAskTurnFailure({
     );
     const promptPersisted = compactPersist.settled && compactPersist.value === true;
     if (promptPersisted) {
+      recordFailure();
       errorStateDurable = await persistFinalizedSession({
         session,
         sessionId,

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

@@ -17,6 +17,7 @@ import {
   suffixUserTurnReminders,
   buildCurrentTimeBlock,
   snapshotPendingWorkspaceNotice,
+  snapshotPendingSetupNotice,
 } from './prompt-utils.mjs';
 import { codexWireSendOpts } from './session-id.mjs';
 import { _tryBridgeExplicitPrefetch } from './prefetch-bridge.mjs';
@@ -177,8 +178,11 @@ export async function buildUserTurn({
   // A mid-conversation working-folder change: the system prompt keeps its
   // old root (cache intact) and the new folder's facts ride this turn.
   const workspaceNotice = snapshotPendingWorkspaceNotice(session);
+  // What preparing a new worktree linked, installed, ran, failed or skipped.
+  const setupNotice = snapshotPendingSetupNotice(session);
   const reminderBlock = [
     workspaceNotice?.content || '',
+    setupNotice?.content || '',
     currentTimeBlock ? `<system-reminder>\n# Current Time\n${currentTimeBlock}\n</system-reminder>` : '',
     deferredToolDelta?.content || '',
     goalReminder?.content || '',
@@ -206,6 +210,7 @@ export async function buildUserTurn({
     deferredToolDelta,
     goalReminder,
     workspaceNotice,
+    setupNotice,
     userTurnMessage,
     outgoing: [...historyMessages, userTurnMessage],
   };