mixdog 1.2.0 → 1.2.2

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

@@ -5,7 +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 { prepareExplicitSkills } from '../explicit-skills.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';
 import { saveSessionAsync } from '../store.mjs';
@@ -27,16 +27,12 @@ export async function prepareAskTurn({ sessionId, opened, input, cwdOverride, tr
   // Register the live session object for synchronous close snapshots.
   runtime.session = session;
   if (!provider) throw new Error(`Provider "${session.provider}" not available`);
-  const autoEffort = await resolveTurnAutoEffort({ sessionId, session, provider, input });
-  const turnEffort = autoEffort?.applied ? autoEffort.effort : session.effort || null;
-  const effortConfiguration = prepareTurnEffortConfiguration(
-    session,
-    provider,
-    autoEffort?.applied ? autoEffort.effort : undefined
-  );
-  // Auto effort also judges every tool-result step of the turn when the
-  // installed judge was trained on steps (session/loop/step-auto-effort.mjs).
-  const stepAutoEffort = turnStepAutoEffort(autoEffort, effortConfiguration);
+  // 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,
+  // together with the user turn, before the effort configuration is stamped.
+  const autoEffortPending = resolveTurnAutoEffort({ sessionId, session, provider, input });
+  autoEffortPending.catch(() => {});
   applyTurnContextMeta(session, provider);
   const effectiveCwd = cwdOverride || session.cwd;
   // A failed-turn retry resubmits the prompt the failure left unanswered;
@@ -46,25 +42,49 @@ export async function prepareAskTurn({ sessionId, opened, input, cwdOverride, tr
   if (session.sessionStartMetaInjected !== true && !hasUserConversationMessage(session.messages)) {
     refreshSessionBp3Environment(session, effectiveCwd);
   }
+  // The prewarm only opens the transport (effort never shapes the socket), so
+  // it starts now instead of after the judgment.
   const startupProviderPrewarm = startProviderPrewarm({
     sessionId,
     session,
     provider,
-    turnEffort,
-    effortConfiguration,
+    turnEffort: session.effort || null,
+    effortConfiguration: null,
     codexTurnId,
     startedAtMs: startedAt,
   });
-  const userTurn = await buildUserTurn({
+  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,
+    }),
+  ]);
+  const turnEffort = autoEffort?.applied ? autoEffort.effort : session.effort || null;
+  const effortConfiguration = prepareTurnEffortConfiguration(
     session,
-    prompt: input.prompt,
-    context: input.context,
-    explicitPrefetch: input.explicitPrefetch,
-    turnSignal,
-    transcriptMeta,
-    turnPromptSource: input.promptSource,
-    effortConfiguration,
-  });
+    provider,
+    autoEffort?.applied ? autoEffort.effort : undefined
+  );
+  // Auto effort also judges every tool-result step of the turn when the
+  // installed judge was trained on steps (session/loop/step-auto-effort.mjs).
+  const stepAutoEffort = turnStepAutoEffort(autoEffort, effortConfiguration);
+  if (effortConfiguration) {
+    // Stamp the turn's effort on the user message (same meta order as when it
+    // was built with it: before the runtime-context provenance).
+    const { runtimeUserContext, ...meta } = userTurn.userTurnMessage.meta || {};
+    userTurn.userTurnMessage.meta = {
+      ...meta,
+      effortConfiguration,
+      ...(runtimeUserContext ? { runtimeUserContext } : {}),
+    };
+  }
   const { historyMessages, outgoing } = userTurn;
   turn.userTurnContent = userTurn.userTurnMessage.content;
   turn.outgoing = outgoing;
@@ -151,9 +171,16 @@ export async function runAskAgentLoop({
   }
   try {
     if (!input.promptSource) {
-      await prepareExplicitSkills(input.prompt, outgoing, session, { cwd: effectiveCwd, signal: turnSignal });
+      const applied = await prepareExplicitSkills(input.prompt, outgoing, session, {
+        cwd: effectiveCwd,
+        signal: turnSignal,
+        selection: input.skillSelection,
+      });
+      // The user turn message sits right after the history it was built on.
+      const userMessage = recordAppliedSkills(outgoing, outgoing[prepared.beforeCount - 1], applied);
       session.messages = filterModelVisibleSessionMessages(outgoing);
       checkpoint.schedule(true);
+      notifySkillsApplied(askOpts?.onSkillsApplied, applied, userMessage);
     }
     return await _api_call_with_interrupt(sessionId, (signal) =>
       agentLoop(

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

@@ -152,6 +152,10 @@ export function buildAgentLoopOptions({
       checkpoint.schedule(true);
       relay(askOpts?.onSteerMessage, text, detail);
     },
+    onSkillsApplied: (names, detail) => {
+      checkpoint.schedule(true);
+      relay(askOpts?.onSkillsApplied, names, detail);
+    },
     notifyFn: optionalFn(askOpts?.notifyFn),
     // Same projection compaction uses, so a session presents one identity on
     // every request it makes.

package/src/runtime/agent/orchestrator/session/manager/pending-message-entry.mjs

@@ -1,7 +1,7 @@
 import { createHash, randomBytes } from 'node:crypto';
 import { mergeNormalizedContentEntries } from '../loop/steering.mjs';
 import { isDeliveredCompletion, logDuplicateSkip } from './delivered-completions.mjs';
-import { isInternalRuntimeNotificationText, promptContentText } from './prompt-utils.mjs';
+import { promptContentText } from './prompt-utils.mjs';
 import { parseTaskNotification, taskNotificationId } from '../../../../shared/task-notification-envelope.mjs';
 
 const STALE_USER_INJECTION_TTL_MS = 30 * 60 * 1000;
@@ -158,6 +158,14 @@ export function lateDeliveryText(text, entry, now = Date.now()) {
   return `[late delivery: queued ${age} ago, before the current session owner started]\n${value}`;
 }
 
+// A non-completion entry may be queued explicitly as a task notification (a
+// runtime/channel notice, never the user typing): the mode survives
+// normalization and the durable spool so the drain stores it as one and it
+// never drives explicit skill selection.
+function explicitModeField(entry) {
+  return entry?.mode === PENDING_MODE_TASK_NOTIFICATION ? { mode: PENDING_MODE_TASK_NOTIFICATION } : {};
+}
+
 export function normalizePendingMessageEntry(entry) {
   if (typeof entry === 'string') {
     const text = entry.trim();
@@ -173,7 +181,10 @@ export function normalizePendingMessageEntry(entry) {
     id: pendingMessageId(entry),
     enqueuedAt: Number(entry.enqueuedAt) || Date.now(),
   };
-  const entryOptions = entry.options && typeof entry.options === 'object' ? { options: entry.options } : {};
+  const entryOptions = {
+    ...(entry.options && typeof entry.options === 'object' ? { options: entry.options } : {}),
+    ...explicitModeField(entry),
+  };
   const marker =
     entry.notificationKind === COMPLETION_NOTIFICATION_KIND
       ? {
@@ -259,38 +270,35 @@ function normalizePersistedEntryBase(entry) {
         }
       : null;
   }
+  const mode = explicitModeField(entry);
   if (typeof entry.message === 'string') {
     const message = entry.message.trim();
-    return message ? { id, message, enqueuedAt } : null;
+    return message ? { id, message, ...mode, enqueuedAt } : null;
   }
   if (Object.hasOwn(entry, 'content')) {
     const normalized = normalizePendingMessageEntry(entry);
     if (!normalized) return null;
     if (typeof normalized.content === 'string' && !normalized.options) {
-      return { id, message: normalized.text || normalized.content, enqueuedAt };
+      return { id, message: normalized.text || normalized.content, ...mode, enqueuedAt };
     }
     return {
       id,
       content: normalized.content,
       text: normalized.text,
       ...(normalized.options ? { options: normalized.options } : {}),
+      ...mode,
       enqueuedAt,
     };
   }
   const text = pendingMessageText(entry);
-  return text ? { id, message: text, enqueuedAt } : null;
+  return text ? { id, message: text, ...mode, enqueuedAt } : null;
 }
 
 export function modelVisiblePendingMessages(messages) {
-  return (Array.isArray(messages) ? messages : [])
-    .map(pendingMessageQueueEntry)
-    .filter(Boolean)
-    .filter(
-      (message) =>
-        !isInternalRuntimeNotificationText(
-          message && typeof message === 'object' && Object.hasOwn(message, 'content') ? message.content : message
-        )
-    );
+  // No content filter: isInternalRuntimeNotificationText is a display-only
+  // predicate. Every canonical completion envelope matches it, and a drained
+  // entry the model never sees is never claimed/acked/released.
+  return (Array.isArray(messages) ? messages : []).map(pendingMessageQueueEntry).filter(Boolean);
 }
 
 export function _mergePendingMessageEntries(entries) {

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

@@ -216,7 +216,7 @@ function releaseSessionReadCaches(id) {
     /* ignore */
   }
   try {
-    forgetSessionSaveBaseline(id);
+    forgetSessionSaveBaseline(id, { releaseWriteControl: true });
   } catch {
     /* ignore */
   }

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

@@ -1,6 +1,6 @@
 import { sanitizeToolPairs } from '../context-utils.mjs';
 import { collectAssistantToolCallIds as assistantToolCallIds } from '../context-tool-pairs.mjs';
-import { isInternalRuntimeNotificationText, promptContentText } from './prompt-utils.mjs';
+import { promptContentText } from './prompt-utils.mjs';
 import { filterModelVisibleSessionMessages } from './message-sanitize.mjs';
 import { journalDelta } from './turn-interruption-journal.mjs';
 
@@ -72,8 +72,11 @@ function finalizeInterruptedTurn({
       const index = provisionalUserTurnIndex(messages, currentUserContent);
       return index >= 0 && index < messages.length - 1;
     })();
-  const preserveResponse =
-    responseStarted && !isInternalRuntimeNotificationText(currentUserContent) && (producedOutput || !userCancelled);
+  // A turn woken by a task notification is preserved by the same rule as a
+  // user prompt: once it produced output its notification is consumed (the
+  // host commits it and never requeues it), so rewinding it would erase the
+  // turn and its side effects from history.
+  const preserveResponse = responseStarted && (producedOutput || !userCancelled);
   if (!preserveResponse) {
     if (!userCancelled) {
       return {
@@ -198,8 +201,11 @@ export function createTurnInterruptionTracker() {
       // copies of the same first sentence). Reference agents never
       // commit a replayed attempt's discarded stream at all; the
       // tombstone exists only for the window between a retraction and
-      // its replacement.
-      if (state.tombstonedAssistantContent) {
+      // its replacement. Whitespace is not a replacement: it is not output
+      // (finalizeInterruptedTurn trims, and the host commits the prompt only
+      // on non-blank text), so until real text arrives the retracted bytes
+      // remain the only output the user saw.
+      if (state.tombstonedAssistantContent && value.trim()) {
         state.tombstonedAssistantContent = '';
         state.tombEpoch += 1;
       }
@@ -212,8 +218,13 @@ export function createTurnInterruptionTracker() {
       // REPLACE, never accumulate: consecutive retractions belong to
       // successive attempts at the SAME answer, so keeping the earlier
       // tombstone alongside the newer one is what multiplied the visible
-      // text across retries.
-      state.tombstonedAssistantContent = state.partialAssistantContent.slice(cutAt);
+      // text across retries. A whitespace-only retraction is not a newer
+      // attempt at the answer (recordTextDelta never let it supersede the
+      // draft), so it never replaces a meaningful tombstone.
+      const retracted = state.partialAssistantContent.slice(cutAt);
+      if (retracted.trim() || !state.tombstonedAssistantContent.trim()) {
+        state.tombstonedAssistantContent = retracted;
+      }
       state.partialAssistantContent = state.partialAssistantContent.slice(0, cutAt);
       state.textEpoch += 1;
       state.tombEpoch += 1;

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

@@ -72,7 +72,6 @@ export {
 // attach-on-resume guard) — resolved through the manager facade so the
 // session-runtime turn API reaches it as mgr.publishSessionPresence.
 export { publishSessionPresence, deleteSessionPresence } from './store.mjs';
-export { isInternalRuntimeNotificationText as _isInternalRuntimeNotificationText } from './manager/prompt-utils.mjs';
 
 // ── Usage-metrics surface — re-exported unchanged so loop.mjs / smoke scripts
 //    keep resolving these through the facade. ────────────────────────────────

package/src/runtime/agent/orchestrator/session/pre-send-compact.mjs

@@ -408,9 +408,10 @@ function adoptCompactedTranscript(ctx, run) {
   // providerState so the next send starts a fresh chain.
   ctx.providerState = undefined;
   ctx.providerStateCleared = true;
-  // Compaction shrank the transcript, so prior turns no longer pressure the
-  // window — reset the iteration counter so a steadily-compacting long task
-  // isn't killed by the cap, while a non-compacting tight loop still hits it.
+  // Compaction starts a new loop epoch: the iteration counter restarts at 0
+  // so iteration indices (traces, usage metrics, cross-turn dedup windows)
+  // count from the compacted transcript. The counter bounds nothing — the
+  // loop has no iteration cap.
   ctx.iterations = 0;
   // New loop epoch so persistIterationMetrics idempotency keys do not
   // collide when iteration indices restart at 1 (incl. iter 1 → iter 1).

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/listing.mjs

@@ -30,6 +30,7 @@ import { _saveAsyncQueued, _saveWorkerPending } from './save-worker.mjs';
 import { STORED_SESSION_UNREADABLE, _ensureLifecycleFields, _storedSessionFromFile } from './serialize.mjs';
 import { _savePending } from './pending-saves.mjs';
 import { isOrdinarySession } from '../store-summary-visibility.mjs';
+import { closeSessionCatalogDb } from '../catalog-db/index.mjs';
 
 // Disk mtime of the summary index when the in-memory cache was last refreshed
 // from it — the cross-process staleness detector.
@@ -145,8 +146,9 @@ function scheduleSessionSummaryIndexRebuild() {
 
 /**
  * Resolves once no summary-index writer of this process is running: the
- * background rebuild worker a cold listing (or sweep) spawned has exited and
- * every queued index mutation has landed. Both write the index, its lock and
+ * background rebuild worker a cold listing (or sweep) spawned has exited,
+ * every queued index mutation has landed and the session catalog DB is
+ * closed. Both write the index, its lock and
  * temp files into the data dir after the listing/sweep/save that caused them
  * has returned, so an owner that removes or switches the data dir awaits this
  * first.
@@ -159,6 +161,8 @@ export async function settleSessionSummaryIndex() {
     await new Promise((resolve) => worker.once('exit', resolve));
   }
   await settleSummaryIndexWrites();
+  // The daemon's session catalog DB holds its file, WAL and lock open.
+  await closeSessionCatalogDb();
 }
 
 export function listStoredSessionSummaries(options = {}) {

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