mixdog 0.9.93 → 0.9.95

package/src/runtime/agent/orchestrator/providers/openai-oauth-http-sse.mjs

@@ -126,8 +126,8 @@ function _isMaxOutputIncompleteReason(reason) {
     return /^(?:max_output_tokens|max_tokens|length|output_token_limit)$/i.test(String(reason || '').trim());
 }
 
-// Wire-level `end_turn` on a terminal Responses frame (codex-rs
-// codex-api/src/sse/responses.rs ResponseCompleted.end_turn: Option<bool>).
+// Wire-level `end_turn` on a terminal Responses frame: an optional boolean on
+// the completed response.
 // Optional by contract: only a real boolean normalizes; a missing/non-boolean
 // field stays undefined so absence is never collapsed into false.
 export function _endTurnFromEvent(event) {
@@ -178,9 +178,9 @@ function _buildOpenAIHttpFallbackHeaders({ auth, cacheKey }) {
     };
     if (cacheKey) {
         const sid = String(cacheKey);
-        // Codex-native anchors (see openai-ws-pool _buildHandshakeHeaders):
-        // `session-id`/`thread-id` (hyphen) match codex-rs headers.rs; legacy
-        // underscore `session_id` kept for backward compat.
+        // Backend-native anchors (see openai-ws-pool _buildHandshakeHeaders):
+        // the hyphenated `session-id`/`thread-id` pair; legacy underscore
+        // `session_id` kept for backward compat.
         headers.session_id = sid;
         headers['session-id'] = sid;
         headers['thread-id'] = sid;
@@ -244,9 +244,8 @@ export async function sendViaHttpSse({
     const responsesUrl = auth?.type === 'openai-direct'
         ? OPENAI_DIRECT_RESPONSES_URL
         : CODEX_RESPONSES_URL;
-    // Request-body zstd (codex parity: core client.rs
-    // responses_request_compression enables zstd for the codex backend on the
-    // OpenAI provider — the server decompresses Content-Encoding: zstd).
+    // Request-body zstd: compression is enabled for the codex backend on the
+    // OpenAI provider — the server decompresses Content-Encoding: zstd.
     // openai-direct is excluded: only the codex backend is verified. Env
     // kill-switch plus a process-wide latch flipped on the first 400 seen on
     // a compressed request, which then replays that attempt uncompressed.

package/src/runtime/agent/orchestrator/providers/openai-oauth-ws.mjs

@@ -88,7 +88,7 @@ globalThis.__mixdogOpenaiWsRuntimeLoaded = true;
 // by connect/handshake and pre-output stream failures.
 const MIDSTREAM_WS_TRANSIENT_RETRY_LIMIT = MIDSTREAM_RETRY_POLICY.ws.transientCloseRetries;
 const MIDSTREAM_DEFAULT_RETRY_LIMIT = MIDSTREAM_RETRY_POLICY.ws.defaultRetries;
-// Codex core/src/util.rs uses a 200ms base, factor 2, and symmetric ±10%
+// The reference client uses a 200ms base, factor 2, and symmetric ±10%
 // jitter for each of its five stream retries.
 const MIDSTREAM_BACKOFF_MS = Object.freeze([200, 400, 800, 1600, 3200]);
 const CODEX_RETRY_JITTER_RATIO = 0.1;
@@ -773,7 +773,7 @@ export async function sendViaWebSocket({
         let result;
         const streamTimeouts = null;
         try {
-            // codex prewarm gate (client.rs:1686-1688): only when the session
+            // Prewarm gate: only when the session
             // has no prior request state. A reused pooled socket with a live
             // chain must go straight to the real request.
             if (warmupBody && typeof warmupBody === 'object' && !completedWarmup

package/src/runtime/agent/orchestrator/providers/openai-responses-payload.mjs

@@ -203,7 +203,7 @@ export function toOpenAIResponsesTool(t) {
 
 export const _convertMessagesToResponsesInputForTest = convertMessagesToResponsesInput;
 
-// codex build_reasoning() (core/src/client.rs:785-805) only attaches the
+// The reference client only attaches the
 // reasoning object when model_info.supports_reasoning_summaries; models
 // without summary support get NO reasoning field at all. Mirror that via the
 // cached codex catalog; unknown models default to true (gpt-5 family all
@@ -218,7 +218,7 @@ function _codexModelSupportsReasoningSummaries(id) {
     return true;
 }
 
-// codex reasoning_effort_for_request (core/src/client.rs): `ultra` collapses to
+// Effort normalization: `ultra` collapses to
 // `max` on the wire — the openai-oauth backend does not accept `ultra`. Every
 // other effort passes through unchanged; empty/unknown falls back to medium.
 export function _normalizeReasoningEffort(effort) {
@@ -251,12 +251,12 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
         const value = String(item || '').trim();
         if (value && !include.includes(value)) include.push(value);
     }
-    // Field order MIRRORS codex-rs ResponsesApiRequest (common.rs struct order):
+    // Field order MIRRORS the reference request struct:
     // model, instructions, input, tools, tool_choice, parallel_tool_calls,
     // reasoning, store, stream, include, service_tier, prompt_cache_key, text.
     // JSON serialization order is load-bearing for the server prompt cache
-    // (exact-prefix match): matching codex's byte layout keeps our requests on
-    // the same cache-routing shape codex warms. tools/service_tier/
+    // (exact-prefix match): matching that byte layout keeps our requests on
+    // the same cache-routing shape the backend warms. tools/service_tier/
     // prompt_cache_key are appended below in the same relative order.
     const body = {
         model,
@@ -264,17 +264,15 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
         input,
         tool_choice: opts.toolChoice || 'auto',
         parallel_tool_calls: true,
-        // codex build_reasoning() sends { effort, summary } — summary defaults to
-        // ReasoningSummary::Auto (protocol config_types.rs), serialized lowercase
-        // as "auto". Matching this keeps our reasoning object byte-identical to
-        // codex so the server prompt-cache prefix hash lines up. codex also
-        // normalizes `ultra` -> `max` on the wire (reasoning_effort_for_request
-        // in core/src/client.rs); the openai-oauth backend does not accept
-        // `ultra` as a wire value, so mirror that mapping here.
-        // WIRE-VERIFIED (codex desktop logs_2.sqlite, 40 response.create
-        // captures, 2026-07-03): codex sends reasoning as {"effort":"..."}
-        // with NO summary field on gpt-5.5, regardless of what the repo's
-        // build_reasoning() suggests. Match the observed bytes.
+        // The reference client sends { effort, summary } — summary defaults
+        // to "auto" (lowercase on the wire). Matching this keeps our
+        // reasoning object byte-identical so the server prompt-cache prefix
+        // hash lines up. `ultra` is normalized to `max` on the wire too; the
+        // openai-oauth backend does not accept `ultra` as a wire value, so
+        // mirror that mapping here.
+        // WIRE-VERIFIED (40 response.create captures, 2026-07-03): the wire
+        // carries reasoning as {"effort":"..."} with NO summary field on
+        // gpt-5.5. Match the observed bytes.
         reasoning: { effort: _normalizeReasoningEffort(opts.effort) },
         store: process.env.MIXDOG_OAI_STORE === 'true' ? true : false,
         stream: true,

package/src/runtime/agent/orchestrator/providers/openai-ws-headers.mjs

@@ -41,8 +41,8 @@ export function _envOn(name) {
 // (MIXDOG_OAI_CODEX_WIRE_PARITY=1 + ws-delta + underscore session_id) exactly
 // as-is. These add EXTRA parity dimensions for backend fingerprint probes.
 
-// codex sends dashed RFC-4122 UUIDs as session-id/thread-id (client.rs:1033-
-// 1057); we key those dashed handshake headers off the underscore cacheKey by
+// The reference client sends dashed RFC-4122 UUIDs as session-id/thread-id;
+// we key those dashed handshake headers off the underscore cacheKey by
 // default. Opt in with MIXDOG_OAI_CODEX_WIRE_PARITY_UUID_IDS to reshape ONLY
 // the dashed pair (session-id/thread-id/x-client-request-id) into codex's UUID
 // format. The value is derived deterministically from the id so it stays
@@ -108,11 +108,12 @@ export function _codexBetaFeatures() {
     return out.join(',');
 }
 
-// --- Opt-in raw WS capture for byte-diff against codex-rs -------------------
+// --- Opt-in raw WS capture for wire byte-diff -------------------------------
 // Enabled ONLY when MIXDOG_OAI_WS_DUMP_DIR names a directory. Persists the
 // (redacted) handshake header metadata and the exact serialized
 // response.create frame bytes so our wire format can be byte-diffed against
-// codex. Secrets (Authorization / Cookie / account-id / routing tokens) are
+// the reference client. Secrets (Authorization / Cookie / account-id /
+// routing tokens) are
 // hashed, never written in clear. When the env is unset both helpers are
 // no-ops, so there is no default behavior change.
 const _WS_DUMP_SECRET_RE = /^(authorization|proxy-authorization|cookie|set-cookie|chatgpt-account-id|x-codex-turn-state|session_id|session-id|thread-id|x-codex-parent-thread-id|x-client-request-id|x-session-affinity)$/i;

package/src/runtime/agent/orchestrator/providers/openai-ws-pool.mjs

@@ -110,16 +110,16 @@ function _selectIdleEntry(entries, compatibility) {
 }
 
 // --- Cache-route probe state (2026-07-04 hunt) -----------------------------
-// CF cookie stickiness (codex chatgpt_cloudflare_cookies.rs:22-55 persists
+// CF cookie stickiness (the reference client persists
 // __cf_bm/_cfuvid across HTTP clients; our WS handshakes never echo them, so
 // Cloudflare may re-shard every fresh socket). Jar is per-process, keyed by
 // auth account. Env knobs (A/B):
 //   MIXDOG_OAI_CF_COOKIES=1        capture Set-Cookie from the 101 upgrade and
 //                                  send Cookie on subsequent handshakes
 //   MIXDOG_OAI_SESSION_AFFINITY=1  send x-session-affinity: <cacheKey>
-//                                  (opencode request.ts:187, ws-pool.ts:66)
-//   MIXDOG_OAI_WS_URL_SESSION=0    drop the ?session_id= URL query (codex/pi/
-//                                  opencode all use the bare WS URL)
+//                                  (a known cache-affinity hint)
+//   MIXDOG_OAI_WS_URL_SESSION=0    drop the ?session_id= URL query (reference
+//                                  clients all use the bare WS URL)
 function _getPoolArr(poolKey) {
     if (!poolKey) return null;
     let arr = _wsPool.get(poolKey);
@@ -340,15 +340,15 @@ function _buildHandshakeHeaders({ auth, sessionToken, turnState, cacheKey: _cach
             'x-codex-beta-features': _codexBetaFeatures(),
         };
     const isOpenAiOauth = auth.type !== 'xai' && auth.type !== 'openai-direct';
-    // codex-rs sends only the dashed session-id/thread-id pair
-    // (client.rs:1033-1057), but OUR backend measurements disagree with pure
-    // codex parity here: 2026-04-19 probes showed the OAuth backend dedupes
+    // The reference client sends only the dashed session-id/thread-id pair,
+    // but OUR backend measurements disagree with pure
+    // wire parity here: 2026-04-19 probes showed the OAuth backend dedupes
     // its in-memory prefix state by the underscore session_id handshake
     // header, and the only 0.0%-miss full-frame rounds (R7/R8, R15 regressed
     // to 13% after this header was dropped) all had it present. Send both.
     // The underscore session_id is the backend prefix-dedupe key (2026-04-19
-    // probes; R15 regressed to 13% miss when it was dropped). Codex parity
-    // (client.rs:1033-1057) sends ONLY the dashed pair, but dropping this
+    // probes; R15 regressed to 13% miss when it was dropped). Strict wire
+    // parity sends ONLY the dashed pair, but dropping this
     // header is a KNOWN cache-unsafe change — so the general parity flag no
     // longer silently drops it. Keep it unless an operator EXPLICITLY opts
     // into the codex-exact dashed-only wire via
@@ -432,7 +432,7 @@ function _openSocket({ auth, sessionToken, turnState, externalSignal, cacheKey,
     if (process.env.MIXDOG_DEBUG_AGENT) {
         process.stderr.write(`[agent-trace] ws-open-start url=${baseUrl} tokenHash=${createHash('sha256').update(String(sessionToken)).digest('hex').slice(0, 8)} ts=${_wsOpenStart}\n`);
     }
-    // Bare WS URL by default (codex/pi/opencode parity). Interleaved A/B
+    // Bare WS URL by default (reference-client parity). Interleaved A/B
     // (2026-07-04, ivA/ivB, 24 sessions each, alternating rounds to cancel
     // server-time noise): dropping the ?session_id= query improved it1
     // warmup-prefix hits 15/24 -> 22/24 and it2 full hits 11 -> 15 (miss

package/src/runtime/agent/orchestrator/providers/openai-ws-stream.mjs

@@ -126,9 +126,8 @@ function _writeWsLifecycleTrace(lifecycle) {
     process.stderr.write(`[ws-trace] t=${new Date().toISOString()} lifecycle=${lifecycle}\n`);
 }
 
-// Wire-level `end_turn` on a terminal Responses frame (codex-rs
-// codex-api/src/sse/responses.rs ResponseCompleted.end_turn: Option<bool>,
-// consumed in core/src/session/turn.rs:2299 as "false ⇒ needs follow-up").
+// Wire-level `end_turn` on a terminal Responses frame: an optional boolean on
+// the completed response, where "false ⇒ needs follow-up".
 // The field is optional: only a real boolean is normalized; anything else —
 // including a missing field — stays undefined so absence is preserved and no
 // caller can mistake "server said nothing" for "server said true/false".

package/src/runtime/agent/orchestrator/providers/registry.mjs

@@ -35,6 +35,12 @@ let _initChain = Promise.resolve();
 let _inFlightPromise = null;
 let _inFlightSig = null;
 let _lastAppliedSig = null;
+// Provider instances are process-global inside the backend daemon. Catalog
+// readers use this revision to share one raw model snapshot while still
+// rebuilding their cheap route/config projection after auth/config changes.
+let _providerCatalogRevision = 0;
+let _startupCatalogRefreshPromise = null;
+let _catalogRefreshPromise = null;
 
 // Deterministic structural signature of a provider config. Recursively sorts
 // object keys so signature equality reflects config-value equality regardless
@@ -141,7 +147,12 @@ export async function initProviders(config, { signal = null } = {}) {
         }
     };
     const tracked = next.then(
-        (v) => { _lastAppliedSig = sig; settle(); return v; },
+        (v) => {
+            if (_lastAppliedSig !== sig) _providerCatalogRevision += 1;
+            _lastAppliedSig = sig;
+            settle();
+            return v;
+        },
         (err) => { settle(); throw err; },
     );
     _inFlightSig = sig;
@@ -236,6 +247,7 @@ export function getProvider(name) {
         if (!Ctor) return undefined;
         const inst = wrapProviderAdmission(new Ctor({}), name);
         providers.set(name, inst);
+        _providerCatalogRevision += 1;
         return inst;
     }
     if (name === 'openai-oauth' && hasOpenAIOAuthCredentials()) {
@@ -243,6 +255,7 @@ export function getProvider(name) {
         if (!Ctor) return undefined;
         const inst = wrapProviderAdmission(new Ctor({}), name);
         providers.set(name, inst);
+        _providerCatalogRevision += 1;
         return inst;
     }
     if (name === 'grok-oauth' && hasGrokOAuthCredentials()) {
@@ -250,6 +263,7 @@ export function getProvider(name) {
         if (!Ctor) return undefined;
         const inst = wrapProviderAdmission(new Ctor({}), name);
         providers.set(name, inst);
+        _providerCatalogRevision += 1;
         return inst;
     }
     return undefined;
@@ -287,6 +301,9 @@ export function getAllProviders() {
     // stale entries across re-init (initProviders rebuilds the map in place).
     return new Map(providers);
 }
+export function providerCatalogRevision() {
+    return _providerCatalogRevision;
+}
 // Narrow synchronous test seam for the lazy-OAuth boundary. It models a
 // constructor whose module is already loaded while guaranteeing every touched
 // registry entry is restored, even when the assertion callback throws.
@@ -311,6 +328,20 @@ export function _withLoadedProviderCtorForTest(name, Ctor, fn) {
         else signatures.delete(name);
     }
 }
+// Companion seam for registry walks that iterate live INSTANCES (what
+// initProviders leaves behind) rather than constructors — the startup catalog
+// refresh is one. Restores the prior entry even when the callback throws.
+export function _withRegisteredProviderForTest(name, instance, fn) {
+    const hadProvider = providers.has(name);
+    const priorProvider = providers.get(name);
+    providers.set(name, instance);
+    try {
+        return fn();
+    } finally {
+        if (hadProvider) providers.set(name, priorProvider);
+        else providers.delete(name);
+    }
+}
 // Background catalog warm-up. Each provider's listModels() either hits its
 // own cached model list (no-op) or fires a single HTTP refresh. Called from
 // agent.init() after providers are registered so the first agent dispatch call
@@ -336,7 +367,9 @@ function warmupCatalogs() {
     }
 }
 
-// Force-refresh each provider's /models catalog on every MCP start. Unlike
+// Force-refresh each provider's /models catalog ONCE per backend-daemon
+// lifetime. Every session runtime joins this process-global promise and then
+// reads the same provider-instance caches. Unlike
 // warmupCatalogs (which calls listModels() and so respects the 24h provider
 // TTL → no-op when the cache is fresh), this bypasses the TTL via
 // _refreshModelCache so a model released since the last refresh is picked up
@@ -345,6 +378,7 @@ function warmupCatalogs() {
 // context metadata stays on its own 24h TTL. Fire-and-forget: never awaited,
 // per-provider failures logged to stderr like warmupCatalogs.
 export function refreshProviderCatalogsOnStartup() {
+    if (_startupCatalogRefreshPromise) return _startupCatalogRefreshPromise;
     const pending = [];
     for (const [name, provider] of providers) {
         const refreshFn = typeof provider?._refreshModelCache === 'function'
@@ -361,7 +395,11 @@ export function refreshProviderCatalogsOnStartup() {
     // Returns a completion promise so callers can invalidate stale model
     // caches once the fresh catalogs land. Still fire-and-forget: unawaited
     // callers keep the previous nonblocking startup behavior.
-    return Promise.allSettled(pending);
+    _startupCatalogRefreshPromise = Promise.allSettled(pending).then((results) => {
+        _providerCatalogRevision += 1;
+        return results;
+    });
+    return _startupCatalogRefreshPromise;
 }
 
 // Force-refresh provider catalogs after an operator changes model/provider
@@ -369,6 +407,7 @@ export function refreshProviderCatalogsOnStartup() {
 // the shared LiteLLM metadata cache first so context/pricing metadata follows
 // newly released models without waiting for the next process restart.
 export function refreshCatalogs() {
+    if (_catalogRefreshPromise) return _catalogRefreshPromise;
     const pending = [];
     const metadataReady = Promise.resolve()
         .then(() => refreshMetadataCatalog())
@@ -391,5 +430,13 @@ export function refreshCatalogs() {
             }));
     }
     // Completion promise: lets callers drop stale model caches after refresh.
-    return Promise.allSettled([metadataReady, ...pending]);
+    _catalogRefreshPromise = Promise.allSettled([metadataReady, ...pending])
+        .then((results) => {
+            _providerCatalogRevision += 1;
+            return results;
+        })
+        .finally(() => {
+            _catalogRefreshPromise = null;
+        });
+    return _catalogRefreshPromise;
 }

package/src/runtime/agent/orchestrator/providers/retry-classifier.mjs

@@ -252,7 +252,7 @@ function isRetryable(err) {
   return classifyError(err) === 'transient'
 }
 
-/** Claude Code compatible Anthropic request budget: 10 retries (11 attempts).
+/** Anthropic request budget: 10 retries (11 attempts).
  * CLAUDE_CODE_MAX_RETRIES is intentionally read per request for reload/tests.
  * The upper bound prevents an accidental unbounded retry loop. */
 export function anthropicMaxAttempts() {
@@ -262,16 +262,16 @@ export function anthropicMaxAttempts() {
   return retries + 1
 }
 
-// Claude Code request defaults (withRetry.ts): 500ms exponential backoff,
+// Anthropic retry defaults: 500ms exponential backoff,
 // capped at 32s, with positive-only jitter up to 25% of the base delay.
-// The leading duplicate accounts for withRetry's sleep-before-attempt index:
+// The leading duplicate accounts for the sleep-before-attempt index:
 // retry attempt 2 reads index 1.
 export const ANTHROPIC_RETRY_BACKOFF_MS = Object.freeze([
   500, 500, 1000, 2000, 4000, 8000, 16000, 32000, 32000, 32000, 32000,
 ])
 export const ANTHROPIC_RETRY_JITTER_RATIO = 0.25
 
-// Claude Code's Anthropic SDK client defaults API_TIMEOUT_MS to ten minutes.
+// The Anthropic SDK client defaults API_TIMEOUT_MS to ten minutes.
 // Read per request, like CLAUDE_CODE_MAX_RETRIES, so env reload/tests work.
 export function anthropicRequestTimeoutMs() {
   const parsed = Number.parseInt(process.env.API_TIMEOUT_MS || '', 10)
@@ -318,10 +318,10 @@ export function jitterDelayMs(ms, ratio = PROVIDER_RETRY_JITTER_RATIO, mode = 's
 // Mid-stream 'stream_stalled' recoveries retry in place, which is right for a
 // one-off blip but lets a chronically dying stream burn a whole task budget
 // slowly (observed live: one send stretched 149s→298s→556s across stall
-// retries before the agent deadline killed the task). Reference stacks bound
-// this instead of retrying forever: Claude Code caps each request at ~300s
-// wall clock (API_TIMEOUT_MS) and Codex kills a stream after one 300s silent
-// gap (stream_idle_timeout). This guard is the equivalent for our in-place
+// retries before the agent deadline killed the task). A stalling stream is
+// bounded instead of retried forever: a request is capped at ~300s wall
+// clock (API_TIMEOUT_MS) and a stream dies after one 300s silent gap
+// (stream idle timeout). This guard is the equivalent for our in-place
 // recovery: the clock starts at the FIRST stall of a send, and stall-classified
 // retries are allowed only inside that window; past it the stall error
 // surfaces so loop-level transport retry issues a FRESH request. Healthy
@@ -357,7 +357,7 @@ export function createStallRetryBudget(budgetMs = STREAM_STALL_RETRY_BUDGET_MS,
 // branched on a hardcoded provider name.
 
 // F) Retry-budget profiles as DATA. The numbers live ONLY here now.
-//    ws.*Retries (5)              — one Codex Responses stream retry budget.
+//    ws.*Retries (5)              — one Responses stream retry budget.
 //    sse.defaultRetries (3)       — anthropic single-shot SSE mid-stream budget.
 export const MIDSTREAM_RETRY_POLICY = {
   ws: { transientCloseRetries: 5, defaultRetries: 5, backoff: [250, 1000, 2000, 4000, 5000] },
@@ -490,7 +490,7 @@ function _classifyMidstreamWs(err, state, attemptIndex, policy) {
 }
 
 // Explicit `response.failed` error codes/types that describe a transport-level
-// interruption (Codex retries these); every other code is terminal.
+// interruption (these are retryable); every other code is terminal.
 const RESPONSE_FAILED_CODE_CLASSIFIERS = new Map([
   ['stream_disconnected', 'response_failed_disconnected'],
   ['network_error', 'response_failed_network'],
@@ -550,7 +550,7 @@ export function shouldFallbackTransport(err, { signal, enabled = true } = {}) {
   if (signal?.aborted) return false
   // Transport fallback re-issues the request on another transport: it is a
   // replay, so the exposure deny applies. Eligibility itself stays typed
-  // (status / errno / classifier), matching Codex's WS→HTTPS switch.
+  // (status / errno / classifier) for the WS→HTTPS switch.
   if (readStreamOutcome(err).replaySafe !== true) return false
   const status = Number(err?.httpStatus || err?.status || 0)
   // 401 is auth recovery, never transport fallback. 426 is the explicit
@@ -660,7 +660,7 @@ function _sleepChunkWithAbort(ms, signal, sleepFn, abortMessage) {
 // E) Handshake classifier (moved here from openai-oauth-ws). Default-deny:
 //    anything not recognized as transient returns null. HTTP 401 is reserved
 //    for auth recovery and 426 for immediate HTTPS fallback. The OpenAI OAuth
-//    caller opts out of 429 retries (Codex retry_429:false); all other callers
+//    caller opts out of 429 retries (retry429:false); all other callers
 //    retain the historical retryable UnexpectedStatus policy.
 export function classifyHandshakeError(err, { retry429 = true } = {}) {
   if (!err) return null
@@ -764,8 +764,8 @@ export async function withRetry(fn, opts = {}) {
       // an eligible failure is actually retried remains the typed question
       // resolved by classifyError()/status below.
       if (readStreamOutcome(caught).replaySafe !== true) throw caught
-      // Claude Code treats x-should-retry:false as an explicit server veto
-      // (except an internal-only 5xx override that Mixdog does not have).
+      // x-should-retry:false is an explicit server veto on retrying and is
+      // honored as-is.
       // Keep this ahead of status defaults, including the request-local 429 path.
       const shouldRetryHeader = _headerValue(
         caught?.headers || caught?.response?.headers || caught?.data?.responseHeaders,
@@ -786,7 +786,7 @@ export async function withRetry(fn, opts = {}) {
         }
         continue
       }
-      // Claude Code's optional model fallback fires on the third 529. This
+      // The optional model fallback fires on the third 529. This
       // remains opt-in: providers pass fallbackModel only when the caller set
       // one. The hard progress veto above must run first so fallback can never
       // replay partial thinking/tool output.

package/src/runtime/agent/orchestrator/session/agent-loop.mjs

@@ -91,7 +91,6 @@ import {
     isOutputLimitStopReason,
     providerContinuationSignal,
 } from './loop/termination.mjs';
-import { createSteeringLadder } from './loop/steering-ladder.mjs';
 import { runPreSendCompactPass } from './pre-send-compact.mjs';
 import { createEagerDispatcher } from './eager-dispatch.mjs';
 import { sendWithRecovery } from './send-with-recovery.mjs';
@@ -238,7 +237,7 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
     if (compactSettledToolCallBodies(messages) && !opts.cacheBreakIntent) {
         opts.cacheBreakIntent = 'deferred_body_compaction';
     }
-    // ---- Codex turn stop hook (refs/codex core/src/session/turn.rs:372-404) --
+    // ---- Turn stop hook ----------------------------------------------------
     // A no-tool assistant message is TERMINAL. Only a structured provider
     // follow-up signal (end_turn=false / pause_turn), pending input, tool
     // calls/results, or a stop hook that blocks with a continuation prompt keep
@@ -280,8 +279,8 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
             }
             // Tag steering-origin user messages so provider lowering keeps them
             // distinct from preceding tool results. Keep each queued command as
-            // its own user turn, matching Claude Code queued_command attachment
-            // semantics instead of collapsing priority/mode buckets together.
+            // its own user turn instead of collapsing priority/mode buckets
+            // together.
             messages.push({
                 role: 'user',
                 content: merged.content,
@@ -366,9 +365,10 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
     };
     const maxLoopIterations = resolveSessionMaxLoopIterations(sessionRef);
     // ---- Completion-first loop guards (worker runaway prevention) ----
-    // Step 1 (escalation ladder) + the missed-parallelism / serial-rewording
-    // steering hints live in the createSteeringLadder controller below; it owns
-    // their cumulative counters and emits at most one hint per turn.
+    // Behavior-steering hints (missed-parallelism, all-read-only, read-only
+    // shell, level-2 "stop exploring") were removed: they nudged tool shape
+    // instead of protecting resources. Only the staged iteration warnings, the
+    // hard cap, and the cross-turn dedup stub remain.
     // _editCount counts any executed tool call whose def lacks readOnlyHint
     // (i.e. edit/progress: apply_patch, bash, MCP writes, skills, ...).
     let _editCount = 0;
@@ -406,7 +406,7 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
     // Loop-level transport replays consumed this ask (see send-with-recovery
     // TRANSPORT_RETRY_MAX): bounded per turn, reset only with a fresh ask.
     let _transportRetriesUsed = 0;
-    // Claude Code parity: queued prompt/task notifications are attached after a
+    // Queued prompt/task notifications are attached after a
     // tool batch, before the continuation provider send. Normal batches drain
     // up to 'next'; a Sleep-like tool grants a 'later' flush.
     let _toolBatchJustCompleted = false;
@@ -415,20 +415,6 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
         const name = String(call?.name || call?.toolName || call?.function?.name || '').toLowerCase();
         return name === 'sleep' || name.endsWith('/sleep') || name.endsWith('.sleep');
     };
-    // Completion-first steering ladder controller. Owns the (cumulative) level-1
-    // fire count, the all-read-only / serial-single / same-file-grep streaks,
-    // and the level-2 latch. Threaded via live getters so it reads the loop's
-    // current `iterations` / `_editCount` on every call (no stale snapshots).
-    const _steeringLadder = createSteeringLadder({
-        sessionId,
-        sessionAgent,
-        tools,
-        getIterations: () => iterations,
-        getEditCount: () => _editCount,
-        readOnlyRole: String(sessionRef?.permission || sessionRef?.toolPermission || '') === 'read',
-        pushUserMessage: (msg) => messages.push(msg),
-        pushSystemReminder: (text) => messages.push({ role: 'user', content: `<system-reminder>\n${text}\n</system-reminder>`, meta: 'hook' }),
-    });
     // Tool execution must use the session cwd even when the caller omitted the
     // legacy positional cwd argument. Agent workers always carry their cwd on
     // sessionRef; falling through to pwd()/process.cwd() resolves relatives
@@ -503,8 +489,7 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
             } catch { /* best-effort */ }
         }
         // Drain queued steering/prompts BEFORE the pre-send compact check, but
-        // only immediately after a tool batch has completed. This mirrors
-        // Claude Code's query.ts queued_command attachment drain: queued entries
+        // only immediately after a tool batch has completed: queued entries
         // are attached after tool results are appended and before the recursive
         // continuation, not on arbitrary non-tool continuations (empty nudges,
         // iteration-cap final text turns, etc.).
@@ -792,11 +777,6 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
         // tool-call-blocked vs contract-required oscillation.
         if (!response.toolCalls?.length) {
             // No tool calls. Decide between final-answer accept vs nudge.
-            // Reviewer fix: a zero-tool turn (final-pre-send steering drain or
-            // contract nudge `continue`) must not bridge the all-read-only
-            // streak across non-tool turns — that would fire level-2 early on
-            // a worker that paused to synthesize text mid-run.
-            _steeringLadder.resetAllReadOnlyStreak();
             //   - has content + non-hidden role → valid final, break.
             //   - empty content + hidden role → contract allows text-only
             //     terminal turn, break.
@@ -915,7 +895,7 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
                 messages.push({ role: 'user', content: nudgeMsg });
                 continue;
             }
-            // Codex `has_pending_input` (turn.rs:304-318): queued user input is
+            // Pending-input rule: queued user input is
             // folded into needs_follow_up and evaluated BEFORE the stop hooks,
             // so real steering always wins over a synthetic continuation prompt.
             // Commit the terminal text first (beforeAppend), then resume.
@@ -926,7 +906,7 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
                 _emptyNudgeStreak = 0;
                 continue;
             }
-            // Codex parity (turn.rs:372-404): this no-tool message ends the turn
+            // This no-tool message ends the turn
             // unless a stop hook blocks it. The unresolved-tool-failure hook may
             // block exactly once — commit the assistant text, record the
             // structural continuation prompt, resume sampling. Skipped on the
@@ -1064,7 +1044,7 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
             pending: eager.pending, epoch: eager.epoch, startEagerRun: eager.startEagerRun,
             crossTurnCalls: _crossTurnCalls, crossTurnCap: _CROSS_TURN_CAP,
             dedupStubTotal: _dedupStubTotal, editCount: _editCount,
-            sessionAgent, steeringLadder: _steeringLadder,
+            sessionAgent,
             pushToolResultMessage, throwIfAborted,
             repeatFailLimit: REPEAT_FAIL_LIMIT,
         }));

package/src/runtime/agent/orchestrator/session/cache/read-cache.mjs

@@ -3,6 +3,8 @@
 import { _normalizeAbs, _statTuple, _statEqual } from './util.mjs';
 import { clearScopedToolsForSession, clearScopedCounters } from './scoped-cache.mjs';
 import { clearPostEditMarks } from './post-edit-marks.mjs';
+import { registerSessionPurgeHook } from '../store.mjs';
+import { releaseReadSnapshotScope } from '../../tools/builtin/snapshot-store.mjs';
 
 const MAX_PER_SESSION = 100;
 
@@ -260,6 +262,11 @@ export function clearReadDedupSession(sessionId) {
     clearScopedCounters(sessionId);
 }
 
+registerSessionPurgeHook((sessionId) => {
+    clearReadDedupSession(sessionId);
+    releaseReadSnapshotScope(sessionId, { deletePersisted: true, persist: false });
+});
+
 /**
  * Extract the set of touched filesystem paths from a unified-diff patch text.
  * Handles git-style `--- a/<path>` / `+++ b/<path>` headers and `/dev/null` markers.