mixdog 1.2.3 → 1.2.4

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],
   };

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

@@ -8,7 +8,7 @@ import { ingestSessionTurn } from '../../../../session-search/session-search-ing
 import { persistedAssistantTranscriptMetadata } from '../../../../shared/transcript-metadata.mjs';
 import { acknowledgePendingDeferredToolDelta } from '../../runtime-core/deferred-tool-delta.mjs';
 import { acknowledgePendingGoalReminder } from '../../runtime-core/goal-reminder.mjs';
-import { acknowledgePendingWorkspaceNotice } from './prompt-utils.mjs';
+import { acknowledgePendingSetupNotice, acknowledgePendingWorkspaceNotice } from './prompt-utils.mjs';
 import {
   finalizePendingMessageDelivery,
   drainPendingMessages,
@@ -43,6 +43,8 @@ export function attachAssistantTranscriptCompletion(messages, completion, turnSt
   }
   for (let index = messages.length - 1; index > turnStart; index -= 1) {
     const message = messages[index];
+    // An earlier turn's recorded end bounds this turn.
+    if (message?.meta?.transcript?.completion) break;
     if (message?.role !== 'assistant') continue;
     const content = message.content;
     const hasVisibleText =
@@ -72,6 +74,21 @@ export function attachAssistantTranscriptCompletion(messages, completion, turnSt
   return false;
 }
 
+/** Records a failed turn's end on its last message: its tool result, its
+ *  last reply, or the prompt itself when the turn produced nothing. Only for
+ *  a turn whose prompt survived in `messages`, so that message is the turn's. */
+export function attachFailedTurnCompletion(messages, completion) {
+  if (!Array.isArray(messages) || !completion || typeof completion !== 'object') return false;
+  const index = messages.length - 1;
+  const message = messages[index];
+  if (!message || message.role === 'system') return false;
+  const meta = message.meta && typeof message.meta === 'object' ? message.meta : {};
+  const transcript = meta.transcript && typeof meta.transcript === 'object' ? meta.transcript : {};
+  // A new object: the save worker detects changed messages by identity.
+  messages[index] = { ...message, meta: { ...meta, transcript: { ...transcript, completion } } };
+  return true;
+}
+
 /** Commits the loop result into the session: messages, usage, provider state
  *  and queue acknowledgements. Returns the terminal result preview. */
 export async function commitAskTurn({ sessionId, opened, prepared, result, rawTranscriptMeta, askStartedAt }) {
@@ -125,6 +142,7 @@ export async function commitAskTurn({ sessionId, opened, prepared, result, rawTr
   if (prepared.workspaceNotice) {
     acknowledgePendingWorkspaceNotice(session, prepared.workspaceNotice.revision);
   }
+  if (prepared.setupNotice) acknowledgePendingSetupNotice(session, prepared.setupNotice.revision);
   return {
     ...result,
     trimmed: messagesDropped > 0,