mixdog 0.9.91 → 0.9.93

package/src/output-styles/simple.md

@@ -2,7 +2,7 @@
 name: simple
 title: Simple
 description: Outcome-first concise handoffs for coding work
-aliases: concise, handoff, default
+aliases: concise, handoff
 keep-coding-instructions: true
 ---
 

package/src/rules/agent/00-core.md

@@ -1,7 +1,6 @@
 # Agent Constraints
 
-- Agent communication is English. One turn is one batch; include every
-  compatible read-only call.
+- Agent communication is English.
 - Call tools immediately: no preamble/progress; text only in final handoff.
 - Final handoff is fragments: outcome, key `file:line`, verification
   command+result, material risk/blocker. Never repeat the brief, process,

package/src/rules/lead/01-general.md

@@ -8,6 +8,7 @@
   validated target paths — never `~`, a root, or unresolved variables/globs;
   report material deletions with recoverability.
 - Act proactively; ask only for decisions.
+- Build only what the task requires; trust internal and framework guarantees.
 - Mid-task input: a replacement supersedes current work, an addition folds
   into it, a status question gets a brief answer while work continues; after
   context compaction continue from the summary — never restart or redo

package/src/rules/shared/01-tool.md

@@ -1,21 +1,18 @@
 # Tool Use
 
-- Before the first call, gather every known facet in one tool message; one
-  shortest route per facet: broad/uncertain→`explore` (roles without it:
-  `find`); partial path/name→`find`; verified root+wildcard→`glob`;
-  quoted/non-identifier literal or regex→`grep`; exact code identifier/
-  relation→`code_graph` before grep; known file/span→`read` directly without
-  `grep`; verified directory→`list`; known edit→`apply_patch` (span already
-  seen; else `read`/`grep` first); program/state change→`shell`; web/current
-  external info→`search`.
-- Shortest total calls, maximum batching — every turn: all independent calls
-  in one concurrent message (shell included); combine variants/symbols/
-  scopes/paths/queries per call; same-file regions as one real
-  `{path,offset,limit}` array; graph targets as arrays; `explore` facets in
-  one `query[]` (max 8, no rephrased duplicates); all new edits in one patch.
-  Distinct facets, not alternative routes; sequential singles only for a
-  genuinely dependent step (unconditional follow-ups are not dependent —
-  batch them); only apply_patch executes in order.
+- Before the first call, gather every known facet — environment, capability,
+  artifact, and failure checks — in one bounded tool message. Use one shortest
+  route per facet: broad/uncertain→`explore` (roles without it: `find`);
+  partial path/name→`find`; verified root+wildcard→`glob`;
+  quoted/non-identifier literal or regex→`grep`; exact code
+  identifier/relation→`code_graph` before grep; known file/span→`read`
+  directly without `grep`; verified directory→`list`; known
+  edit→`apply_patch`; program/state change→`shell`; web/current external
+  info→`search`.
+- Shortest total calls, maximum batching — every turn: every determined call
+  in one concurrent message (mix `shell` in), merged per tool — one `shell`
+  chain, one `read`, one `apply_patch` carrying full verification in
+  `post_shell`; a later turn only for steps needing unseen output.
 - Verified paths: project root, session cwd, user-provided, tool-returned.
   `find` first for guessed path/name fragments; on ENOENT, find the basename.
   Retry `EXPLORATION_FAILED` once with changed tokens.
@@ -23,11 +20,12 @@
   nonzero `content_with_context` result is final — act on it (inspecting it
   via read/code_graph is valid); only zero/error results justify changed
   tokens or scope. Don't re-locate, re-verify, or reread returned spans.
-- `apply_patch` is the primary edit tool: send the patch as soon as target
-  path and new content are known. Hunk context comes verbatim from the newest
-  tool output of that span (`read`/`grep`/your own patch — post-patch content
-  after edits), never retyped from memory; one look-up beats a failed patch.
-  A same-turn shell after `apply_patch` runs once the patch lands.
+- Verify changes in proportion to risk with one decisive batched boundary
+  probe. A pass is final; on failure, fix and rerun only what failed. Keep
+  optional diagnostics non-fatal; report verified vs assumed.
+- `apply_patch` is the primary edit tool: once target path and new content are
+  known, include the patch in the current tool batch, hunk context verbatim
+  from the newest tool output of that span (post-patch content after edits).
 - After starting or receiving a background task, end the turn — its
   completion notification resumes the work. Never poll, sleep-loop, or block;
   explicit wait only for a result the current turn cannot proceed without.

package/src/runtime/agent/orchestrator/agent-runtime/cache-strategy.mjs

@@ -120,18 +120,31 @@ export function resolveCacheStrategy(agent, { autoClear } = {}) {
     if (isOneShotMaintenanceAgent(agent)) {
         return { tools: 'none', system: 'none', tier3: 'none', messages: 'none' };
     }
+    // Operator override for the BP4 (messages-tail) TTL. Short-lived
+    // rapid-turn deployments (bench-style: session dies in <15min) never
+    // benefit from a 1h tail across its premium window, so '5m' trades the
+    // 2x write premium (1h, $10/M) down to 1.25x ($6.25/M) and deactivates
+    // the 1h volatile-content anchor guard. Product defaults below stay
+    // untouched when the env is unset.
+    const envMessagesTtl = (process.env.MIXDOG_CACHE_MESSAGES_TTL || '').trim();
+    const applyEnv = (strategy) => {
+        if (envMessagesTtl === '1h' || envMessagesTtl === '5m' || envMessagesTtl === 'none') {
+            return { ...strategy, messages: envMessagesTtl };
+        }
+        return strategy;
+    };
     if (getHiddenAgent(agent)) {
-        return { tools: 'none', system: '1h', tier3: '1h', messages: '1h' };
+        return applyEnv({ tools: 'none', system: '1h', tier3: '1h', messages: '1h' });
     }
     if (agent && agent !== 'lead') {
         // Public (non-hidden, non-lead) agents keep the flat 1h tail — only
         // the Lead session's tail is linked to autoClear.
-        return { tools: 'none', system: '1h', tier3: '1h', messages: '1h' };
+        return applyEnv({ tools: 'none', system: '1h', tier3: '1h', messages: '1h' });
     }
     // Lead session (agent === 'lead', or no agent — raw/CLI callers default
     // to Lead behavior): message tail TTL is linked to autoClear (see
     // resolveLeadMessagesTtl).
-    return { tools: 'none', system: '1h', tier3: '1h', messages: resolveLeadMessagesTtl(autoClear) };
+    return applyEnv({ tools: 'none', system: '1h', tier3: '1h', messages: resolveLeadMessagesTtl(autoClear) });
 }
 
 /**

package/src/runtime/agent/orchestrator/agent-trace.mjs

@@ -38,6 +38,22 @@ function extractCachedTokens(usage) {
     return 0;
 }
 
+function extractCacheWriteTokens(usage) {
+    const candidates = [
+        usage?.input_tokens_details?.cache_write_tokens,
+        usage?.prompt_tokens_details?.cache_write_tokens,
+        usage?.inputTokensDetails?.cacheWriteTokens,
+        usage?.promptTokensDetails?.cacheWriteTokens,
+        usage?.cache_write_tokens,
+        usage?.cacheWriteTokens,
+    ];
+    for (const value of candidates) {
+        const n = Number(value);
+        if (Number.isFinite(n)) return n;
+    }
+    return 0;
+}
+
 // Lightweight fingerprint of the conversation prefix. Hashes the first 4096
 // characters of JSON.stringify(messages) — enough to detect prefix mutation
 // across iterations (which invalidates the provider prompt cache) without
@@ -267,6 +283,7 @@ export {
     appendAgentTrace,
     drainAgentTrace,
     estimateProviderPayloadBytes,
+    extractCacheWriteTokens,
     extractCachedTokens,
     messagePrefixHash,
     traceAgentFetch,

package/src/runtime/agent/orchestrator/context/collect.mjs

@@ -275,7 +275,7 @@ export function buildSkillToolEnvelope(name, content, skillDir) {
     };
 }
 
-function compactSkillManifestText(value, max = 180) {
+function compactSkillManifestText(value, max = 100) {
     const text = String(value || '').replace(/\s+/g, ' ').trim();
     return text.length > max ? `${text.slice(0, Math.max(1, max - 3))}...` : text;
 }
@@ -528,6 +528,7 @@ export function buildSkillToolDefs(skills, { ownerIsAgentSession = false } = {})
                     name: { type: 'string', description: 'Skill name' },
                 },
                 required: ['name'],
+                additionalProperties: false,
             },
         },
     ];

package/src/runtime/agent/orchestrator/providers/anthropic-effort.mjs

@@ -208,7 +208,15 @@ export function applyAnthropicEffortToBody(
         // modelSupportsEffort() allowlist so older models never receive it.
         // Set unconditionally (independent of `normalized`) so effort-capable
         // turns always carry adaptive thinking + round-trip signatures.
-        body.thinking = { type: 'adaptive', display: 'summarized' };
+        // MIXDOG_ANTHROPIC_THINKING_DISPLAY=omitted (operator/bench knob):
+        // CC-parity mode — no thinking blocks come back, so nothing is
+        // replayed into later requests (saves the 1h cache-write + re-read on
+        // accumulated thinking) at the cost of losing visible reasoning and
+        // cross-iteration thinking continuity. Default stays summarized.
+        const display = (process.env.MIXDOG_ANTHROPIC_THINKING_DISPLAY || '').trim() === 'omitted'
+            ? 'omitted'
+            : 'summarized';
+        body.thinking = { type: 'adaptive', display };
         // Adaptive/4.7+ models reject any non-default sampling param with a 400.
         delete body.temperature;
         delete body.top_p;

package/src/runtime/agent/orchestrator/providers/anthropic-oauth.mjs

@@ -50,8 +50,10 @@ import {
     anthropicRequestTimeoutMs,
     classifyError,
     anthropicMaxAttempts,
+    createStallRetryBudget,
     midstreamBackoffFor,
     retryAfterMsFromError,
+    STREAM_STALL_RETRY_BUDGET_MS,
     withRetry,
 } from './retry-classifier.mjs';
 import {
@@ -62,6 +64,18 @@ import {
     stampAnthropicStreamOutcome,
 } from './anthropic-sse.mjs';
 import { buildAnthropicBetaHeaders, supportsAnthropicFastMode } from './anthropic-betas.mjs';
+import { gzipSync } from 'node:zlib';
+
+// Request-body gzip gate (see the fetch site below). Env kill-switch
+// (MIXDOG_ANTHROPIC_REQ_GZIP=0) plus a process-wide latch flipped on the
+// first 400 response to a compressed request. Small bodies skip compression:
+// below ~8KB the CPU + header cost outweighs the upload saving.
+const ANTHROPIC_REQ_GZIP_MIN_BYTES = 8 * 1024;
+let _anthropicReqGzipLatch = false;
+function _anthropicReqGzipDisabled() {
+    return _anthropicReqGzipLatch || process.env.MIXDOG_ANTHROPIC_REQ_GZIP === '0';
+}
+function _disableAnthropicReqGzip() { _anthropicReqGzipLatch = true; }
 import {
     applyAnthropicEffortToBody,
     effortValuesForModel,
@@ -652,7 +666,16 @@ export class AnthropicOAuthProvider {
                 // provider-visible cache breakpoint off the cached one — the
                 // exact COLD-turn bug this change fixes. Order is fixed:
                 // build → sanitize (once) → mark → JSON.stringify.
-                const response = await fetch(API_URL, {
+                // Request-body gzip (probe-verified 2026-08-04: /v1/messages
+                // returns 200 for Content-Encoding: gzip, 400 for zstd). Large
+                // turn bodies (system prompt + history, typically 50-100KB+)
+                // compress ~5-10x, trimming upload time off every call's
+                // header wait. Latch OFF process-wide on the first 400 seen on
+                // a compressed request and retry that attempt uncompressed, so
+                // a server-side behavior change can never wedge the session.
+                const rawBody = Buffer.from(JSON.stringify(requestBody));
+                const useGzip = !_anthropicReqGzipDisabled() && rawBody.length >= ANTHROPIC_REQ_GZIP_MIN_BYTES;
+                const sendAttempt = (gz) => fetch(API_URL, {
                     method: 'POST',
                     headers: {
                         'Authorization': `Bearer ${accessToken}`,
@@ -667,11 +690,18 @@ export class AnthropicOAuthProvider {
                         'user-agent': `claude-cli/${resolveCliVersion()} (external, sdk-cli)`,
                         'x-app': 'cli',
                         'Content-Type': 'application/json',
+                        ...(gz ? { 'Content-Encoding': 'gzip' } : {}),
                     },
-                    body: JSON.stringify(requestBody),
+                    body: gz ? gzipSync(rawBody) : rawBody,
                     signal: controller.signal,
                     dispatcher: getLlmDispatcher(),
                 });
+                let response = await sendAttempt(useGzip);
+                if (useGzip && response.status === 400) {
+                    _disableAnthropicReqGzip();
+                    try { await response.arrayBuffer(); } catch { /* drain best-effort */ }
+                    response = await sendAttempt(false);
+                }
 
                 traceAgentFetch({
                     sessionId,
@@ -774,26 +804,17 @@ export class AnthropicOAuthProvider {
         const MAX_MIDSTREAM_RETRIES = ANTHROPIC_MAX_MIDSTREAM_RETRIES;
         let firstAttemptError = null;
         let firstAttemptClassifier = null;
-
-        const recoverNonStreaming = async (midState, streamingError, controller) => {
-            const exposedChars = Number(midState?.emittedTextChars) || 0;
-            if (!onTextReset || exposedChars <= 0
-                || midState.emittedToolCall || midState.partialToolCall || midState.emittedThinking) {
-                try { streamingError.liveTextEmitted = true; streamingError.unsafeToRetry = true; } catch {}
-                throw streamingError;
-            }
-            let resetAccepted = false;
-            try {
-                resetAccepted = await onTextReset({
-                    chars: exposedChars,
-                    reason: 'anthropic-streaming-fallback',
-                }) === true;
-            } catch {}
-            if (!resetAccepted) {
-                try { streamingError.liveTextEmitted = true; streamingError.unsafeToRetry = true; } catch {}
-                throw streamingError;
-            }
-            try { controller?.abort?.(streamingError); } catch {}
+        // Send-scoped stall window: in-place stall retries share one wall
+        // clock starting at the first stall (see createStallRetryBudget).
+        const stallRetryBudget = createStallRetryBudget();
+
+        // Core non-streaming re-issue: abort the dead stream and repeat the
+        // SAME request with stream:false. Shared by the exposed-text recovery
+        // (which must first get the owner's onTextReset acknowledgement) and
+        // the no-exposure stall fallback below (trivially safe — nothing was
+        // relayed or dispatched, so there is nothing to withdraw or replay).
+        const issueNonStreamingFallback = async (controller, abortReason) => {
+            try { controller?.abort?.(abortReason); } catch {}
             try { onStageChange?.('requesting', { transport: 'non-streaming-fallback' }); } catch {}
             let fallback = await requestWithRetry(creds.accessToken, { ...body, stream: false });
             if (fallback.response.status === 401) {
@@ -820,6 +841,27 @@ export class AnthropicOAuthProvider {
             }
         };
 
+        const recoverNonStreaming = async (midState, streamingError, controller) => {
+            const exposedChars = Number(midState?.emittedTextChars) || 0;
+            if (!onTextReset || exposedChars <= 0
+                || midState.emittedToolCall || midState.partialToolCall || midState.emittedThinking) {
+                try { streamingError.liveTextEmitted = true; streamingError.unsafeToRetry = true; } catch {}
+                throw streamingError;
+            }
+            let resetAccepted = false;
+            try {
+                resetAccepted = await onTextReset({
+                    chars: exposedChars,
+                    reason: 'anthropic-streaming-fallback',
+                }) === true;
+            } catch {}
+            if (!resetAccepted) {
+                try { streamingError.liveTextEmitted = true; streamingError.unsafeToRetry = true; } catch {}
+                throw streamingError;
+            }
+            return issueNonStreamingFallback(controller, streamingError);
+        };
+
         try {
         for (let attemptIndex = 0; attemptIndex <= MAX_MIDSTREAM_RETRIES; attemptIndex++) {
             let response, controller, cancelHandler;
@@ -1052,6 +1094,32 @@ export class AnthropicOAuthProvider {
                     continue;
                 }
                 const classifier = _classifyMidstreamError(err, midState);
+                // CC-parity stall recovery (2026-08-03 v3 postmortem): a
+                // stalled stream that exposed NOTHING (no text/thinking
+                // relayed, no tool emitted) is re-issued NON-STREAMING instead
+                // of retrying the same streaming shape. Effort-mode models can
+                // legitimately think in silence past any streaming idle
+                // window; an in-place streaming retry re-runs the same silent
+                // generation into the same timer (observed live: deterministic
+                // 4×~138s beheading, ~552s per turn), while the non-streaming
+                // transport simply waits for the full body (bounded by
+                // PROVIDER_NONSTREAM_TOTAL_TIMEOUT_MS). Claude Code does
+                // exactly this on its watchdog aborts. Replay is trivially
+                // safe here — nothing was relayed or dispatched.
+                if (classifier === 'stream_stalled'
+                    && _outcome?.replayUnsafe !== true
+                    && !midState.emittedText
+                    && !midState.emittedToolCall
+                    && !midState.partialToolCall
+                    && !midState.emittedThinking) {
+                    try { process.stderr.write('[anthropic-oauth] stream stalled with no exposure — retrying non-streaming\n'); } catch {}
+                    return await issueNonStreamingFallback(controller, err);
+                }
+                if (classifier === 'stream_stalled' && !stallRetryBudget.allowStallRetry()) {
+                    try { process.stderr.write(`[anthropic-oauth] stall retry budget exhausted (${STREAM_STALL_RETRY_BUDGET_MS}ms since first stall) — surfacing for fresh-request retry\n`); } catch {}
+                    try { controller?.abort?.(err); } catch { /* best-effort teardown */ }
+                    throw err;
+                }
                 if (classifier && attemptIndex < MAX_MIDSTREAM_RETRIES) {
                     firstAttemptError = err;
                     firstAttemptClassifier = classifier;

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

@@ -8,8 +8,10 @@ import {
     anthropicMaxAttempts,
     anthropicRequestTimeoutMs,
     classifyError,
+    createStallRetryBudget,
     midstreamBackoffFor,
     sleepWithAbort,
+    STREAM_STALL_RETRY_BUDGET_MS,
     withRetry,
     retryAfterMsFromError,
 } from './retry-classifier.mjs';
@@ -249,6 +251,9 @@ export class AnthropicProvider {
         const MAX_MIDSTREAM_RETRIES = ANTHROPIC_MAX_MIDSTREAM_RETRIES;
         let firstAttemptError = null;
         let firstAttemptClassifier = null;
+        // Send-scoped stall window: in-place stall retries share one wall
+        // clock starting at the first stall (see createStallRetryBudget).
+        const stallRetryBudget = createStallRetryBudget();
 
         const buildReturnFromParse = (parseResult) => {
             const usageRaw = parseResult.usage?.raw || null;
@@ -315,25 +320,11 @@ export class AnthropicProvider {
             };
         };
 
-        const recoverNonStreaming = async (midState, streamingError, streamController) => {
-            const exposedChars = Number(midState?.emittedTextChars) || 0;
-            if (!onTextReset || exposedChars <= 0
-                || midState.emittedToolCall || midState.partialToolCall || midState.emittedThinking) {
-                try { streamingError.liveTextEmitted = true; streamingError.unsafeToRetry = true; } catch {}
-                throw streamingError;
-            }
-            let resetAccepted = false;
-            try {
-                resetAccepted = await onTextReset({
-                    chars: exposedChars,
-                    reason: 'anthropic-streaming-fallback',
-                }) === true;
-            } catch {}
-            if (!resetAccepted) {
-                try { streamingError.liveTextEmitted = true; streamingError.unsafeToRetry = true; } catch {}
-                throw streamingError;
-            }
-            try { streamController.abort?.(streamingError); } catch {}
+        // Core non-streaming re-issue shared by the exposed-text recovery
+        // (onTextReset-gated) and the no-exposure stall fallback (trivially
+        // safe — nothing was relayed or dispatched). Mirrors anthropic-oauth.
+        const issueNonStreamingFallback = async (streamController, abortReason) => {
+            try { streamController.abort?.(abortReason); } catch {}
             try { onStageChange?.('requesting', { transport: 'non-streaming-fallback' }); } catch {}
             const nonStreamingParams = { ...params, stream: false };
             const message = await withRetry(
@@ -357,6 +348,27 @@ export class AnthropicProvider {
             return buildReturnFromParse(normalizeAnthropicNonStreamingResponse(message, useModel));
         };
 
+        const recoverNonStreaming = async (midState, streamingError, streamController) => {
+            const exposedChars = Number(midState?.emittedTextChars) || 0;
+            if (!onTextReset || exposedChars <= 0
+                || midState.emittedToolCall || midState.partialToolCall || midState.emittedThinking) {
+                try { streamingError.liveTextEmitted = true; streamingError.unsafeToRetry = true; } catch {}
+                throw streamingError;
+            }
+            let resetAccepted = false;
+            try {
+                resetAccepted = await onTextReset({
+                    chars: exposedChars,
+                    reason: 'anthropic-streaming-fallback',
+                }) === true;
+            } catch {}
+            if (!resetAccepted) {
+                try { streamingError.liveTextEmitted = true; streamingError.unsafeToRetry = true; } catch {}
+                throw streamingError;
+            }
+            return issueNonStreamingFallback(streamController, streamingError);
+        };
+
         try {
             for (let attemptIndex = 0; attemptIndex <= MAX_MIDSTREAM_RETRIES; attemptIndex++) {
                 const streamController = createAbortController();
@@ -592,6 +604,29 @@ export class AnthropicProvider {
                         continue;
                     }
                     const classifier = _classifyMidstreamError(err, midState);
+                    // CC-parity stall recovery (ported from anthropic-oauth,
+                    // 2026-08-03): a stalled stream that exposed NOTHING is
+                    // re-issued non-streaming instead of retrying the same
+                    // streaming shape into the same idle window. Replay is
+                    // trivially safe — nothing was relayed or dispatched.
+                    if (classifier === 'stream_stalled'
+                        && _outcome?.replayUnsafe !== true
+                        && !midState.emittedText
+                        && !midState.emittedToolCall
+                        && !midState.partialToolCall
+                        && !midState.emittedThinking) {
+                        try { process.stderr.write(`[${this.name}] stream stalled with no exposure — retrying non-streaming\n`); } catch {}
+                        return await issueNonStreamingFallback(streamController, err);
+                    }
+                    if (classifier === 'stream_stalled' && !stallRetryBudget.allowStallRetry()) {
+                        try {
+                            process.stderr.write(
+                                `[${this.name}] stall retry budget exhausted (${STREAM_STALL_RETRY_BUDGET_MS}ms since first stall) — surfacing for fresh-request retry\n`,
+                            );
+                        } catch {}
+                        try { streamController.abort?.(err); } catch {}
+                        throw err;
+                    }
                     if (classifier && attemptIndex < MAX_MIDSTREAM_RETRIES) {
                         firstAttemptError = err;
                         firstAttemptClassifier = classifier;

package/src/runtime/agent/orchestrator/providers/lib/anthropic-request-utils.mjs

@@ -268,10 +268,27 @@ export function applyAnthropicCacheMarkers(sanitizedMessages, {
         const tailIdx = sanitizedMessages.length - 1;
         return hasUserText(sanitizedMessages[tailIdx]) ? tailIdx : -1;
     };
+    // True-tip anchor: when the request ends with a PERSISTED user text turn
+    // (the current prompt — it re-appears verbatim in every later request's
+    // prefix), mark it first. Without this, mid-session turn-first requests
+    // (multi-turn only; single-turn sessions are already covered by
+    // firstRequestUserPromptIdx) leave the fresh prompt unmarked: its tokens
+    // bill once at $5/M uncached, then again as a cache write when a later
+    // anchor advances past them — cost bounded by the prompt's size, so it
+    // matters for large pasted prompts. (2026-08-03 A/B note: session totals'
+    // totalUncachedInputTokens = input + cacheWrite by design, see
+    // uncachedInputTokensForProvider; billing-uncached input measured via
+    // usage.json was already ~0 on single-turn bench tasks before and after
+    // this change.) Synthetic system-reminder tails are excluded by
+    // hasUserText, so per-call volatile content still never keys the cache.
+    const currentTailUserIdx = () => {
+        const tailIdx = sanitizedMessages.length - 1;
+        return hasUserText(sanitizedMessages[tailIdx]) ? tailIdx : -1;
+    };
     if (messageTtl !== null) {
         const slots = Math.max(0, Math.min(4, Number(messageSlots) || 0));
         const marked = new Set();
-        const candidates = [latestToolResultTailIdx(), previousUserTextAnchorIdx(), firstRequestUserPromptIdx()];
+        const candidates = [currentTailUserIdx(), latestToolResultTailIdx(), previousUserTextAnchorIdx(), firstRequestUserPromptIdx()];
         for (const idx of candidates) {
             if (slots <= 0) break;
             if (idx < 0 || marked.has(idx)) continue;

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

@@ -7,7 +7,10 @@
  * (scripts/openai-oauth-http-sse-toolcall-smoke.mjs) and fallback headers.
  */
 import { randomBytes } from 'crypto';
+import zlib from 'node:zlib';
 import {
+    extractCacheWriteTokens,
+    extractCachedTokens,
     traceAgentFetch,
     traceAgentSse,
     traceAgentUsage,
@@ -47,6 +50,21 @@ const CODEX_REQUEST_MAX_RETRIES = 4;
 const CODEX_REQUEST_BACKOFF_MS = Object.freeze([200, 400, 800, 1600]);
 const CODEX_RETRY_JITTER_RATIO = 0.1;
 
+// Request-body zstd gate (see sendViaHttpSse). Namespace import: on Node
+// runtimes without zlib zstd bindings the named export would fail at module
+// load, so the call site typeof-guards zlib.zstdCompressSync instead.
+const OPENAI_REQ_ZSTD_MIN_BYTES = 8 * 1024;
+let _openaiReqZstdLatch = false;
+function _openaiReqZstdDisabled() {
+    return _openaiReqZstdLatch || process.env.MIXDOG_OPENAI_REQ_ZSTD === '0';
+}
+function _disableOpenaiReqZstd() { _openaiReqZstdLatch = true; }
+function _zstdHeaders(headers, bodyForSend) {
+    return bodyForSend.encoding
+        ? { ...headers, 'Content-Encoding': bodyForSend.encoding }
+        : headers;
+}
+
 export function _envFlag(name, fallback = true) {
     const raw = process.env[name];
     if (raw == null || raw === '') return fallback;
@@ -72,11 +90,6 @@ function _parseJsonObject(value) {
     }
 }
 
-function _extractCachedTokens(usage) {
-    const details = usage?.input_tokens_details || usage?.prompt_tokens_details || {};
-    return Number(details.cached_tokens ?? details.cached ?? usage?.cached_tokens ?? 0) || 0;
-}
-
 function _sseEventsFromBuffer(buffer) {
     const frames = [];
     let rest = buffer.replace(/\r\n/g, '\n');
@@ -231,6 +244,19 @@ 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).
+    // 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.
+    const _rawReqBytes = Buffer.from(JSON.stringify(body));
+    let _reqBodyForSend = auth?.type !== 'openai-direct'
+        && !_openaiReqZstdDisabled()
+        && typeof zlib.zstdCompressSync === 'function'
+        && _rawReqBytes.length >= OPENAI_REQ_ZSTD_MIN_BYTES
+        ? { bytes: zlib.zstdCompressSync(_rawReqBytes), encoding: 'zstd' }
+        : { bytes: _rawReqBytes, encoding: null };
     let response;
     for (let attempt = 0; attempt <= CODEX_REQUEST_MAX_RETRIES; attempt++) {
         const headerTimeout = createTimeoutSignal(
@@ -253,8 +279,8 @@ export async function sendViaHttpSse({
             } catch {}
             response = await fetchFn(responsesUrl, {
                 method: 'POST',
-                headers,
-                body: JSON.stringify(body),
+                headers: _zstdHeaders(headers, _reqBodyForSend),
+                body: _reqBodyForSend.bytes,
                 signal: headerTimeout.signal,
                 dispatcher: getLlmDispatcher(),
             });
@@ -267,6 +293,15 @@ export async function sendViaHttpSse({
             headerTimeout.cleanup();
         }
 
+        // zstd rejection fallback: a 400 on a compressed request latches
+        // compression OFF process-wide and replays this attempt uncompressed.
+        if (response && response.status === 400 && _reqBodyForSend.encoding) {
+            _disableOpenaiReqZstd();
+            _reqBodyForSend = { bytes: _rawReqBytes, encoding: null };
+            await response.arrayBuffer().catch(() => {});
+            response = undefined;
+            continue;
+        }
         const retryableStatus = response && response.status >= 500 && response.status <= 599;
         // Typed transient transport failures only (errno / SDK connection
         // type). An unknown pre-response failure throws immediately instead of
@@ -783,7 +818,8 @@ export async function sendViaHttpSse({
                     usage = {
                         inputTokens: resp.usage.input_tokens || 0,
                         outputTokens: resp.usage.output_tokens || 0,
-                        cachedTokens: _extractCachedTokens(resp.usage),
+                        cachedTokens: extractCachedTokens(resp.usage),
+                        cacheWriteTokens: extractCacheWriteTokens(resp.usage),
                         promptTokens: resp.usage.input_tokens || 0,
                         raw: serviceTier ? { ...resp.usage, service_tier: serviceTier } : resp.usage,
                     };

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

@@ -36,9 +36,11 @@ import {
     classifyHandshakeError,
     classifyMidstreamError,
     createStreamSafetyStamps,
+    createStallRetryBudget,
     jitterDelayMs,
     MIDSTREAM_RETRY_POLICY,
     sleepWithAbort,
+    STREAM_STALL_RETRY_BUDGET_MS,
 } from './retry-classifier.mjs';
 import { stampStreamOutcome, STREAM_TRANSPORTS } from './lib/stream-outcome.mjs';
 import {
@@ -459,6 +461,9 @@ export async function sendViaWebSocket({
     const MAX_MIDSTREAM_RETRIES = MIDSTREAM_WS_TRANSIENT_RETRY_LIMIT;
     let firstAttemptError = null;
     let firstAttemptClassifier = null;
+    // Send-scoped stall window: in-place stall retries share one wall clock
+    // starting at the first stall (see createStallRetryBudget).
+    const stallRetryBudget = createStallRetryBudget();
     // A generate:false prewarm is billable even if its main request later
     // retries on a fresh socket or falls back to HTTP. Retain one completed
     // result across the whole logical send and attach it to terminal errors.
@@ -1006,6 +1011,11 @@ export async function sendViaWebSocket({
             const classifier = err?.unsafeToRetry === true
                 ? null
                 : _classifyMidstreamError(err, midState);
+            if (classifier === 'stream_stalled' && !stallRetryBudget.allowStallRetry()) {
+                try { process.stderr.write(`[openai-oauth] stall retry budget exhausted (${STREAM_STALL_RETRY_BUDGET_MS}ms since first stall) — surfacing for fresh-request retry\n`); } catch {}
+                emitSendSpan('error');
+                throw _stampTool(_stampLiveText(err));
+            }
             const retryLimit = classifier ? _midstreamRetryLimit(classifier) : 0;
             if (classifier && attemptIndex < retryLimit) {
                 // Retry-eligible: stash the first-attempt error, emit progress,

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

@@ -39,6 +39,9 @@ export function _combineUsageWithWarmup(actual, warmup, { separateMainContext =
         inputTokens: _usageNum(actual.inputTokens) + _usageNum(warmup.inputTokens),
         outputTokens: _usageNum(actual.outputTokens) + _usageNum(warmup.outputTokens),
         cachedTokens: _usageNum(actual.cachedTokens) + _usageNum(warmup.cachedTokens),
+        ...(actual.cacheWriteTokens != null || warmup.cacheWriteTokens != null
+            ? { cacheWriteTokens: _usageNum(actual.cacheWriteTokens) + _usageNum(warmup.cacheWriteTokens) }
+            : {}),
         promptTokens: _usageNum(actual.promptTokens) + _usageNum(warmup.promptTokens),
         warmupInputTokens: _usageNum(warmup.inputTokens),
         warmupCachedTokens: _usageNum(warmup.cachedTokens),