mixdog 1.2.2 → 1.2.4

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

@@ -5,6 +5,7 @@
 // (runAskAgentLoop). Provider-not-available and trim failures throw here so
 // the caller marks the session errored instead of leaving stage='connecting'.
 import { getProvider } from '../../providers/registry.mjs';
+import { pinSessionWireRoute } from '../../providers/wire-route.mjs';
 import { notifySkillsApplied, prepareExplicitSkills, recordAppliedSkills } from '../explicit-skills.mjs';
 import { prepareTurnEffortConfiguration } from '../../providers/effort-configuration.mjs';
 import { resolveTurnAutoEffort, turnStepAutoEffort } from './ask-turn-auto-effort.mjs';
@@ -14,19 +15,27 @@ 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';
 
 /** 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 }) {
   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;
   if (!provider) throw new Error(`Provider "${session.provider}" not available`);
+  // The session's wire is pinned before its first request (an existing
+  // session keeps the wire it started on); read from the history as the turn
+  // found it, awaited with the user turn below.
+  const wireRoutePending = pinSessionWireRoute(session, provider);
   // The turn-level judgment runs while the rest of the turn is prepared; it
   // reads the session as the turn found it (synchronously, on this call).
   // The first request still carries its decision: it is awaited below,
@@ -38,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);
   }
@@ -55,16 +64,38 @@ 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;
   const effortConfiguration = prepareTurnEffortConfiguration(
@@ -107,6 +138,14 @@ export async function prepareAskTurn({ sessionId, opened, input, cwdOverride, tr
   // user turn is introduced.
   session.messages = filterModelVisibleSessionMessages(outgoing);
   session.liveTurnMessages = outgoing;
+  // Name a titleless session from its first human prompt before the first
+  // save, so the title outlives any later compaction of the transcript. The
+  // earliest human turn already in the history wins; this turn's prompt is the
+  // fallback (runtime-injected turns carrying a promptSource never name it).
+  backfillFallbackSessionTitle(session, [
+    ...historyMessages,
+    ...(input.promptSource ? [] : [{ role: 'user', content: input.prompt }]),
+  ]);
   session.activeTurnCheckpoint = {
     version: 1,
     turnToken,
@@ -147,6 +186,8 @@ export async function prepareAskTurn({ sessionId, opened, input, cwdOverride, tr
     beforeCount: historyMessages.length + 1,
     deferredToolDelta: userTurn.deferredToolDelta,
     goalReminder: userTurn.goalReminder,
+    workspaceNotice: userTurn.workspaceNotice,
+    setupNotice: userTurn.setupNotice,
   };
 }
 
@@ -170,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-loop-options.mjs

@@ -18,6 +18,53 @@ const relay = (fn, ...args) => {
   }
 };
 
+/**
+ * The callback-free send options that shape a turn's provider request (effort,
+ * model parameters, cache routing, continuation state, Codex wire identity and
+ * the session's provider cache settings). agentLoop's options spread them, and
+ * a /btw request built before any turn has run uses them as they are.
+ */
+export function buildRequestSendOptions({
+  sessionId,
+  session,
+  turnEffort,
+  effortConfiguration,
+  stepAutoEffort,
+  codexTurnId,
+  startedAtMs,
+  signal,
+}) {
+  return {
+    effort: turnEffort,
+    effortConfiguration,
+    // { request, base } when each tool-result step is judged (step-auto-effort.mjs).
+    stepAutoEffort: stepAutoEffort || null,
+    fast: session.fast === true,
+    modelParameters: session.modelParameters || {},
+    selectedContextWindow: session.selectedContextWindow || session.contextWindow || null,
+    sessionId,
+    // Same projection compaction uses, so a session presents one identity on
+    // every request it makes.
+    ...(codexWireSendOpts(session, { turnId: codexTurnId, startedAtMs }) || {}),
+    promptCacheKey: session.promptCacheKey || sessionId,
+    // Provider-scoped cache key (mixdog-codex, mixdog-claude…). Distinct
+    // from sessionId — providers that pool sockets per-session (openai-oauth
+    // WS) use sessionId as the pool bucket and providerCacheKey as the
+    // server-side prompt-cache shard so parallel callers don't collide on a
+    // mid-turn socket while still sharing prefix cache.
+    providerCacheKey: session.promptCacheKey || null,
+    signal,
+    providerState: session.providerState ?? undefined,
+    // The wire this session is pinned to (wire-route.mjs).
+    wireRoute: session.wireRoute ?? undefined,
+    session,
+    // Agent Runtime cache settings — merged last so session overrides don't
+    // get overridden by defaults. When session has no profile,
+    // providerCacheOpts is null and this spread is a no-op.
+    ...(session.providerCacheOpts || {}),
+  };
+}
+
 /**
  * @param {object} input
  * @param {string} input.sessionId
@@ -49,14 +96,6 @@ export function buildAgentLoopOptions({
   // (ask-turn-steering-drain.mjs).
   const drainSteering = createAskSteeringDrain({ sessionId, turn, askOpts });
   return {
-    effort: turnEffort,
-    effortConfiguration,
-    // { request, base } when each tool-result step is judged (step-auto-effort.mjs).
-    stepAutoEffort: stepAutoEffort || null,
-    fast: session.fast === true,
-    modelParameters: session.modelParameters || {},
-    selectedContextWindow: session.selectedContextWindow || session.contextWindow || null,
-    sessionId,
     onTextDelta: (chunk) => {
       interruption.recordTextDelta(chunk);
       checkpoint.schedule();
@@ -157,23 +196,16 @@ export function buildAgentLoopOptions({
       relay(askOpts?.onSkillsApplied, names, detail);
     },
     notifyFn: optionalFn(askOpts?.notifyFn),
-    // Same projection compaction uses, so a session presents one identity on
-    // every request it makes.
-    ...(codexWireSendOpts(session, { turnId: codexTurnId, startedAtMs }) || {}),
-    promptCacheKey: session.promptCacheKey || sessionId,
-    // Provider-scoped cache key (mixdog-codex, mixdog-claude…). Distinct
-    // from sessionId — providers that pool sockets per-session (openai-oauth
-    // WS) use sessionId as the pool bucket and providerCacheKey as the
-    // server-side prompt-cache shard so parallel callers don't collide on a
-    // mid-turn socket while still sharing prefix cache.
-    providerCacheKey: session.promptCacheKey || null,
-    signal,
-    providerState: session.providerState ?? undefined,
-    session,
-    // Agent Runtime cache settings — merged last so session overrides don't
-    // get overridden by defaults. When session has no profile,
-    // providerCacheOpts is null and this spread is a no-op.
-    ...(session.providerCacheOpts || {}),
+    ...buildRequestSendOptions({
+      sessionId,
+      session,
+      turnEffort,
+      effortConfiguration,
+      stepAutoEffort,
+      codexTurnId,
+      startedAtMs,
+      signal,
+    }),
     onStageChange: (stage, detail) => {
       updateSessionStage(sessionId, stage);
       relay(askOpts?.onStageChange, stage, detail);

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

@@ -16,6 +16,8 @@ import {
   prefixUserTurnContent,
   suffixUserTurnReminders,
   buildCurrentTimeBlock,
+  snapshotPendingWorkspaceNotice,
+  snapshotPendingSetupNotice,
 } from './prompt-utils.mjs';
 import { codexWireSendOpts } from './session-id.mjs';
 import { _tryBridgeExplicitPrefetch } from './prefetch-bridge.mjs';
@@ -173,7 +175,14 @@ export async function buildUserTurn({
   // input intake: either can precede the previous turn's pause.
   // This supplies context only; it never resumes the Goal.
   const goalReminder = snapshotPendingGoalReminder(session, { includePaused: true });
+  // 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 || '',
@@ -200,6 +209,8 @@ export async function buildUserTurn({
     historyMessages,
     deferredToolDelta,
     goalReminder,
+    workspaceNotice,
+    setupNotice,
     userTurnMessage,
     outgoing: [...historyMessages, userTurnMessage],
   };

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

@@ -8,6 +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 { acknowledgePendingSetupNotice, acknowledgePendingWorkspaceNotice } from './prompt-utils.mjs';
 import {
   finalizePendingMessageDelivery,
   drainPendingMessages,
@@ -42,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 =
@@ -71,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 }) {
@@ -121,6 +139,10 @@ export async function commitAskTurn({ sessionId, opened, prepared, result, rawTr
   if (prepared.goalReminder) {
     acknowledgePendingGoalReminder(session, prepared.goalReminder.revision);
   }
+  if (prepared.workspaceNotice) {
+    acknowledgePendingWorkspaceNotice(session, prepared.workspaceNotice.revision);
+  }
+  if (prepared.setupNotice) acknowledgePendingSetupNotice(session, prepared.setupNotice.revision);
   return {
     ...result,
     trimmed: messagesDropped > 0,

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

@@ -3,6 +3,7 @@
 // throttled crash-recovery checkpoint sidecar, and the close snapshot that
 // canonicalizes the transcript when the turn is interrupted.
 import { captureTurnCheckpointContextState, createTurnCheckpointRecorder } from './turn-checkpoint.mjs';
+import { finalizeTurnInterruptionSnapshot } from './turn-interruption.mjs';
 
 // Coalescing window for streaming-delta flushes. Each flush journals only the
 // delta since the previous one, so the window just bounds syscalls.
@@ -83,28 +84,46 @@ export function createTurnCheckpointScheduler({ sessionId, generation, turnToken
   };
 }
 
+// The live-session fields a staged close snapshot rewrites.
+const CLOSE_SNAPSHOT_SESSION_FIELDS = [
+  'liveTurnMessages',
+  '_providerPrefixGuardState',
+  'messages',
+  'activeTurnCheckpoint',
+  'providerState',
+  'updatedAt',
+  'lastUsedAt',
+];
+
 /** closeSession is synchronous and generation-first by design. This turn-local
  *  hook lets it canonicalize the in-flight transcript before
  *  bumpSessionGeneration()/markSessionClosed() writes the disk snapshot and
  *  invalidates the ordinary cancellation cleanup save. Finalizes at most once;
- *  later calls return the same snapshot. */
+ *  later calls return the same snapshot.
+ *
+ *  `prepare.tentative(reason)` stages the snapshot on the live session only:
+ *  the checkpoint scheduler and the interruption tracker keep running until
+ *  `commit()`, and `rollback()` restores the live session exactly, so a close
+ *  whose lifecycle barrier is refused leaves the turn as it was. */
 export function createCloseSnapshot({ turn, interruption, checkpoint, runtime }) {
   let snapshot = null;
-  return (abortReason) => {
-    if (snapshot) return snapshot;
+  const stage = (abortReason) => {
     const session = turn.session;
     if (!session) return null;
-    checkpoint.stop();
-    session.liveTurnMessages = null;
-    // Interruption finalize below rewrites the transcript; the
-    // mid-turn provider prefix snapshot must not survive it.
-    delete session._providerPrefixGuardState;
-    interruption.restoreTombstonedText();
-    const finalized = interruption.finalize({
+    const saved = CLOSE_SNAPSHOT_SESSION_FIELDS.map((key) => [key, Object.hasOwn(session, key), session[key]]);
+    const savedRuntimeSession = runtime.session;
+    // The tracker snapshot already counts retracted (tombstoned) text as
+    // output, so finalizing from it leaves the tracker itself untouched.
+    const finalized = finalizeTurnInterruptionSnapshot({
       turnOutgoing: turn.outgoing || session.messages,
       currentUserContent: turn.userTurnContent,
-      abortReason,
+      snapshot: interruption.snapshot(),
+      abortReason: abortReason ?? null,
     });
+    session.liveTurnMessages = null;
+    // The finalized transcript is a rewrite; the mid-turn provider prefix
+    // snapshot must not survive it.
+    delete session._providerPrefixGuardState;
     session.messages = finalized.messages;
     delete session.activeTurnCheckpoint;
     // A preserved response — or a non-user detach that keeps the provisional
@@ -113,7 +132,32 @@ export function createCloseSnapshot({ turn, interruption, checkpoint, runtime })
     session.updatedAt = Date.now();
     session.lastUsedAt = Date.now();
     runtime.session = session;
-    snapshot = finalized;
-    return finalized;
+    return {
+      snapshot: finalized,
+      commit() {
+        checkpoint.stop();
+        interruption.restoreTombstonedText();
+        snapshot = finalized;
+      },
+      rollback() {
+        for (const [key, had, value] of saved) {
+          if (had) session[key] = value;
+          else delete session[key];
+        }
+        runtime.session = savedRuntimeSession;
+      },
+    };
+  };
+  const prepare = (abortReason) => {
+    if (snapshot) return snapshot;
+    const staged = stage(abortReason);
+    if (!staged) return null;
+    staged.commit();
+    return staged.snapshot;
+  };
+  prepare.tentative = (abortReason) => {
+    if (snapshot) return { snapshot, commit() {}, rollback() {} };
+    return stage(abortReason);
   };
+  return prepare;
 }

package/src/runtime/agent/orchestrator/session/manager/compaction-runner.mjs

@@ -21,7 +21,9 @@ import { uncachedInputTokensForProvider } from './usage-metrics.mjs';
 import { pruneOffloadSession } from '../tool-result-offload.mjs';
 import { _getPendingMessagesForSession } from './pending-messages.mjs';
 import { isSessionCompactionBlocked } from './runtime-liveness.mjs';
+import { backfillFallbackSessionTitle } from './session-fallback-title.mjs';
 import { resetReadStateAfterCompaction } from '../read-dedup.mjs';
+import { applyPendingWorkspaceReroot } from './prompt-utils.mjs';
 import {
   compactTargetBudget as compactTargetBudgetForPolicy,
   compactDisplayBeforeTokens,
@@ -629,7 +631,13 @@ async function commitSessionCompaction(plan, run, compactStartedAt) {
   let unchangedReason = null;
   if (!changed) unchangedReason = force ? 'nothing to compact' : 'below threshold';
   const now = Date.now();
+  // Older titleless sessions: keep a name before the transcript that carries
+  // the first prompt is replaced.
+  if (changed) backfillFallbackSessionTitle(session, messages);
   session.messages = transcript;
+  // 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 (changed) applyPendingWorkspaceReroot(session);
   if (changed) resetReadStateAfterCompaction(resolvedSessionId);
   await pruneCompactedOffloads(session, resolvedSessionId);
   if (changed) session.providerState = undefined;

package/src/runtime/agent/orchestrator/session/manager/failed-turn-rewind.mjs

@@ -45,3 +45,19 @@ export function rewindUnansweredPrompt(session, prompt) {
   delete session._providerPrefixGuardState;
   return true;
 }
+
+/** Resolve a retry against the durable failure, never against display text. */
+export function retainedFailedTurnInput(messages, messageId, attemptId) {
+  const list = Array.isArray(messages) ? messages : [];
+  const index = list.findLastIndex((message) => message?.role !== 'system');
+  const message = list[index];
+  const transcript = message?.meta?.transcript;
+  if (!messageId || transcript?.messageId !== messageId || transcript?.completion?.status !== 'failed') {
+    throw new Error('The failed turn is no longer the latest execution.');
+  }
+  if (transcript.completion.attemptId && transcript.completion.attemptId !== attemptId) {
+    throw new Error('The failed attempt is no longer the latest execution.');
+  }
+  if (message.role !== 'user') return null;
+  return { index, message };
+}