mixdog 1.2.3 → 1.2.5

package/src/tui/session/session-api/routes.mjs

@@ -4,8 +4,7 @@
  * definitions, output style and orchestration mode.
  */
 import { modelSwitchItem } from '../../../runtime/agent/orchestrator/session/transcript-restore/restore.mjs';
-import { selectedModel, switchesSessionModel } from '../../../session-runtime/model-route/model-switch-target.mjs';
-import { latestQuotaFailure } from '../quota-resume.mjs';
+import { selectedModel } from '../../../session-runtime/model-route/model-switch-target.mjs';
 import { createApiHelpers } from './shared.mjs';
 
 // Optimistic route preview: the requested provider/model/effort/fast are
@@ -50,6 +49,36 @@ function optimisticRoutePatch(requested = {}, current = {}) {
   return patch;
 }
 
+const SESSION_ONLY_KEYS = new Set(['provider', 'model', 'effort', 'fast', 'autoEffort']);
+
+/**
+ * A session-only request (an agent child's route) may name just the model, just
+ * the tuning, or both. Completed here, inside the serialized route write,
+ * against the latest selected route — so a Fast-only change keeps the effort a
+ * previous write selected. `unchanged` when it asks for nothing the selected
+ * route does not already have.
+ */
+function completeSessionOnlyRequest(request, selected) {
+  const named = Boolean(request.provider || request.model);
+  const target = named ? request : { ...request, provider: selected.provider, model: selected.model };
+  const sameModel = target.provider === selected.provider && target.model === selected.model;
+  if (!sameModel) return { request: target, unchanged: false };
+  const unchanged =
+    Object.keys(request).every((key) => SESSION_ONLY_KEYS.has(key)) &&
+    (request.effort === undefined || request.effort === selected.effort) &&
+    (request.fast === undefined || request.fast === (selected.fast === true)) &&
+    (request.autoEffort === undefined || request.autoEffort === (selected.autoEffort !== false));
+  return {
+    unchanged,
+    request: {
+      ...(selected.effort ? { effort: selected.effort } : {}),
+      fast: selected.fast === true,
+      autoEffort: selected.autoEffort !== false,
+      ...target,
+    },
+  };
+}
+
 /** The live divider of an in-place model switch (restored from message meta
  *  after a reload); every switch path publishes it the same way. */
 export function publishModelSwitch(bag, modelSwitch) {
@@ -76,6 +105,8 @@ export function createSessionRouteApi(bag) {
   });
   let routeWrite = null;
   let routeSequence = 0;
+  // Whether this API (not another command) is the one holding commandBusy.
+  let routeLocked = false;
 
   // A preset selector previews as the preset's model, never as its id.
   const previewedRequest = (routeOpts) => {
@@ -84,86 +115,79 @@ export function createSessionRouteApi(bag) {
     return target.provider ? { ...routeOpts, ...target } : routeOpts;
   };
 
-  // Auto-compact on model change (default on): compact on the CURRENT model,
-  // whose cache and window still hold the history, before the switch. A model
-  // stopped on its quota cannot run it; the next turn's auto-compaction on the
-  // new model fits the history instead. A failure never blocks the switch.
-  const compactBeforeModelSwitch = async () => {
-    if (runtime.getCompactionSettings?.()?.onModelChange === false) return;
-    if (latestQuotaFailure(getState().items)) return;
-    if (typeof bag.compactBeforeModelSwitch !== 'function') return;
-    set({
-      commandStatus: { active: true, verb: 'Compacting conversation', startedAt: Date.now(), mode: 'compacting' },
-    });
-    flushEmitImmediate();
-    try {
-      await bag.compactBeforeModelSwitch();
-    } catch {
-      /* the switch goes ahead; next-turn auto-compaction fits the window */
-    } finally {
-      set({ commandStatus: null });
-    }
-  };
-
   const setRoute = async (opts) => {
-    if (getState().commandBusy && !routeWrite) return false;
     const routeOpts = opts && typeof opts === 'object' ? opts : {};
-    // Every user model choice on this surface (composer picker, /model,
-    // presets, the TUI picker) switches the conversation itself in place.
-    const switchesModel = switchesSessionModel(runtime, routeOpts);
-    // A running turn keeps the route it started on.
-    if (switchesModel && getState().busy) {
-      throw new Error('The model cannot change while a response is running. Try again when it finishes.');
-    }
-    // Any route change supersedes waiting for the old route's quota reset.
-    bag.supersedeQuotaResume?.(getState().sessionId);
+    // All model pickers save a selection for the conversation's next turn; a
+    // running turn keeps the session model it started on. A selection is never
+    // refused: another command's lock neither blocks it nor is released by it.
     const token = ++routeSequence;
     const previousWrite = routeWrite;
+    // The session generation this selection was made under. The write below
+    // waits behind earlier ones, so "current" is never read later: the runtime
+    // validates this token before every route side effect, and `settle` below
+    // is the only place the display is touched once the write has started.
+    const originGeneration = runtime.sessionGeneration;
+    const owned = () => runtime.sessionGeneration === originGeneration;
     const preview = optimisticRoutePatch(previewedRequest(routeOpts), getState());
     // Preview immediately, serialize persistence without dropping a later
     // click. Earlier completions cannot replace the newest visible choice.
-    // A model switch previews once its pre-compaction (which republishes the
-    // current route) is done.
-    set({ commandBusy: true, ...(switchesModel ? {} : preview || {}) });
+    if (!getState().commandBusy) routeLocked = true;
+    set({ ...(routeLocked ? { commandBusy: true } : {}), ...(preview || {}) });
     flushEmitImmediate();
     const write = (async () => {
       if (previousWrite) await previousWrite.catch(() => {});
       const previousRoute = routeState();
+      // A stale selection only republishes the route that is actually
+      // selected; it never restores or announces its own session's state.
+      const settle = ({ failed = false, sync = false, modelSwitch = null } = {}) => {
+        const stillOwned = owned();
+        if (stillOwned) publishModelSwitch(bag, modelSwitch);
+        // A newer selection publishes the final route itself.
+        if (token !== routeSequence) return;
+        if (stillOwned && failed) {
+          if (preview) set({ ...previousRoute, stats: { ...getState().stats } });
+          return;
+        }
+        if (stillOwned && sync) syncContextStats({ allowEstimated: true });
+        publishRoute();
+      };
       try {
-        // Explicit addressing applies the route to this session: an empty
-        // one is initialized in place. Either way an established
-        // conversation follows the user's choice in place.
+        // Keep the durable session address while deferring route application.
         const applyToCurrentSession = routeOpts.applyToCurrentSession === true;
-        const keepMainModel = routeOpts.keepMainModel === true;
-        const { applyToCurrentSession: _drop, keepMainModel: _keep, ...nextRoute } = routeOpts;
-        if (switchesModel) {
-          // The destination must be accepted before the history is compacted.
-          await runtime.setRoute(nextRoute, { validateOnly: true });
-          await compactBeforeModelSwitch();
-          if (token === routeSequence && preview) {
-            set(preview);
-            flushEmitImmediate();
+        const keepMainModel = routeOpts.keepMainModel !== false;
+        const sessionOnly = routeOpts.sessionOnly === true;
+        const { applyToCurrentSession: _drop, keepMainModel: _keep, sessionOnly: _scope, ...requested } = routeOpts;
+        let nextRoute = requested;
+        if (sessionOnly) {
+          const completed = completeSessionOnlyRequest(requested, previousRoute);
+          if (completed.unchanged) {
+            // An earlier failed write skipped its rollback because this one is
+            // newer, so the shown route may still be that write's preview.
+            settle();
+            return previousRoute;
           }
+          nextRoute = completed.request;
         }
         const resolvedRoute = await runtime.setRoute(nextRoute, {
           applyToCurrentSession,
           keepMainModel,
+          ...(sessionOnly ? { sessionOnly } : {}),
+          ...(originGeneration !== undefined ? { originGeneration } : {}),
           switchEstablished: true,
+          deferUntilNextTurn: true,
+        });
+        settle({
+          sync: applyToCurrentSession || Boolean(resolvedRoute?.modelSwitch),
+          modelSwitch: resolvedRoute?.modelSwitch,
         });
-        if (token === routeSequence) {
-          if (applyToCurrentSession || resolvedRoute?.modelSwitch) syncContextStats({ allowEstimated: true });
-          publishRoute();
-        }
-        publishModelSwitch(bag, resolvedRoute?.modelSwitch);
         return resolvedRoute;
       } catch (error) {
-        if (token === routeSequence && preview) {
-          set({ ...previousRoute, stats: { ...getState().stats } });
-        }
+        settle({ failed: true });
         throw error;
       } finally {
         if (token === routeSequence) {
-          set({ commandBusy: false });
+          if (routeLocked) set({ commandBusy: false });
+          routeLocked = false;
           // Publish the resolved route (or rollback) before an RPC reply
           // reads getState(), even while the display-frame clock is busy.
           flushEmitImmediate();

package/src/tui/session/session-api/settings.mjs

@@ -29,9 +29,9 @@ export function createSessionSettingsApi(bag) {
 
   return {
     // A model selector (/model, a preset) is the user's model choice like any
-    // picker selection: the route surface switches an established
-    // conversation in place (pre-compaction, busy refusal, divider). False
-    // while another command holds the lock.
+    // picker selection: the route surface saves it for the conversation's
+    // next turn (a running turn keeps its model) and applies it there. Never
+    // refused: another command's lock does not block a selection.
     setModel: async (m) => (await bag.setSessionRoute({ model: m })) !== false,
     setEffort: withCommandLock(
       async (value) => {

package/src/tui/session/session-api/worktree.mjs

@@ -23,8 +23,7 @@
  *     (expectedRevision: WORKTREE_REVISION_CONFLICT when the session moved on)
  *     (WORKTREE_REMOVAL_INCOMPLETE: partly removed; call again to finish)
  *   listWorktrees()                                → every managed worktree with its retention
- *   pruneWorktrees()                               → reconcile report (never a retained worktree)
- */
+ *   pruneWorktrees()                               → reconcile report (never a retained worktree) */
 import { worktreeError } from '../../../runtime/shared/worktrees/contract.mjs';
 
 /** Session actions of the Lead worktree feature (settings live in settings.mjs). */
@@ -34,6 +33,8 @@ export const SESSION_WORKTREE_ACTIONS = Object.freeze([
   'selectBranch',
   'selectProjectBranch',
   'mergeProjectBranch',
+  'inspectProjectBranch',
+  'manageProjectBranch',
   'requestWorktree',
   'mergeWorkspace',
   'removeWorktree',

package/src/tui/session/session-flow/auto-clear.mjs

@@ -196,10 +196,8 @@ export function createAutoClearOps(bag, { reset, kickDrain }) {
 
   // Same eligibility as a user submit, run before a completion wake turn so a
   // cold cache after a long idle is compacted first. Never throws: a skipped or
-  // failed auto-clear must still let the wake run. A viewer mirroring another
-  // surface's owner leaves compaction to that owner.
+  // failed auto-clear must still let the wake run.
   async function autoClearBeforeWake() {
-    if (bag.liveShareMirroring?.() === true) return false;
     try {
       return await autoClearBeforeSubmit({ ignorePending: true });
     } catch {

package/src/tui/session/session-flow/drain.mjs

@@ -89,6 +89,8 @@ export function turnOptionsForBatch(batch, steering) {
   return {
     promptSource: batchPromptSource(batch),
     retryFailedTurn: batch[0]?.retryFailedTurn === true,
+    retryTurnId: batch[0]?.retryTurnId || null,
+    retryAttemptId: batch[0]?.retryAttemptId || null,
     displayText: batch
       .map((entry) => entry.text)
       .filter((text) => String(text || '').trim())
@@ -148,7 +150,7 @@ export function createDrainLoop(
   // matching message under its own lock).
   function rewindFailedTurnRows(batch) {
     const entry = batch[0];
-    if (entry?.retryFailedTurn !== true) return;
+    if (entry?.retryFailedTurn !== true || entry.retryTurnId) return;
     const rewound = rewoundFailedTurnItems(getState().items, entry.text);
     if (!rewound) return;
     set({
@@ -217,7 +219,7 @@ export function createDrainLoop(
     // but so do setModel/newSession/resume/etc). Running a turn concurrently
     // with a command that swaps or reroutes the live session is a race; the
     // commandBusy-release hook re-kicks drain once the command finishes.
-    if (flags.autoClearRunning || getState().commandBusy) {
+    if (flags.autoClearRunning || flags.quotaResumePending || getState().commandBusy) {
       scheduleBlockedDrainRetry();
       return;
     }
@@ -253,7 +255,7 @@ export function createDrainLoop(
         // its pre-compaction, a reset) runs before the next turn starts. The
         // finally below re-enters drain(), which waits on the same gate, and
         // the commandBusy release re-kicks the queue.
-        if (flags.autoClearRunning || getState().commandBusy) return;
+        if (flags.autoClearRunning || flags.quotaResumePending || getState().commandBusy) return;
         // Drain one priority/mode bucket at a time (unified command queue):
         // prompt steering stays editable and task notifications stay
         // non-editable but model-visible.
@@ -331,7 +333,7 @@ export function createDrainLoop(
     submissions.remember(submissionId);
     pending.push(entry);
     const needsDurableSteering =
-      (getState().busy || getState().commandBusy || flags.autoClearRunning) &&
+      (getState().busy || getState().commandBusy || flags.autoClearRunning || flags.quotaResumePending) &&
       steering.shouldMirrorSteeringEntry(entry);
     const persistence = needsDurableSteering ? appendTuiSteeringPersist(steering.leadSessionId(), entry) : null;
     if (isQueuedEntryVisible(entry)) {

package/src/tui/session/session-flow/queue/entry-shape.mjs

@@ -49,5 +49,7 @@ export function makeQueueEntry(text, options = {}, nextId) {
     // Retry of a failed turn: the transcript and the session rewind the
     // failed turn's unanswered prompt before this entry runs.
     retryFailedTurn: options.retryFailedTurn === true,
+    retryTurnId: options.retryTurnId || null,
+    retryAttemptId: options.retryAttemptId || null,
   };
 }

package/src/tui/session/session-flow/queue/take-entries.mjs

@@ -39,10 +39,11 @@ export function createTakeEntriesOps({ pending, pendingNotificationKeys, removeQ
         (entry.mode || 'prompt') === targetMode &&
         queuePriorityValue(entry.priority) === bestPriority
       ) {
+        if (batch.length > 0 && entry.retryTurnId) break;
         batch.push(entry);
         pending.splice(i, 1);
         if (entry.mode === 'task-notification' && entry.key) pendingNotificationKeys.delete(entry.key);
-        if (batch.length >= limit) break;
+        if (entry.retryTurnId || batch.length >= limit) break;
       } else {
         i += 1;
       }

package/src/tui/session/session-flow/queue.mjs

@@ -14,7 +14,7 @@ import { createTakeEntriesOps } from './queue/take-entries.mjs';
 
 // Submission-id memory for idempotent re-delivery. A prompt can legitimately
 // reach this queue TWICE when its transport retries across a failed response
-// (daemon view retry, live-share spool fallback after a missing ack). The id
+// (daemon view retry after a missing ack). The id
 // the surface minted is the identity of the message, so a repeat of an id we
 // already queued is dropped instead of posting the prompt twice.
 const SUBMISSION_ID_MEMORY = 256;

package/src/tui/session/tool-approval.mjs

@@ -12,8 +12,14 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
 
   function normalizeToolApprovalRequest(input = {}, id = nextId()) {
     const now = Date.now();
+    // An explicit `timeoutMs: null` means no wait limit (no timer, no expiry);
+    // any other missing/invalid value falls back to the session default.
     const requestTimeoutMs =
-      Number.isFinite(Number(input?.timeoutMs)) && Number(input.timeoutMs) > 0 ? Number(input.timeoutMs) : timeoutMs;
+      input?.timeoutMs === null
+        ? null
+        : Number.isFinite(Number(input?.timeoutMs)) && Number(input.timeoutMs) > 0
+          ? Number(input.timeoutMs)
+          : timeoutMs;
     return {
       id,
       name: String(input?.name || input?.tool_name || 'tool'),
@@ -25,14 +31,14 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
       reason: String(input?.reason || input?.message || 'approval requested by hook').trim(),
       requestedAt: now,
       timeoutMs: requestTimeoutMs,
-      expiresAt: now + requestTimeoutMs,
+      expiresAt: requestTimeoutMs === null ? null : now + requestTimeoutMs,
     };
   }
   // Every request expires from ITS OWN requestedAt, queued or active. Arming
   // the timer only on presentation let a queued request sit past expiresAt
   // (retaining its promise and surfacing an obsolete approval later).
   function armToolApprovalTimeout(entry) {
-    if (!entry || entry.timer) return;
+    if (!entry || entry.timer || entry.request?.expiresAt === null) return;
     const remainingMs = Math.max(0, Number(entry.request?.expiresAt || 0) - Date.now());
     entry.timer = setTimeout(() => {
       finishToolApproval(entry.id, false, 'approval timed out');
@@ -42,10 +48,13 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
   // Settle one entry: drop its timeout, then hand the waiter its answer. The
   // resolve stays guarded — a waiter whose caller already went away must never
   // take the rest of the queue down with it.
-  function settleToolApproval(entry, approved, reason, answers) {
+  function settleToolApproval(entry, approved, reason, answers, reply) {
     if (entry?.timer) clearTimeout(entry.timer);
+    const result = { approved, reason };
+    if (answers !== undefined) result.answers = answers;
+    if (reply !== undefined) result.reply = reply;
     try {
-      entry.resolve(answers === undefined ? { approved, reason } : { approved, reason, answers });
+      entry.resolve(result);
     } catch {}
   }
   function presentNextToolApproval() {
@@ -59,7 +68,7 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
     armToolApprovalTimeout(entry);
     set({ toolApproval: entry.request });
   }
-  function finishToolApproval(id, approved, reason = '', device = '', answers = undefined) {
+  function finishToolApproval(id, approved, reason = '', device = '', answers = undefined, reply = undefined) {
     const targetId = String(id || '');
     if (activeToolApproval && activeToolApproval.id === targetId) {
       const entry = activeToolApproval;
@@ -70,14 +79,14 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
         ? { id: targetId, approved: approved === true, device: String(device), at: Date.now() }
         : null;
       set({ toolApproval: null, toolApprovalResult });
-      settleToolApproval(entry, approved === true, String(reason || ''), answers);
+      settleToolApproval(entry, approved === true, String(reason || ''), answers, reply);
       presentNextToolApproval();
       return true;
     }
     const index = toolApprovalQueue.findIndex((entry) => entry.id === targetId);
     if (index >= 0) {
       const [entry] = toolApprovalQueue.splice(index, 1);
-      settleToolApproval(entry, approved === true, String(reason || ''), answers);
+      settleToolApproval(entry, approved === true, String(reason || ''), answers, reply);
       return true;
     }
     return false;

package/src/tui/session/transcript-store/streaming-tail.mjs

@@ -4,7 +4,7 @@
  * that lets a host prove a longer text is an append of the same stream.
  */
 // Non-enumerable so the marker never enters persisted transcript items,
-// live-share JSON, or renderer snapshots. The desktop host reads the shared
+// wire JSON, or renderer snapshots. The desktop host reads the shared
 // Symbol.for key before cloning and uses it to prove that a growing text is
 // an append, avoiding an O(total text) startsWith check on every frame.
 const streamingTailTextEpochKey = Symbol.for('mixdog.streaming-tail-text-epoch');

package/src/tui/session/tui-steering-persist.mjs

@@ -99,11 +99,9 @@ function normalizePendingStore(raw) {
       // FOREIGN bucket. This file is SHARED with the runtime/manager pending
       // -message spool, and every TUI write passes the whole store through
       // here. Flattening those rows to plain strings destroyed id,
-      // enqueuedAt, options, structured content, the notification markers —
-      // and the handoffAt/handoffPid parking stamp that is the only reason an
-      // accepted-but-undelivered user message survives an owner crash. Rows
-      // this process does not own are copied through UNCHANGED (array copy
-      // only, so nothing here can alias-mutate them either).
+      // enqueuedAt, options, structured content and the notification markers.
+      // Rows this process does not own are copied through UNCHANGED (array
+      // copy only, so nothing here can alias-mutate them either).
       out.sessions[sid] = value.slice();
       const foreignTouched = Number(touchedRaw[sid]);
       // Carry an existing stamp only: inventing one would reset the runtime's

package/src/tui/session/turn-quiet.mjs

@@ -0,0 +1,53 @@
+// The lead turn's quiet-time cue: polls the runtime's turn liveness while the
+// turn runs and publishes `spinner.quiet` ({ since, wait, tool?, warnMs })
+// once the turn has gone QUIET_PROGRESS_CUE_MS without counted progress, and
+// clears it when progress resumes. The value is frozen for a whole silence, so
+// a silence costs two publications, never one per tick. Display only.
+import { displayProgressStage, quietProgress, lastProgressAt } from '../../runtime/shared/quiet-progress.mjs';
+import { resolveAgentStallThresholds } from '../../runtime/agent/orchestrator/stall-policy.mjs';
+
+const QUIET_POLL_MS = 1_000;
+
+/** The lead's stall-watchdog warn point, in ms. */
+export function leadStallWarnMs() {
+  return resolveAgentStallThresholds('lead').warn * 1000;
+}
+
+function sameQuiet(left, right) {
+  if (!left || !right) return !left && !right;
+  return left.since === right.since && left.wait === right.wait && left.tool === right.tool;
+}
+
+/** The quiet state a liveness snapshot implies at `now` (null: not quiet). */
+export function turnQuietState(liveness, now, warnMs) {
+  if (!liveness || typeof liveness !== 'object' || typeof liveness.then === 'function') return null;
+  const quiet = quietProgress({
+    progressAt: lastProgressAt(liveness),
+    stage: displayProgressStage(liveness),
+    tool: liveness.currentTool,
+    now,
+  });
+  return quiet ? { ...quiet, warnMs } : null;
+}
+
+export function startQuietWatch({ runtime, getState, set, isCurrentTurn, warnMs = leadStallWarnMs() }) {
+  const timer = setInterval(() => {
+    if (!isCurrentTurn()) {
+      clearInterval(timer);
+      return;
+    }
+    const spinner = getState().spinner;
+    if (!spinner) return;
+    let liveness = null;
+    try {
+      liveness = runtime?.getTurnLiveness?.() ?? null;
+    } catch {
+      return;
+    }
+    const next = turnQuietState(liveness, Date.now(), warnMs);
+    if (sameQuiet(spinner.quiet ?? null, next)) return;
+    set({ spinner: { ...spinner, quiet: next } });
+  }, QUIET_POLL_MS);
+  timer.unref?.();
+  return () => clearInterval(timer);
+}

package/src/tui/session/turn-stream.mjs

@@ -6,6 +6,7 @@
 // scalars); every function here takes it as its first argument.
 import { TUI_FRAME_MS, yieldToRenderer } from './render-timing.mjs';
 import { retryStatusLine } from '../../runtime/shared/err-text.mjs';
+import { MODEL_THINKING_STAGE } from '../../runtime/shared/quiet-progress.mjs';
 import { newTranscriptMessageId } from '../../runtime/shared/transcript-metadata.mjs';
 
 // Share Ink's exact 120fps cadence with the frame-batched store. A separate
@@ -590,9 +591,12 @@ export async function applyStageChange(stream, stage, detail = null) {
     await yieldToRenderer();
     return;
   }
-  if (value === 'requesting' || value === 'streaming') stream.compactingActive = false;
+  if (value === 'requesting' || value === 'streaming' || value === MODEL_THINKING_STAGE) {
+    stream.compactingActive = false;
+  }
   let mode = null;
   if (value === 'requesting') mode = 'requesting';
+  else if (value === MODEL_THINKING_STAGE) mode = 'model-thinking';
   else if (value === 'streaming') mode = getState().spinner.thinking ? 'thinking' : 'responding';
   if (!mode || getState().spinner.mode === mode) return;
   set({ spinner: { ...getState().spinner, mode } });

package/src/tui/session/turn.mjs

@@ -7,15 +7,20 @@
  * turn record below that finalization publishes as the turndone item.
  */
 import { applyUsageDelta } from './session-stats.mjs';
+import {
+  createTranscriptRouteMetadata,
+  transcriptRouteMetadataFields,
+} from '../../runtime/shared/transcript-metadata.mjs';
+import { publishModelSwitch } from './session-api/routes.mjs';
 import { compactEventLabel } from '../../runtime/shared/compact-event-label.mjs';
 import { pickVerb, pickDoneVerb, compactEventDetail } from './labels.mjs';
-import { toolErrorDisplay } from './tool-result-text.mjs';
-import { errText, isCancelLikeError } from '../../runtime/shared/err-text.mjs';
+import { isCancelLikeError } from '../../runtime/shared/err-text.mjs';
 import { preserveGoalStateAfterTurn } from './goal-turn-state.mjs';
 export { preserveGoalStateAfterTurn } from './goal-turn-state.mjs';
 export { transcriptToolCallDisplayMode } from './turn-tool-cards.mjs';
-import { isRejected429, safeErrorDetails } from '../../runtime/shared/error-presentation.mjs';
+import { isRejected429 } from '../../runtime/shared/error-presentation.mjs';
 import { QUOTA_KINDS, providerErrorKind } from '../../runtime/agent/orchestrator/providers/provider-error-kind.mjs';
+import { turnFailureRecord } from '../../runtime/agent/orchestrator/session/turn-failure.mjs';
 import { registerTaskWaitSteeringCheck } from '../../runtime/agent/orchestrator/session/task-wait-control.mjs';
 import { promptDisplayText, STEERING_SUPPRESSED_DISPLAY } from './queue-helpers.mjs';
 import { yieldToRenderer } from './render-timing.mjs';
@@ -47,6 +52,7 @@ import {
   collectClosingCards,
   startLiveTail,
 } from './turn-tool-cards.mjs';
+import { startQuietWatch } from './turn-quiet.mjs';
 
 // A usage limit is exactly a spent quota, a plan-gated feature or a billing
 // refusal; overloads, rate limits and server faults recover by waiting.
@@ -94,6 +100,13 @@ function streamingTailStore({ updateStreamingTail, settleStreamingTail, clearStr
 
 // The turn record: identity, transcript metadata, and the outcome fields
 // finalization publishes.
+export function applyTurnRouteMetadata(ctx, session) {
+  const metadata = transcriptRouteMetadataFields(createTranscriptRouteMetadata(session));
+  Object.assign(ctx.turn.transcriptMeta, metadata);
+  Object.assign(ctx.turn.routeMeta, metadata);
+  for (const id of ctx.turn.submittedIds) ctx.patchItem(id, metadata);
+}
+
 function beginTurn({ flags, getState, transcriptRouteMetadata }, options) {
   const index = getState().stats.turns || 0;
   const startedAt = Date.now();
@@ -102,6 +115,7 @@ function beginTurn({ flags, getState, transcriptRouteMetadata }, options) {
     ...(flags.pendingTranscriptMeta || transcriptRouteMetadata?.(startedAt) || { at: startedAt }),
     ...(options.transcriptMeta && typeof options.transcriptMeta === 'object' ? options.transcriptMeta : {}),
     completionVerb,
+    attemptId: globalThis.crypto.randomUUID(),
   };
   flags.pendingTranscriptMeta = null;
   // The prompt's own time and stable id stay on the prompt row.
@@ -457,34 +471,13 @@ export function failTurn(ctx, error) {
   }
   turn.failed = true;
   cards.aggregates.finalizeToolHeaders();
-  // Presentation only: legacy untyped failure text may still name a usage limit.
-  const errorKind = providerErrorKind(error, { legacyQuotaWording: true });
+  const record = turnFailureRecord(error, { provider: turn.routeMeta?.provider, model: turn.routeMeta?.model });
   // The UI reads this descriptor instead of re-parsing the error text.
-  turn.errorKind = {
-    kind: errorKind.kind,
-    code: errorKind.code,
-    status: errorKind.status,
-    retryAfterMs: errorKind.retryAfterMs,
-    resetAt: errorKind.resetAt,
-  };
-  turn.usageLimited = isUsageLimitError(error, errorKind);
-  const exhausted = error?.quotaExhausted;
-  // Quota metadata: the pool's validated exhaustion, or a spent quota whose
-  // provider named the real reset time.
-  const resetKnown = errorKind.kind === 'quota_exhausted' && Number.isFinite(errorKind.resetAt);
-  if ((exhausted && typeof exhausted === 'object') || resetKnown) {
-    const source = exhausted && typeof exhausted === 'object' ? exhausted : {};
-    let resetAt = null;
-    if (Number.isFinite(source.resetAt)) resetAt = source.resetAt;
-    else if (Number.isFinite(errorKind.resetAt)) resetAt = errorKind.resetAt;
-    turn.quota = {
-      provider: String(source.provider || turn.routeMeta?.provider || ''),
-      model: String(source.model || turn.routeMeta?.model || ''),
-      resetAt,
-    };
-  }
-  turn.failureDetail = toolErrorDisplay(error, 'turn').replace(/^Error:\s*/i, '');
-  turn.failureDiagnostic = safeErrorDetails(errText(error));
+  turn.errorKind = record.errorKind;
+  turn.usageLimited = isUsageLimitError(error, record.providerKind);
+  if (record.quota) turn.quota = record.quota;
+  turn.failureDetail = record.detail;
+  turn.failureDiagnostic = record.errorDetails;
   pushNotice(turn.failureDetail, 'error', { owner: 'transcript' });
 }
 
@@ -683,7 +676,12 @@ export function createRunTurn(bag) {
       routeMeta: turn.routeMeta,
       sealToolBlock: cards.aggregates.clearAggregateContinuation,
     });
-    const stopLiveTail = startLiveTail(cards);
+    const stopToolTail = startLiveTail(cards);
+    const stopQuietWatch = startQuietWatch({ runtime, getState, set, isCurrentTurn });
+    const stopLiveTail = () => {
+      stopToolTail();
+      stopQuietWatch();
+    };
     const ctx = {
       ...bag,
       bag,
@@ -703,11 +701,20 @@ export function createRunTurn(bag) {
         submittedAt: options.submittedAt,
         promptSource: options.promptSource,
         retryFailedTurn: options.retryFailedTurn === true,
+        retryTurnId: options.retryTurnId,
+        retryAttemptId: options.retryAttemptId,
         transcriptMeta: turn.transcriptMeta,
         context: options.context || null,
         ...turnHandlers(ctx),
         ...toolHandlers(ctx),
         ...streamHandlers(ctx),
+        onRouteApplied: (session) => {
+          if (isCurrentTurn()) applyTurnRouteMetadata(ctx, session);
+        },
+        onModelSwitch: (boundary) => {
+          if (!isCurrentTurn()) return;
+          publishModelSwitch(bag, boundary);
+        },
       });
       if (!isCurrentTurn()) turn.cancelled = true;
       else completeTurn(ctx, result, session);