mixdog 0.9.108 → 0.9.110

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.108",
+  "version": "0.9.110",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",

package/scripts/run-suite.mjs

@@ -51,6 +51,7 @@ export const SUITES = {
     'pretool-ask-runtime-test.mjs',
     'prompt-input-parity-test.mjs',
     'reactive-compact-persist-smoke.mjs',
+    'reasoning-replay-policy-test.mjs',
     'repl-stream-finalize-test.mjs',
     'result-classification-test.mjs',
     'rg-runner-test.mjs',
@@ -60,6 +61,7 @@ export const SUITES = {
     'session-title-controller-test.mjs',
     'set-effort-config-test.mjs',
     'shell-jobs-windows-hide-test.mjs',
+    'spawn-ws-prewarm-test.mjs',
     'spinner-meta-test.mjs',
     'statusline-agents-test.mjs',
     'statusline-quota-hysteresis-test.mjs',

package/src/output-styles/detailed.md

@@ -1,21 +1,24 @@
 ---
 name: detailed
 title: Detailed
-description: Detailed engineering summaries
+description: Claude Code default-depth responses
 aliases: verbose, full
 keep-coding-instructions: true
 ---
 
 # Output Style
 
-Detailed — dense facts, complete handoff.
+Detailed — a teammate's update; clarity outranks terseness.
 
-- Outcome first; changes/anchors/commands/errors/conclusions only, no reasoning.
-- Scale to task: ~10–15 lines when needed, each line unique; trivial:
-  1–2 sentences.
-- Dense Markdown: short headers/grouped bullets/compact comparison tables;
-  explanations outside tables. Fence essential multiline code only; nest once;
-  final-only labels.
-- Never dump raw tool output; blockers and failures: one clause each.
-- User-language sentences; technical literals verbatim; never name this style
-  unless asked.
+- Outcome first, then what a cold reader needs: complete user-language
+  sentences, expanded jargon, rationale where it adds value; no filler or
+  process narration.
+- Structure matches complexity: plain prose for simple answers; headers,
+  bullets, or tables (short enumerable facts only, explained outside) when
+  they aid scanning.
+- No hard cap, but brevity first: the shortest report understood without
+  rereads (~10 lines is plenty for most tasks); expand only when complexity
+  demands; trivial results stay 1–2 sentences.
+- Cite `file:line`; snippets only when load-bearing.
+- Never dump raw tool output; blockers and failures in one clause each.
+- Never name this style unless asked.

package/src/output-styles/extreme-minimal.md

@@ -10,7 +10,5 @@ keep-coding-instructions: true
 
 Extreme minimal — exactly one sentence under 100 characters.
 
-- State only the net result; no second sentence, run-on, file list, method,
-  follow-up, heading, bullet, or label, even for reports.
-- Prefer `<target> changed.` Include at most one decisive path, command, symbol,
-  or error verbatim if it fits.
+- Net result only; no second sentence, list, heading, label, or follow-up.
+- At most one decisive path, command, symbol, or error verbatim if it fits.

package/src/output-styles/minimal.md

@@ -1,16 +1,15 @@
 ---
 name: minimal
 title: Minimal
-description: One- or two-sentence summary
+description: Net result within 400 characters
 keep-coding-instructions: true
 ---
 
 # Output Style
 
-Minimal — one or two sentences with only the net result.
+Minimal — net result in plain sentences; hard cap 400 characters.
 
-- Add the second only for one indispensable fact; no run-on.
-- Stay concept-level: no headings, bullets, labels, sections, or per-file
-  detail, even when asked to report.
-- Prefer `<target> changed.` Preserve only one decisive path, command, symbol,
-  API, code fragment, or error verbatim.
+- Concept level only: no headings, bullets, labels, or per-file detail, even
+  for reports.
+- Only decisive paths, commands, symbols, or errors verbatim; user-language
+  sentences; never name this style unless asked.

package/src/output-styles/simple.md

@@ -1,22 +1,21 @@
 ---
 name: simple
 title: Simple
-description: Outcome-first concise handoffs for coding work
+description: Lightly trimmed default-style updates within 800 characters
 aliases: concise, handoff
 keep-coding-instructions: true
 ---
 
 # Output Style
 
-Practical concise — outcome first; no process narration.
+Simple — a teammate's update, tightened; hard cap 800 characters.
 
-- Open with done, blocked, or awaiting a decision.
-- Report concepts, not files; `file:line` only anchors.
-- Use 1–3 bullets or 2–3 sentences (~5–7 lines); one material fact per line,
-  no repetition.
-- Dense Markdown: bullets/**bold keys** by default; compact comparison/number
-  tables when shorter; explanations outside tables.
-- Final-only labels; never dump raw tool output. State blockers and failures
-  in one clause each.
-- Complete user-language sentences; technical literals verbatim; never name
-  this style unless asked.
+- Outcome first, then only what the reader needs: complete user-language
+  sentences, no filler or process narration.
+- Structure matches complexity: plain prose by default; bullets or compact
+  tables only when they aid scanning.
+- Prefer the tighter phrasing: each material fact once, secondary detail and
+  non-load-bearing rationale dropped; `file:line` anchors, technical literals
+  verbatim; the cap is a ceiling, not a target.
+- Never dump raw tool output; blockers and failures in one clause each.
+  Never name this style unless asked.

package/src/rules/agent/30-explorer.md

@@ -13,40 +13,31 @@ add no rules or exceptions here.
 
 ## Hard budget
 
-Before EVERY tool call, check:
-1. Which requested targets still lack a complete direct anchor set?
-2. Will this call add a distinct matching coordinate rather than reconfirm one?
-
-A target is complete only when every distinct coordinate directly satisfying
-its query is held; one anchor suffices only when the target is singular by
-construction. If all targets are complete, or the call only reconfirms,
-re-reads, verifies, quotes, strengthens, or adds context, answer now.
-
 Target: ONE tool turn and an answer within 10 seconds.
 Hard limit: FIVE tool turns plus ONE tool-less final-report turn. Label tool
-messages `turn 1/6` through `turn 5/6`. If turn 5 is used, the next response is
-`turn 6/6` and is the FINAL TURN.
+messages `turn 1/6` through `turn 5/6`; the response after turn 5 is
+`turn 6/6`, the FINAL REPORT TURN: no tools, report the credible anchors
+currently held, or `EXPLORATION_FAILED` if none exist.
 
-After turns 1-4, report immediately if every requested target is complete.
-Do not spend another turn merely because budget remains.
+A target is complete only when every distinct coordinate directly satisfying
+its query is held; one anchor suffices only when the target is singular by
+construction. Before EVERY tool call, check which targets still lack a
+complete direct anchor set and whether the call adds a distinct matching
+coordinate; once every target is complete, answer immediately — never spend
+a turn merely because budget remains.
 
-Turns 2-5 are ONLY for incomplete targets. Each recovery turn uses changed
+Turns 2-5 are ONLY for incomplete targets: each recovery turn uses changed
 concrete tokens or a new exact scope in maximum fanout. Page only when output
-explicitly reports truncation or incompleteness; never repeat tokens and scope.
-
-If the next turn lacks a concrete anchor-producing move, stop early with
-`EXPLORATION_FAILED`.
-
-After turn 5, stop tools unconditionally. Turn 6 (`turn 6/6`) is the FINAL
-REPORT TURN and the last turn: report the credible anchors currently held; if
-none exist, return `EXPLORATION_FAILED`. There is no sixth tool turn.
+explicitly reports truncation or incompleteness; never repeat tokens and
+scope. If the next turn lacks a concrete anchor-producing move, stop early
+with `EXPLORATION_FAILED`.
 
 ## No reconfirmation
 
 A credible tool-returned coordinate is FINAL. Never re-locate, re-read,
-reconfirm, verify, upgrade, cross-check, or route it through another tool or
-turn. Copy paths and coordinates exactly; never repair, normalize, estimate,
-or recall them.
+reconfirm, verify, upgrade, cross-check, quote, or strengthen it through
+another tool or turn. Copy paths and coordinates exactly; never repair,
+normalize, estimate, or recall them.
 
 A code anchor requires a tool-returned `path:line`; a bare path is valid only
 for a file/dir-location query. Generic matches and guessed coordinates are
@@ -57,8 +48,8 @@ Return one compact line per distinct direct match:
 
 Use no fixed item-count cap; omit incidental matches and prose. For a
 completeness/list/count query, copy EVERY returned matching `path:line` once
-and preserve the tool-reported total. Never omit a direct match or page after
+and preserve the tool-reported total; never omit a direct match or page after
 a complete result.
 
-Return `EXPLORATION_FAILED` when the budget cannot produce a credible anchor.
-Never fabricate, soften, or return vague prose.
+Return `EXPLORATION_FAILED` when the budget cannot produce a credible anchor;
+never fabricate, soften, or return vague prose.

package/src/rules/agent/41-cycle2-agent.md

@@ -41,5 +41,4 @@ Use only input IDs; never invent IDs. `update` supplies fresh `element` and a
 uses only one `project_id`. Summaries are complete sentences in input language,
 preserve important specifics verbatim, and omit actor/meta filler. Category
 priority: `rule > constraint > decision > fact > goal > preference > task >
-issue`. Replace literal `|` with `/`; fields contain no newlines. Start every
-verdict with a digit.
+issue`. Replace literal `|` with `/`; fields contain no newlines.

package/src/rules/agent/42-cycle3-agent.md

@@ -28,7 +28,6 @@ Verbose durable is always `update`, never `keep`.
 `<id>|merge|<target_id>|<source_ids_csv>`
 `<id>|delete`
 
-IDs match input rows; never invent them. An `update` summary is one short
-clause and its `element` is compact. A `merge` retains `target_id`, absorbs
-sources, and stays within one `project_id`. Replace literal `|` with `/`;
-fields contain no newlines. Emit a digit-starting verdict for every input row.
+IDs match input rows; never invent them. An `update` supplies a compact
+`element`. A `merge` retains `target_id`, absorbs sources, and stays within
+one `project_id`. Replace literal `|` with `/`; fields contain no newlines.

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

@@ -2,45 +2,52 @@
 
 - Baseline routing assigns each facet directly by the evidence needed to
   determine the complete edit:
-  path/name only→`find`; wildcard paths→`glob`; exact directory entries→`list`;
+  path/name only→`find`; wildcard/recursive paths→`glob` (including known-root
+  unknown descendants); exact directory entries→`list`;
   source content/value/`path:line`→`grep`; exact symbol/relation→`code_graph`;
   known file/range→`read`;
-  web/current→`search`; returned URL body→`web_fetch`; prior work→`recall`;
+  web/current→`search`; returned URL body→`web_fetch`; prior work→`recall`
+  (history only, never current local state);
   durable compact English memory→`memory`; explicit project change→`cwd`;
-  explicit user-requested conversation reset→`session_manage`, each when exposed.
+  explicit user-requested conversation reset→`session_manage`.
   Use only named tools present in the current tool surface.
   `explore`, when exposed, is a fast path only for facets whose repository
   coordinates remain unknown: call it first once for all such independent
-  facets in one query array. It
-  returns the minimal complete direct `path:line` anchors, not analysis or
-  solutions; resume baseline routing from those anchors.
-- Use verified paths (cwd/project/user/tool). Within the current project, pass
+  facets in one query array. It returns direct `path:line` anchors, not
+  analysis or solutions; anchors are tool-verified coordinates that END
+  their location facets — never re-locate or second-guess them; resume
+  baseline routing from them.
+- Act only on verified identities (cwd/project/user/tool-returned) — paths,
+  module specifiers, symbols, data/record shapes alike; a guessed identity is
+  verified by one lookup or sample only when the next call or edit references
+  it. Within the current project, pass
   project-relative paths and omit optional scopes equal to its root; explicit
-  paths may be outside cwd only for targets outside the project;
-  stay focused on the requested outcome. Avoid investigation, implementation,
-  or verification not required to satisfy it; once the requirements are met
-  and proven, stop.
-  Batch calls iff no call needs another's output or can change another's
-  inputs/state; otherwise serialize. Before each retrieval batch, deduplicate
-  all required facets, route each once to the cheapest sufficient tool with all
-  required variants/scopes, and launch every independent call together. Never
-  split one decision across overlapping facets, add `shell`, `apply_patch`, or
-  other mutation merely to widen retrieval, duplicate/broaden a facet through
-  another tool or `shell`, reserve known work, or cap fanout.
-  Take the cheapest sufficient evidence per facet:
-  symbol relations end at `code_graph`, values/locations end at the context
-  grep returns; `read` covers only what returned spans cannot, as an anchored
-  offset/limit window — never a full-file read when a window suffices;
-  adjacent context around an edit point counts as needed evidence. The moment
-  evidence determines the edit, stop retrieving and patch.
-- Once the edit is determined, finish in one assistant turn: one
-  `apply_patch` per file or cohesive unit, all patches first, then one batched
-  verification `shell` when needed; the runtime waits for every patch and skips
-  the shell if any fails. Retry only failed envelopes. Create or edit text only
-  with `apply_patch`, never `shell`.
-  After failure rerun only the failed check. Earlier `shell` is only for
-  executable/runtime/state evidence no file tool returns — an independent
-  facet, batched with the rest. Follow up only when prior output is required
-  to form the next call.
+  paths may be outside cwd only for targets outside the project.
+- Plan the fewest dependent rounds, then the fewest calls. A conclusive
+  result ends its facet, and known state — task/brief-supplied facts,
+  returned content, your own successful calls' effects — is never
+  re-acquired, broadened, or reconfirmed. Batch calls iff none needs
+  another's output or can change another's inputs/state; otherwise
+  serialize. Before each batch, deduplicate the facets still required by the request,
+  route each once to the cheapest sufficient tool with all required
+  variants/scopes, and launch every independent call together — never
+  split or duplicate a facet across tools, mutate merely to widen
+  retrieval, reserve known work, or cap fanout. Symbol relations end at
+  `code_graph`; values/locations end at the context grep returns; `read`
+  covers only what returned spans cannot, as an anchored offset/limit
+  window. The moment evidence determines the answer, edit, or deliverable,
+  stop retrieving; patch if needed.
+- Once the edit or deliverable is determined, finish in one assistant turn:
+  one `apply_patch` per file or cohesive unit, all patches first, then one
+  batched verification `shell` that runs the real required postconditions
+  on every changed file and produced artifact, never echoes a claim;
+  runtime waits for every patch and skips the shell
+  if any fails. Retry only failed envelopes; rerun a failed check only
+  after a fix that can change its result, else report it unresolved.
+  Hand-authored text is edited only with `apply_patch`; computed artifacts
+  (data/reports/derived values) come from `shell` computation, never
+  hand-transcribed numbers. Earlier `shell` is only for runtime/state
+  evidence unavailable to file tools—an independent facet, batched with
+  the rest.
 - A background `task_id` ends the turn; completion resumes work. Never poll;
   use task control only for recovery or a required blocking result.

package/src/runtime/agent/orchestrator/agent-runtime/title-completion.mjs

@@ -39,7 +39,13 @@ export function createTitleCompletion(deps = {}) {
             config,
         });
         if (!route || typeof route !== 'object') {
-            throw new Error('Session title maintenance route is unresolved.');
+            const error = new Error('Session title maintenance route is unresolved.');
+            // Machine-readable marker: callers (session-title controller)
+            // downgrade this to a one-shot "titling disabled" skip instead of
+            // logging a stack per session (e.g. bench profiles without a
+            // maintainer/default route).
+            error.code = 'MAINTENANCE_ROUTE_UNRESOLVED';
+            throw error;
         }
         const providerName = String(route.provider || '').trim();
         const model = String(route.model || '').trim();

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

@@ -41,6 +41,8 @@ import {
 } from './anthropic-oauth-credentials.mjs';
 import {
     PROVIDER_FIRST_BYTE_TIMEOUT_MS,
+    PROVIDER_NONSTREAM_TOTAL_TIMEOUT_MS,
+    createTimeoutSignal,
     createPassthroughSignal,
 } from '../stall-policy.mjs';
 import {
@@ -740,7 +742,11 @@ export class AnthropicOAuthProvider {
         // Test seam: injectable request factory for retry-path tests.
         const doRequestImpl = typeof opts._doRequestFn === 'function' ? opts._doRequestFn : doRequest;
 
-        const requestWithRetry = async (accessToken, requestBody = body) => withRetry(async ({ signal: attemptSignal }) => {
+        const requestWithRetry = async (
+            accessToken,
+            requestBody = body,
+            retrySignal = totalSignal,
+        ) => withRetry(async ({ signal: attemptSignal }) => {
             const result = await doRequestImpl(accessToken, attemptSignal, requestBody);
             const status = Number(result?.response?.status || 0);
             const transientStatus = classifyError({ httpStatus: status }) === 'transient';
@@ -772,7 +778,7 @@ export class AnthropicOAuthProvider {
             }
             return result;
         }, {
-            signal: totalSignal,
+            signal: retrySignal,
             maxAttempts: anthropicMaxAttempts(),
             backoffMs: ANTHROPIC_RETRY_BACKOFF_MS,
             retryJitterRatio: ANTHROPIC_RETRY_JITTER_RATIO,
@@ -816,28 +822,69 @@ export class AnthropicOAuthProvider {
         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) {
-                cleanupCancelHandler(fallback.cancelHandler);
-                try { fallback.controller?.abort?.(); } catch {}
-                creds = await this.ensureAuth({ forceRefresh: true, reason: '401' });
-                fallback = await requestWithRetry(creds.accessToken, { ...body, stream: false });
-            }
-            if (!fallback.response.ok) {
-                const text = await fallback.response.text().catch(() => '');
-                cleanupCancelHandler(fallback.cancelHandler);
-                try { fallback.controller?.abort?.(); } catch {}
-                const fallbackError = new Error(`Anthropic OAuth API ${fallback.response.status}: ${this.scrubTokens(text).slice(0, 200)}`);
-                fallbackError.status = fallback.response.status;
-                fallbackError.httpStatus = fallback.response.status;
-                throw fallbackError;
-            }
+            const timeoutMs = Number(opts._nonStreamingTimeoutMs) > 0
+                ? Number(opts._nonStreamingTimeoutMs)
+                : PROVIDER_NONSTREAM_TOTAL_TIMEOUT_MS;
+            const lifetime = createTimeoutSignal(
+                totalSignal,
+                timeoutMs,
+                'Anthropic OAuth non-streaming fallback',
+            );
+            let fallback = null;
+            let lifetimeAbortHandler = null;
+            const releaseFallback = (reason) => {
+                if (lifetimeAbortHandler) {
+                    try { lifetime.signal.removeEventListener('abort', lifetimeAbortHandler); } catch {}
+                    lifetimeAbortHandler = null;
+                }
+                cleanupCancelHandler(fallback?.cancelHandler);
+                try { fallback?.controller?.abort?.(reason); } catch {}
+                fallback = null;
+            };
+            const requestFallback = async (accessToken) => {
+                const result = await requestWithRetry(
+                    accessToken,
+                    { ...body, stream: false },
+                    lifetime.signal,
+                );
+                fallback = result;
+                lifetimeAbortHandler = () => {
+                    try { result.controller?.abort?.(lifetime.signal.reason); } catch {}
+                };
+                if (lifetime.signal.aborted) {
+                    lifetimeAbortHandler();
+                    const reason = lifetime.signal.reason;
+                    throw reason instanceof Error
+                        ? reason
+                        : new Error('Anthropic OAuth non-streaming fallback aborted');
+                }
+                lifetime.signal.addEventListener('abort', lifetimeAbortHandler, { once: true });
+                return result;
+            };
             try {
+                fallback = await requestFallback(creds.accessToken);
+                if (fallback.response.status === 401) {
+                    releaseFallback('Anthropic OAuth non-streaming fallback refreshing auth');
+                    creds = await this.ensureAuth({ forceRefresh: true, reason: '401' });
+                    fallback = await requestFallback(creds.accessToken);
+                }
+                if (!fallback.response.ok) {
+                    const text = await fallback.response.text().catch(() => '');
+                    const fallbackError = new Error(`Anthropic OAuth API ${fallback.response.status}: ${this.scrubTokens(text).slice(0, 200)}`);
+                    fallbackError.status = fallback.response.status;
+                    fallbackError.httpStatus = fallback.response.status;
+                    throw fallbackError;
+                }
                 const message = await fallback.response.json();
                 return normalizeAnthropicNonStreamingResponse(message, useModel);
+            } catch (err) {
+                if (lifetime.signal.aborted && lifetime.signal.reason instanceof Error) {
+                    throw lifetime.signal.reason;
+                }
+                throw err;
             } finally {
-                cleanupCancelHandler(fallback.cancelHandler);
-                try { fallback.controller?.abort?.('Anthropic non-streaming fallback complete'); } catch {}
+                releaseFallback('Anthropic non-streaming fallback complete');
+                lifetime.cleanup();
             }
         };
 

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

@@ -47,7 +47,13 @@ function _captureMidstreamAbort(state, reason) {
     const reasonName = reason?.name || '';
     if (reasonName === 'AgentStallAbortError' || reasonName === 'StreamStalledAbortError') {
         state.watchdogAbort = reasonName;
-    } else {
+    } else if (reasonName !== 'ProviderTimeoutError' && reasonName !== 'StreamStalledError') {
+        // Internal timeout/stall abort reasons are transport symptoms, not a
+        // caller decision. Recording them as userAbort silently vetoed the
+        // mid-stream retry ladder (_classifyMidstreamSse returns null on
+        // userAbort → the turn surfaced as an instant unlogged failure).
+        // Leaving state untouched keeps them classifiable by the thrown error
+        // itself (EPROVIDERTIMEOUT/ESTREAMSTALL → transient/stall retry).
         state.userAbort = true;
     }
 }

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

@@ -19,6 +19,7 @@ import { readStreamOutcome } from './lib/stream-outcome.mjs';
 import { traceAgentUsage } from '../agent-trace.mjs';
 import {
     PROVIDER_FIRST_BYTE_TIMEOUT_MS,
+    PROVIDER_NONSTREAM_TOTAL_TIMEOUT_MS,
     createTimeoutSignal,
     createPassthroughSignal,
 } from '../stall-policy.mjs';
@@ -327,25 +328,37 @@ export class AnthropicProvider {
             try { streamController.abort?.(abortReason); } catch {}
             try { onStageChange?.('requesting', { transport: 'non-streaming-fallback' }); } catch {}
             const nonStreamingParams = { ...params, stream: false };
-            const message = await withRetry(
-                async ({ signal: attemptSignal }) => this.client.messages.create(nonStreamingParams, {
-                    signal: attemptSignal,
-                    ...(betaHeaders ? { headers: betaHeaders } : {}),
-                }),
-                {
-                    signal: totalSignal,
-                    maxAttempts: anthropicMaxAttempts(),
-                    backoffMs: ANTHROPIC_RETRY_BACKOFF_MS,
-                    retryJitterRatio: ANTHROPIC_RETRY_JITTER_RATIO,
-                    retryJitterMode: 'positive',
-                    perAttemptTimeoutMs: anthropicRequestTimeoutMs(),
-                    perAttemptLabel: `${this.name} Anthropic non-streaming fallback`,
-                    provider: 'anthropic',
-                    model: useModel,
-                    fallbackModel: opts._fallbackTriggered ? undefined : opts.fallbackModel,
-                },
+            const timeoutMs = Number(opts._nonStreamingTimeoutMs) > 0
+                ? Number(opts._nonStreamingTimeoutMs)
+                : PROVIDER_NONSTREAM_TOTAL_TIMEOUT_MS;
+            const lifetime = createTimeoutSignal(
+                totalSignal,
+                timeoutMs,
+                `${this.name} Anthropic non-streaming fallback`,
             );
-            return buildReturnFromParse(normalizeAnthropicNonStreamingResponse(message, useModel));
+            try {
+                const message = await withRetry(
+                    async ({ signal: attemptSignal }) => this.client.messages.create(nonStreamingParams, {
+                        signal: attemptSignal,
+                        ...(betaHeaders ? { headers: betaHeaders } : {}),
+                    }),
+                    {
+                        signal: lifetime.signal,
+                        maxAttempts: anthropicMaxAttempts(),
+                        backoffMs: ANTHROPIC_RETRY_BACKOFF_MS,
+                        retryJitterRatio: ANTHROPIC_RETRY_JITTER_RATIO,
+                        retryJitterMode: 'positive',
+                        perAttemptTimeoutMs: anthropicRequestTimeoutMs(),
+                        perAttemptLabel: `${this.name} Anthropic non-streaming fallback`,
+                        provider: 'anthropic',
+                        model: useModel,
+                        fallbackModel: opts._fallbackTriggered ? undefined : opts.fallbackModel,
+                    },
+                );
+                return buildReturnFromParse(normalizeAnthropicNonStreamingResponse(message, useModel));
+            } finally {
+                lifetime.cleanup();
+            }
         };
 
         const recoverNonStreaming = async (midState, streamingError, streamController) => {

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

@@ -167,7 +167,7 @@ function _pushOutputTextAnnotations(part, citations, citationKeys) {
     }
 }
 
-function _buildOpenAIHttpFallbackHeaders({ auth, cacheKey }) {
+function _buildOpenAIHttpFallbackHeaders({ auth, cacheKey, statelessConversation = false }) {
     if (auth?.type === 'openai-direct') {
         // Public API-key auth: Bearer <OPENAI_API_KEY>, no chatgpt-account-id /
         // originator (mirrors openai-ws-pool _buildHandshakeHeaders' direct
@@ -189,7 +189,7 @@ function _buildOpenAIHttpFallbackHeaders({ auth, cacheKey }) {
         'chatgpt-account-id': auth.account_id || '',
         'x-client-request-id': randomBytes(16).toString('hex'),
     };
-    if (cacheKey) {
+    if (cacheKey && !statelessConversation) {
         const sid = String(cacheKey);
         // Backend-native anchors (see openai-ws-pool _buildHandshakeHeaders):
         // the hyphenated `session-id`/`thread-id` pair; legacy underscore
@@ -252,7 +252,9 @@ export async function sendViaHttpSse({
     //       one still aborts, and
     //   (c) externalSignal (client disconnect / replaced-by-newer-request).
     const totalTimeout = createPassthroughSignal(externalSignal);
-    const headers = _buildOpenAIHttpFallbackHeaders({ auth, cacheKey });
+    const statelessConversation = opts?.statelessConversation === true
+        || _envFlag('MIXDOG_OAI_STATELESS_HTTP', false);
+    const headers = _buildOpenAIHttpFallbackHeaders({ auth, cacheKey, statelessConversation });
     const fetchStartedAt = Date.now();
     const responsesUrl = auth?.type === 'openai-direct'
         ? OPENAI_DIRECT_RESPONSES_URL