mixdog 1.2.1 → 1.2.2

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

@@ -12,6 +12,7 @@ import {
   isRetryableWireErrorEvent,
   isRetryableStreamErrorEvent,
   isProviderRecoveryExhausted,
+  isProviderRecoveryTerminal,
   isServerUnavailable,
   isStreamCut,
   isToolInputCut,
@@ -20,7 +21,9 @@ import {
   resetStallRetryBudget,
   resolveStallRetryBudget,
   retryAfterMsFromError,
+  sleepWithAbort,
 } from '../providers/retry-classifier.mjs';
+import { DETERMINISTIC_KINDS, providerErrorKind } from '../providers/provider-error-kind.mjs';
 import {
   persistsConfirmedImageRejection,
   promptHasInlineImages,
@@ -34,7 +37,6 @@ import {
   isThinkingReplayRejection,
   repairThinkingReplayInPlace,
 } from './thinking-replay-recovery.mjs';
-import { setTimeout as sleepMs } from 'node:timers/promises';
 import { readStreamOutcome } from '../providers/lib/stream-outcome.mjs';
 import { cloneProviderReplay } from '../providers/lib/provider-replay.mjs';
 import { resolveWorkerCompactPolicy } from './loop/compact-policy.mjs';
@@ -126,10 +128,10 @@ const RECOVERY_RETRY_BACKOFF_MS = retryLadderFromEnv(
   [15_000, 30_000, 60_000, 60_000, 60_000]
 );
 
-// A server-advised wait (Retry-After) replaces the ladder step: a provider that
-// names its own cooldown knows better, within reason — one loop-level wait
-// never parks longer than this.
-const LOOP_RETRY_AFTER_CAP_MS = 120_000;
+// A server-advised wait (Retry-After / retryAfterMs) replaces the ladder step
+// and is honored in full, never shortened. The ladder length
+// still bounds how many replays run, the wait stays cancellable, and the
+// reconnecting stage reports its remaining delay (retryAt).
 
 // Jittering every backoff by 0.9–1.1 means parallel workers that lose the
 // same uplink do not resume in lockstep; our provider layers already jitter
@@ -138,14 +140,42 @@ const TRANSPORT_RETRY_JITTER_RATIO = 0.1;
 
 /** The ladder this failure class is entitled to: an unreachable network, a
  *  provider still unavailable after its own retries, or an ordinary fault. */
-function retryLadderFor(error) {
+function retryLadderFor(error, state = null) {
   if (isConnectFailure(error)) return CONNECTION_RETRY_BACKOFF_MS;
-  if (isProviderRecoveryExhausted(error) && isServerUnavailable(error)) return RECOVERY_RETRY_BACKOFF_MS;
+  if (isProviderRecoveryExhausted(error) && isServerUnavailable(error) && recoveryCyclesEnabled(state)) {
+    return RECOVERY_RETRY_BACKOFF_MS;
+  }
   return TRANSPORT_RETRY_BACKOFF_MS;
 }
 
-function retryBudgetFor(error) {
-  return retryLadderFor(error).length;
+// retryPolicy.recoveryCycles:false — a provider that already ran its own full
+// ladder surfaces its spent failure instead of parking on
+// the 15/30/60/60/60s recovery cycles.
+function recoveryCyclesEnabled(state) {
+  return loopRetryPolicy(state).recoveryCycles !== false;
+}
+
+// Per-provider loop retry policy, read off the provider object
+// (`provider.retryPolicy`), default = the bounded ladders:
+//   unboundedConnectionRetry — a connect failure keeps waiting on the
+//     5/10/20/40/60s… ladder (last step repeating) until the network returns;
+//     still cancellable, with "waiting for network" progress.
+//   contentFilterRetryable   — a content_filter refusal is replayed
+//     under the transport budget with a contextual guidance notice.
+//   inBandInvalidRequestRetryable — an in-band stream error whose only
+//     deterministic evidence is its invalid_request envelope is replayed.
+function loopRetryPolicy(state) {
+  const policy = state?.provider?.retryPolicy;
+  return policy && typeof policy === 'object' ? policy : {};
+}
+
+function waitsForNetwork(error, state) {
+  return loopRetryPolicy(state).unboundedConnectionRetry === true && isConnectFailure(error);
+}
+
+function retryBudgetFor(error, state = null) {
+  if (waitsForNetwork(error, state)) return Number.POSITIVE_INFINITY;
+  return retryLadderFor(error, state).length;
 }
 
 // A provider ladder spent on a connect failure has only shown that the network
@@ -153,15 +183,19 @@ function retryBudgetFor(error) {
 // unavailable parks on the recovery cycles, but only while nothing has reached
 // the user — a replay would otherwise re-show output or re-run a tool. Every
 // other exhausted failure surfaces as-is.
-function providerRecoveryEnded(error, outcome) {
+// A provider VERDICT that recovery is over (an advice-gated denial, the
+// repeated-overload stop) always ends it: the loop never overrides it.
+function providerRecoveryEnded(error, outcome, state = null) {
+  if (isProviderRecoveryTerminal(error)) return true;
   if (!isProviderRecoveryExhausted(error) || isConnectFailure(error)) return false;
+  if (!recoveryCyclesEnabled(state)) return true;
   return !(outcome.replaySafe === true && isServerUnavailable(error));
 }
 
-function transportRetryWaitMs(attemptIndex, error) {
+function transportRetryWaitMs(attemptIndex, error, state = null) {
   const advisedMs = retryAfterMsFromError(error);
-  if (advisedMs != null) return Math.min(advisedMs, LOOP_RETRY_AFTER_CAP_MS);
-  const ladder = retryLadderFor(error);
+  if (advisedMs != null) return advisedMs;
+  const ladder = retryLadderFor(error, state);
   const base = ladder[Math.min(Math.max(attemptIndex, 0), ladder.length - 1)];
   return jitterDelayMs(base, TRANSPORT_RETRY_JITTER_RATIO);
 }
@@ -258,6 +292,46 @@ function traceLoop({ sessionId, nextIteration }, kind, fields) {
 // 5s/15s wait rendered as a frozen turn with no explanation, so the stage
 // change surfaces "Reconnecting... n/max" instead of leaving the user
 // staring at a stalled stream.
+// Unbounded connect-failure wait (retryPolicy.unboundedConnectionRetry): no
+// "n/max" — the turn waits until the network is back, counting down each step.
+function emitWaitingForNetwork(opts, { attempt, waitMs, classifier, error }) {
+  if (typeof opts?.onStageChange !== 'function') return;
+  try {
+    const wait = Math.max(0, Number(waitMs) || 0);
+    opts.onStageChange('reconnecting', {
+      attempt,
+      max: null,
+      waitMs: wait,
+      retryAt: Date.now() + wait,
+      reason: 'waiting for network',
+      waitingForNetwork: true,
+      classifier: classifier || error?.code || null,
+      message: `Reconnecting… waiting for network · attempt ${attempt}${wait > 0 ? ` in ${Math.ceil(wait / 1000)}s` : ''}`,
+    });
+  } catch {
+    /* display-only */
+  }
+}
+
+// content_filter on a path that opted in (retryPolicy.contentFilterRetryable,
+// or the provider boundary stamping `contentFilterRetryable` on the error).
+// A provider-terminal verdict outranks the opt-in.
+function isReplayableContentFilter(sendErr, state) {
+  if (isProviderRecoveryTerminal(sendErr)) return false;
+  const optedIn = loopRetryPolicy(state).contentFilterRetryable === true || sendErr?.contentFilterRetryable === true;
+  return optedIn && providerErrorKind(sendErr).code === 'content_filter';
+}
+
+// The guidance travels as a contextual runtime fragment: the
+// [mixdog-runtime] prefix keeps it out of the visible transcript.
+const CONTENT_FILTER_NOTICE =
+  '[mixdog-runtime] The previous response was stopped by the provider content filter before it completed. ' +
+  'Continue the task, but rephrase or avoid the content that likely triggered the filter; do not repeat it verbatim.';
+
+function contentFilterNotice() {
+  return { role: 'user', content: CONTENT_FILTER_NOTICE, meta: { source: 'content-filter-recovery' } };
+}
+
 function emitLoopReconnectProgress(opts, { attempt, maxAttempts, waitMs, classifier, error }) {
   emitProviderRetryStage(opts?.onStageChange, {
     attempt,
@@ -353,10 +427,22 @@ async function recoverFromSendError(sendErr, state) {
   }
   // Clean transient transport failure with zero exposure: replay the send
   // after a bounded wait instead of failing the turn.
+  if (isReplayableContentFilter(sendErr, state)) {
+    if (transportRetriesUsed < TRANSPORT_RETRY_MAX && (outcome.replaySafe === true || (await retract()))) {
+      return scheduleTransportReplay(sendErr, state, {
+        budget: TRANSPORT_RETRY_MAX,
+        note: `[loop] content filter stopped the response (${loopTag(state)}); replaying with guidance`,
+        trace: { kind: 'content_filter_retry' },
+        classifier: 'content_filter',
+        notice: contentFilterNotice(),
+      });
+    }
+    throw sendErr;
+  }
   if (
-    transportRetriesUsed < retryBudgetFor(sendErr) &&
-    !providerRecoveryEnded(sendErr, outcome) &&
-    (await transportReplayPermitted(sendErr, outcome, retract))
+    transportRetriesUsed < retryBudgetFor(sendErr, state) &&
+    !providerRecoveryEnded(sendErr, outcome, state) &&
+    (await transportReplayPermitted(sendErr, outcome, retract, state))
   ) {
     return retryTransport(sendErr, state);
   }
@@ -373,7 +459,7 @@ async function recoverFromSendError(sendErr, state) {
   ) {
     return repairThinkingReplay(recoveryMessages, state);
   }
-  // Grok Build RetryWithImageStrip: drop inline images and replay once. Safe
+  // Image-strip retry: drop inline images and replay once. Safe
   // only when no tool was dispatched. Text exposure must be retracted first;
   // reasoning-only high-effort streams can retry without a text reset.
   if (
@@ -464,7 +550,7 @@ function isExposedNoToolStall(sendErr, outcome) {
 // 'transient' and never fired).
 async function recoverExposedStall(sendErr, outcome, state, retract) {
   const { transportRetriesUsed = 0 } = state;
-  const exposedRetryBudget = retryBudgetFor(sendErr);
+  const exposedRetryBudget = retryBudgetFor(sendErr, state);
   const len = sendErr.partialContent.length;
   if (transportRetriesUsed < exposedRetryBudget && !isProviderRecoveryExhausted(sendErr) && (await retract())) {
     return scheduleTransportReplay(sendErr, state, {
@@ -491,12 +577,17 @@ async function recoverExposedStall(sendErr, outcome, state, retract) {
 async function scheduleTransportReplay(sendErr, state, { budget, note, trace, classifier, notice = null }) {
   const { opts, signal, transportRetriesUsed = 0 } = state;
   const attempt = transportRetriesUsed + 1;
-  const waitMs = transportRetryWaitMs(transportRetriesUsed, sendErr);
+  const waitMs = transportRetryWaitMs(transportRetriesUsed, sendErr, state);
   logLoop(`${note}; transport retry ${attempt}/${budget} after ${waitMs}ms`);
   const { kind, ...fields } = trace;
   traceLoop(state, kind, { attempt, waitMs, ...fields });
-  emitLoopReconnectProgress(opts, { attempt, maxAttempts: budget, waitMs, classifier, error: sendErr });
-  await sleepMs(waitMs, undefined, signal ? { signal } : undefined);
+  if (Number.isFinite(budget)) {
+    emitLoopReconnectProgress(opts, { attempt, maxAttempts: budget, waitMs, classifier, error: sendErr });
+  } else {
+    emitWaitingForNetwork(opts, { attempt, waitMs, classifier, error: sendErr });
+  }
+  // Chunked, abortable sleep: honored advice may exceed one timer's range.
+  await sleepWithAbort(waitMs, signal, undefined, 'transport retry wait aborted');
   return beginFreshTransportAttempt(opts, budget, notice);
 }
 
@@ -542,7 +633,7 @@ function continueFromShownText(sendErr, state, relayWitness) {
 // budget still bounds it.
 async function recoverToolInputCut(sendErr, outcome, state, retract) {
   const { transportRetriesUsed = 0 } = state;
-  const budget = retryBudgetFor(sendErr);
+  const budget = retryBudgetFor(sendErr, state);
   if (transportRetriesUsed < budget && (outcome.replaySafe === true || (await retract()))) {
     return scheduleTransportReplay(sendErr, state, {
       budget,
@@ -650,20 +741,55 @@ function recoverPartialToolCalls(sendErr, state, toolCalls, outcome) {
 // reasoning/text exposure makes classifyError() intentionally permanent,
 // non-terminal close, or a dropped connection (undici `terminated`, socket
 // reset) — then retract the exposed text and replay.
-async function transportReplayPermitted(sendErr, outcome, retract) {
-  if (outcome.replaySafe === true && classifyError(sendErr) === 'transient') return true;
-  const transportSymptom =
+async function transportReplayPermitted(sendErr, outcome, retract, state) {
+  if (!isSemanticallyRetryable(sendErr, state)) return false;
+  // Existing replay-safety gate: an unexposed failure replays outright only
+  // when it is typed-transient (or an opted-in in-band invalid_request); a
+  // named symptom replays after retraction.
+  if (
+    outcome.replaySafe === true &&
+    (classifyError(sendErr) === 'transient' || inBandInvalidRequestReplay(sendErr, state))
+  ) {
+    return true;
+  }
+  return await retract();
+}
+
+// The ONE semantic verdict on whether this failure is worth re-issuing,
+// independent of what was exposed (the replay-safety gate decides that
+// afterwards): never a deterministic refusal (quota, plan, billing, policy,
+// auth, permission, context or size) — server advice never makes one
+// retryable — and otherwise a named transient/transport symptom.
+function inBandInvalidRequestReplay(sendErr, state) {
+  return (
+    loopRetryPolicy(state).inBandInvalidRequestRetryable === true &&
+    providerErrorKind(sendErr).kind === 'invalid_request' &&
+    isRetryableStreamErrorEvent(sendErr)
+  );
+}
+
+function isSemanticallyRetryable(sendErr, state) {
+  if (isProviderRecoveryTerminal(sendErr)) return false;
+  // Opt-in (retryPolicy.inBandInvalidRequestRetryable): a provider whose
+  // in-band stream errors carry an invalid_request envelope for server faults
+  // replays one with no other deterministic evidence; for every other
+  // provider it is a final refusal.
+  const { kind } = providerErrorKind(sendErr);
+  if (DETERMINISTIC_KINDS.has(kind) && !inBandInvalidRequestReplay(sendErr, state)) {
+    return false;
+  }
+  return (
     classifyError(sendErr) === 'transient' ||
     isStreamCut(sendErr) ||
     isRetryableWireErrorEvent(sendErr) ||
     isRetryableStreamErrorEvent(sendErr) ||
-    isCursorTransientTransportError(sendErr);
-  return transportSymptom && (await retract());
+    isCursorTransientTransportError(sendErr)
+  );
 }
 
 function retryTransport(sendErr, state) {
   return scheduleTransportReplay(sendErr, state, {
-    budget: retryBudgetFor(sendErr),
+    budget: retryBudgetFor(sendErr, state),
     note:
       `[loop] transient send failure with no dispatched tools (${loopTag(state)} code=${sendErr?.code ?? 'n/a'} ` +
       `wsCloseCode=${sendErr?.wsCloseCode ?? 'n/a'} httpStatus=${sendErr?.httpStatus ?? sendErr?.status ?? 'n/a'})`,
@@ -700,7 +826,7 @@ function imageStripEligible(
       hasImages: promptHasInlineImages(recoveryMessages),
       alreadyStripped: imageStripUsed === true,
     }) ||
-      // Grok Build RetryWithImageStrip only: a bare stream error on a Grok
+      // Grok only: a bare stream error on a Grok
       // upload may be the image body being rejected. Other providers' transient
       // stream errors are not evidence about images and use normal transport retry.
       (isGrok &&

package/src/runtime/agent/orchestrator/session/store/save-worker.mjs

@@ -1,5 +1,5 @@
 import { MessageChannel, Worker } from 'node:worker_threads';
-import { guardedSaveOptions as _guardedSaveOptions } from './write-guards.mjs';
+import { guardedSaveOptions as _guardedSaveOptions, releaseSessionWriteControl } from './write-guards.mjs';
 import { _ensureLifecycleFields } from './serialize.mjs';
 import {
   _attemptEvidence,
@@ -63,9 +63,12 @@ export { _hasSessionSaveBaseline } from './save-delta.mjs';
  * the writes, so a write already posted for `id` still lands first; the next
  * save for `id`, if any, simply goes out as a full snapshot.
  */
-export function forgetSessionSaveBaseline(id) {
+export function forgetSessionSaveBaseline(id, { releaseWriteControl = false } = {}) {
   if (!id) return false;
   const had = _dropDeltaBaseline(id);
+  // Only when the session itself is gone (close/teardown/delete): a mid-life
+  // forget (compaction) must keep the landed-epoch fence for in-flight writes.
+  if (releaseWriteControl) releaseSessionWriteControl(String(id));
   if (_saveWorker) {
     try {
       _saveWorker.postMessage({ __forgetBase: String(id) });
@@ -854,7 +857,7 @@ export function purgeSessionSaveBookkeeping(id) {
     }
   }
   // Also frees the worker-side base: a deleted id never saves again.
-  forgetSessionSaveBaseline(id);
+  forgetSessionSaveBaseline(id, { releaseWriteControl: true });
   return purged;
 }
 

package/src/runtime/agent/orchestrator/session/store/write-guards.mjs

@@ -49,6 +49,22 @@ export function guardedSaveOptions(id, opts, epoch = null) {
   };
 }
 
+/**
+ * Drop the id's control buffer once the session is gone (close/forget/delete)
+ * so the map does not grow by one SharedArrayBuffer per session ever saved.
+ * Kept while a commit holds the lock: that write still serialises on this
+ * buffer. A later save for the same id simply allocates a fresh control.
+ */
+export function releaseSessionWriteControl(id) {
+  const control = _writeControls.get(id);
+  if (!control || Atomics.load(control, 1) !== 0) return false;
+  return _writeControls.delete(id);
+}
+
+export function _hasSessionWriteControl(id) {
+  return _writeControls.has(id);
+}
+
 export function cancelSessionWrites(id) {
   Atomics.add(writeControl(id), 0, 1);
 }

package/src/runtime/agent/orchestrator/session/store-agent-worker-rows.mjs

@@ -106,13 +106,25 @@ function agentStatusValues(row) {
     .filter((status, index, values) => Boolean(status) && values.indexOf(status) === index);
 }
 
+/** The worker's lifecycle. `status` decides; `stage` is only the runtime phase
+ *  copied in by the progress sweep, so mid-work it may read idle/done/error
+ *  beside a worker that is still running. Only a row with no status falls
+ *  back to its stage. */
+function workerLifecycle(row) {
+  return cleanValue(row?.status) || cleanValue(row?.stage);
+}
+
 function activeAgentWorker(row) {
-  const statuses = agentStatusValues(row);
-  return (
-    statuses.length > 0 &&
-    !statuses.some((status) => DEAD_AGENT_STATUS.test(status)) &&
-    statuses.some((status) => LIVING_AGENT_STATUS.test(status))
-  );
+  // A cancel in either field ends the work (bare `cancelling` is still work).
+  if (
+    agentStatusValues(row).some(
+      (status) => CANCELLED_AGENT_STATUS.test(status) || CANCEL_UNCONFIRMED_AGENT_STATUS.test(status)
+    )
+  ) {
+    return false;
+  }
+  const lifecycle = workerLifecycle(row);
+  return Boolean(lifecycle) && !DEAD_AGENT_STATUS.test(lifecycle) && LIVING_AGENT_STATUS.test(lifecycle);
 }
 
 function stampMs(value) {
@@ -287,7 +299,7 @@ const withinPoolWindow = (at, now) => at > 0 && now - at <= AGENT_POOL_HEARTBEAT
  *  a working status whose own stamp is still inside the pool window. */
 function poolRowWorking(row, heartbeatMtimes, now) {
   if (withinPoolWindow(heartbeatMtimes.get(cleanValue(row?.sessionId)) || 0, now)) return true;
-  if (!WORKING_AGENT_STATUS.test(cleanValue(row?.stage || row?.status))) return false;
+  if (!WORKING_AGENT_STATUS.test(workerLifecycle(row))) return false;
   return withinPoolWindow(Date.parse(cleanValue(row?.updatedAt)) || 0, now);
 }
 
@@ -307,7 +319,7 @@ function projectChildWorkerRow(row, { now, heartbeatMtimes }) {
   const session = readWorkerSessionHeader(sessionId);
   const declaredStatus = cleanValue(row.status) || 'running';
   const declaredStage = cleanValue(row.stage || row.status) || 'running';
-  const declaredWorking = WORKING_AGENT_STATUS.test(declaredStatus) || WORKING_AGENT_STATUS.test(declaredStage);
+  const declaredWorking = WORKING_AGENT_STATUS.test(workerLifecycle(row) || 'running');
   const heartbeatFresh = withinPoolWindow(heartbeatMtimes.get(sessionId) || 0, now);
   const recentlyUpdated = withinPoolWindow(Date.parse(cleanValue(row.updatedAt)) || 0, now);
   const runtimePid = positiveNumber(row.runtimePid, 0);
@@ -414,7 +426,7 @@ function promoteHeartbeatSidecar(bySessionId, sessionId, heartbeatAt) {
     bySessionId.set(sessionId, sidecarWorkerRow(current, session, { ...identity, status: cancel.status }));
     return;
   }
-  const currentStatus = cleanValue(current.stage || current.status);
+  const currentStatus = workerLifecycle(current);
   if (currentStatus && !WORKING_AGENT_STATUS.test(currentStatus)) return;
   // The sidecar is the live lease. Durable child sessions are intentionally
   // detached/closed while their external owner runs.
@@ -452,7 +464,7 @@ function projectLeadWorkerRow(row, { now, heartbeatMtimes }) {
   const heartbeatAt = heartbeatMtimes.get(sessionId) || 0;
   const heartbeatFresh = withinPoolWindow(heartbeatAt, now);
   const recentlyUpdated = withinPoolWindow(Date.parse(cleanValue(row.updatedAt)) || 0, now);
-  const declaredStatus = cleanValue(row.stage || row.status) || 'idle';
+  const declaredStatus = workerLifecycle(row) || 'idle';
   const working = WORKING_AGENT_STATUS.test(declaredStatus) && (heartbeatFresh || recentlyUpdated);
   const reapAt = Date.parse(cleanValue(row.reapAt)) || 0;
   if (!heartbeatFresh && reapAt > 0 && now >= reapAt) return null;

package/src/runtime/agent/orchestrator/session/store-summary-catalog.mjs

@@ -21,6 +21,7 @@ import { dataDir } from './store-summary-locations.mjs';
 import {
   desktopSession,
   importKey,
+  inheritedFromSessionId,
   isStoredSessionId,
   positiveNumber,
   workspaceSummary,
@@ -188,6 +189,7 @@ export function normalizedRow(row, heartbeatAt = 0) {
     storageSize: positiveNumber(row.storageSize, 0),
     detachedReason: row.detachedReason || null,
     importKey: importKey(row),
+    inheritedFromSessionId: inheritedFromSessionId(row),
   };
 }
 

package/src/runtime/agent/orchestrator/session/store-summary-fields.mjs

@@ -50,6 +50,11 @@ export function workspaceSummary(value) {
 
 /** Dedupe key of an imported conversation: a session's `importOrigin.key`,
  *  or a summary row's projected `importKey`; null for ordinary sessions. */
+export function inheritedFromSessionId(value) {
+  const id = typeof value?.inheritedFromSessionId === 'string' ? value.inheritedFromSessionId.trim() : '';
+  return id || null;
+}
+
 export function importKey(value) {
   const key = typeof value?.importKey === 'string' ? value.importKey : value?.importOrigin?.key;
   return typeof key === 'string' && key.trim() ? key : null;

package/src/runtime/agent/orchestrator/session/store-summary-index.mjs

@@ -20,6 +20,7 @@ import { cleanSessionPreview, isSessionPreviewNoise, sessionMessageText } from '
 import { sessionVisibility } from './store-summary-visibility.mjs';
 import {
   importKey,
+  inheritedFromSessionId,
   isStoredSessionId,
   positiveNumber as _positiveNumber,
   workspaceSummary,
@@ -209,6 +210,7 @@ export function _sessionSummary(session) {
     // Imported-conversation identity, so "already imported" is answered
     // from summaries without loading sessions.
     importKey: importKey(session),
+    inheritedFromSessionId: inheritedFromSessionId(session),
   };
 }
 
@@ -258,6 +260,7 @@ function _normalizeSummaryRow(row) {
     storageSize: _positiveNumber(row.storageSize, 0),
     detachedReason: row.detachedReason || null,
     importKey: importKey(row),
+    inheritedFromSessionId: inheritedFromSessionId(row),
   };
 }
 

package/src/runtime/agent/orchestrator/session/transcript-restore/restore.mjs

@@ -286,7 +286,9 @@ function mergeRestoredToolItems(items) {
 }
 
 function restoredMessageItemUpperBound(message) {
-  const boundaries = Array.isArray(message?.meta?.sessionInheritances) ? message.meta.sessionInheritances.length : 0;
+  const boundaries =
+    (Array.isArray(message?.meta?.sessionInheritances) ? message.meta.sessionInheritances.length : 0) +
+    (Array.isArray(message?.meta?.modelSwitches) ? message.meta.modelSwitches.length : 0);
   if (message?.role === 'user') return 1 + boundaries;
   if (message?.role !== 'assistant') return boundaries;
   const calls = restoredMessageToolCalls(message);
@@ -377,6 +379,19 @@ function restoredUserTranscriptItems(message, nextId) {
   return [restoredNotificationToolItem(synthetic, text, message, nextId, /^(failed|error|killed|cancelled)$/i)];
 }
 
+/** The transcript row of an in-place model switch (live and restored). */
+export function modelSwitchItem(id, boundary) {
+  return {
+    kind: 'statusdone',
+    id,
+    status: 'model-switched',
+    label: 'Model switched',
+    provider: boundary.provider,
+    modelId: boundary.modelId,
+    at: boundary.at,
+  };
+}
+
 function restoreTranscriptRange(messages, start, sessionId) {
   const items = [];
   const pendingToolCalls = new Map();
@@ -408,6 +423,10 @@ function restoreTranscriptRange(messages, start, sessionId) {
         at: boundary.at,
       });
     }
+    for (const boundary of Array.isArray(message?.meta?.modelSwitches) ? message.meta.modelSwitches : []) {
+      if (!boundary?.provider || !boundary?.modelId) continue;
+      items.push(modelSwitchItem(restoredId(), boundary));
+    }
   }
   return mergeRestoredToolItems(items);
 }

package/src/runtime/agent/orchestrator/tools/builtin/arg-guard.mjs

@@ -786,9 +786,9 @@ function guardShell(a) {
   }
   // Over-max is an unambiguous "wait as long as allowed"; clamp like the other
   // saturating integer args instead of failing the call.
-  if (hasOwn(a, 'wait_ms') && Number.isInteger(a.wait_ms) && a.wait_ms > 120000) a.wait_ms = 120000;
+  if (hasOwn(a, 'wait_ms') && Number.isInteger(a.wait_ms) && a.wait_ms > 30000) a.wait_ms = 30000;
   if (hasOwn(a, 'wait_ms') && (!Number.isInteger(a.wait_ms) || a.wait_ms < 1000)) {
-    return `Error: shell arg "wait_ms" must be an integer from 15000 to 120000, e.g. wait_ms:30000 (got ${JSON.stringify(a.wait_ms)})`;
+    return `Error: shell arg "wait_ms" must be an integer from 10000 to 30000, e.g. wait_ms:20000 (got ${JSON.stringify(a.wait_ms)})`;
   }
   if (!hasOwn(a, 'command')) {
     return 'Error: shell requires "command"';

package/src/runtime/agent/orchestrator/tools/builtin/bash-tool/deadline-plan.mjs

@@ -1,12 +1,12 @@
 // Commands start in the foreground. Only work still running after the
-// 15 s coordination budget is promoted to a tracked background task.
+// 10 s coordination budget is promoted to a tracked background task.
 // Short commands therefore complete in the original tool turn, while longer
 // work returns partial output plus task_id and finishes by notification.
-// 15 s because a command promoted moments before it ends costs a whole
-// follow-up request on `task wait`. Session logs (2026-09-30..10-05), the 260
-// promoted commands with a recorded duration: 108 had ended within 10 s, 144
-// within 15 s and only 152 within 20 s.
-export const DEFAULT_SHELL_AUTO_BACKGROUND_MS = 15_000;
+// A per-call wait_ms may stretch the window for a command whose result should
+// return in the same call, never past 30 s, so the conversation is never held
+// open long; anything longer finishes by notification.
+export const DEFAULT_SHELL_AUTO_BACKGROUND_MS = 10_000;
+export const MAX_SHELL_WAIT_MS = 30_000;
 
 // JS timers (setTimeout) and PS WaitForExit(ms) are 32-bit: a delay above
 // 2^31-1 wraps to a tiny/negative value and fires immediately. Clamp the
@@ -17,17 +17,14 @@ const TIMER_MAX_MS = 2_147_483_647;
 
 // Main-agent blocking budget. A timeout is the command's total deadline, not
 // permission to hold the conversation open for that whole duration: after
-// 15 s a still-running command becomes a tracked background task and
+// 10 s a still-running command becomes a tracked background task and
 // completion is pushed to the owner. MIXDOG_SHELL_AUTO_BACKGROUND_MS
 // overrides; an explicit 0 disables. Gated on backgroundOnTimeout so
 // disabled background tasks remain foreground.
-// A per-call wait_ms extends that default for the call, capped by the
-// foreground maximum; it never shortens it. A shorter window promotes a
-// command that would have returned its result in the starting call and spends
-// a whole follow-up request on `task wait`. Session logs (2026-09-30..10-05,
-// 3062 shell calls): 329 passed a wait_ms under the default (53% of one model
-// family's calls), 256 of those were promoted, and 108 of the 192 with a
-// recorded duration had finished inside the default window (10 s then).
+// A per-call wait_ms extends that default for the call, capped by
+// MAX_SHELL_WAIT_MS and the foreground maximum; it never shortens it. A
+// shorter window promotes a command that would have returned its result in
+// the starting call and spends a whole follow-up request on `task wait`.
 function autoBackgroundBudget(backgroundOnTimeout, timeout, waitMs, maxForegroundMs) {
   const raw = process.env.MIXDOG_SHELL_AUTO_BACKGROUND_MS;
   const parsed = Number(raw);
@@ -35,7 +32,7 @@ function autoBackgroundBudget(backgroundOnTimeout, timeout, waitMs, maxForegroun
     raw != null && String(raw).trim() !== '' && Number.isFinite(parsed) && parsed >= 0
       ? Math.floor(parsed)
       : DEFAULT_SHELL_AUTO_BACKGROUND_MS;
-  if (waitMs > 0) defaultMs = Math.max(defaultMs, Math.min(waitMs, maxForegroundMs));
+  if (waitMs > 0) defaultMs = Math.max(defaultMs, Math.min(waitMs, MAX_SHELL_WAIT_MS, maxForegroundMs));
   if (!backgroundOnTimeout || defaultMs <= 0) return 0;
   return timeout > 0 ? Math.min(defaultMs, timeout) : defaultMs;
 }

package/src/runtime/agent/orchestrator/tools/builtin/builtin-tools.mjs

@@ -146,7 +146,7 @@ export const BUILTIN_TOOLS = [
       openWorldHint: true,
       compressible: true,
     },
-    description: `Run programs, builds, tests and computation. Never use shell commands or scripts for work covered by dedicated tools: cat/head/tail→read, ls→list, find→glob, filename lookup→find, grep/rg→grep, code structure→code_graph, file edits/writes (sed/awk/redirection)→edit/apply_patch, Git→git when that tool is on the surface. Tool names are not shell commands. ${_shellBackgroundDisabled ? 'Commands run in the foreground until completion.' : 'After a 15s foreground window (not a timeout; wait_ms extends it up to 120s for one call, e.g. a test suite), unfinished work continues under task_id; use task wait, not read polling. If no execution slot frees within the admission wait, the command is queued as a background task with a task_id. Dev servers/watchers: pass timeout_ms or stop them with task cancel when done.'}`,
+    description: `Run programs, builds, tests and computation. Never use shell commands or scripts for work covered by dedicated tools: cat/head/tail→read, ls→list, find→glob, filename lookup→find, grep/rg→grep, code structure→code_graph, file edits/writes (sed/awk/redirection)→edit/apply_patch, Git→git when that tool is on the surface. Tool names are not shell commands. ${_shellBackgroundDisabled ? 'Commands run in the foreground until completion.' : 'After a 10s foreground window (not a timeout; omit wait_ms by default, set it up to 30s only for a command you expect to finish in 10–30s, e.g. one test file), unfinished work continues under task_id; use task wait, not read polling. If no execution slot frees within the admission wait, the command is queued as a background task with a task_id. Dev servers/watchers: pass timeout_ms or stop them with task cancel when done.'}`,
     inputSchema: {
       type: 'object',
       properties: {
@@ -155,14 +155,14 @@ export const BUILTIN_TOOLS = [
           type: 'integer',
           minimum: 0,
           description:
-            'Hard kill deadline in ms (omit or 0 = none), separate from the 15s foreground window; set one for throwaway probes so a slow check fails fast.',
+            'Hard kill deadline in ms (omit or 0 = none), separate from the 10s foreground window; set one for throwaway probes so a slow check fails fast.',
         },
         wait_ms: {
           type: 'integer',
-          minimum: 15000,
-          maximum: 120000,
+          minimum: 10000,
+          maximum: 30000,
           description:
-            'Foreground wait in ms before unfinished work continues as a background task (default 15000); raise it for a command that should return its result in this call.',
+            'Foreground wait in ms before unfinished work continues as a background task (default 10000). Omit it by default. Set it only when you expect the command to finish within 10–30s (e.g. one test file or a small build step); never for work expected to take longer, which finishes by notification.',
         },
       },
       required: ['command'],