mixdog 0.9.110 → 0.9.111

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.110",
+  "version": "0.9.111",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -125,7 +125,6 @@
     "bench:run": "node scripts/bench-run.mjs",
     "bench:recall": "node scripts/recall-bench.mjs",
     "bench:tui-load": "node scripts/tui-runtime-load-bench.mjs",
-    "bench:explore": "node scripts/explore-bench.mjs",
     "bench:output-style": "node scripts/output-style-bench.mjs",
     "bench:session-context": "node scripts/session-context-bench.mjs",
     "bench:session-transport": "node scripts/session-transport-bench.mjs",

package/scripts/routing-corpus.mjs

@@ -68,7 +68,6 @@ function argsSummary(tool, args) {
       const values = args.symbols || args.files || args.symbol || args.file || '';
       return clip(`${args.mode || '?'}:${Array.isArray(values) ? `[${values.length}]${values[0] || ''}` : values}`);
     }
-    case 'explore': return arr(args.query);
     case 'find': return clip(args.query);
     case 'glob': return clip(Array.isArray(args.pattern) ? args.pattern[0] : args.pattern);
     case 'list': return clip(basename(String(args.path || '')));
@@ -95,7 +94,7 @@ function targetValues(tool, args) {
       ? (args.files != null ? 'files' : 'file')
       : symbolMode || args.mode === 'symbols' ? (args.symbols != null ? 'symbols' : 'symbol') : 'file';
   } else if (tool === 'grep' || tool === 'glob') key = 'pattern';
-  else if (tool === 'find' || tool === 'explore') key = 'query';
+  else if (tool === 'find') key = 'query';
   const value = args[key];
   return Array.isArray(value) ? value : value == null ? [] : [value];
 }
@@ -110,7 +109,7 @@ function batchFields(tool, args) {
       ? (args?.files != null ? 'files' : args?.file != null ? 'file' : args?.symbols != null ? 'symbols' : 'symbol')
       : null].filter(Boolean);
   }
-  return [tool === 'read' || tool === 'list' ? 'path' : tool === 'find' || tool === 'explore' ? 'query' : null].filter(Boolean);
+  return [tool === 'read' || tool === 'list' ? 'path' : tool === 'find' ? 'query' : null].filter(Boolean);
 }
 function compatibleBatchCalls(tool, left, right) {
   if (tool === 'read') {
@@ -149,7 +148,7 @@ function batchSpec(tool, args, forcedField = null) {
       : (args.symbols != null ? 'symbols' : 'symbol');
     return { field, values: targetValues(tool, args) };
   }
-  const fieldName = forcedField || (tool === 'read' || tool === 'list' ? 'path' : tool === 'grep' || tool === 'glob' ? 'pattern' : tool === 'find' || tool === 'explore' ? 'query' : null);
+  const fieldName = forcedField || (tool === 'read' || tool === 'list' ? 'path' : tool === 'grep' || tool === 'glob' ? 'pattern' : tool === 'find' ? 'query' : null);
   if (!fieldName) return null;
   const value = args[fieldName];
   return { field: fieldName, values: Array.isArray(value) ? value : value == null ? [] : [value] };
@@ -166,7 +165,7 @@ function sameIterationBatchObservations(sequence) {
       if (isMutation(next.tool)) break;
       group.push(next);
     }
-    for (const candidate of ['read', 'grep', 'find', 'glob', 'list', 'explore', 'code_graph']) {
+    for (const candidate of ['read', 'grep', 'find', 'glob', 'list', 'code_graph']) {
       if (candidate === 'read') {
         const calls = group.filter((entry) => entry.tool === 'read' && !entry.failed).map((entry) => ({ entry, targets: readTargets(entry.rawArgs) })).filter(({ targets }) => targets?.length);
         if (calls.some(({ entry, targets }, index) => calls.some(({ entry: other, targets: otherTargets }, otherIndex) => (
@@ -238,7 +237,7 @@ function buildCase(sid, toolRows) {
   const observations = [];
   if (sequence.some((s) => s.tool === 'code_graph' && s.rawArgs?.mode === 'find_symbol' && !s.rawArgs?.file && !s.rawArgs?.files)) flags.push('find_symbol_noscope');
   // Exact duplicate requests are the only relookup signal available in tool
-  // traces. Do not infer waste from counts, roles, turns, or explore→inspection:
+  // traces. Do not infer waste from counts, roles, turns, or locator→inspection:
   // exploration followed by inspection can be the intended route.
   const seenRequests = new Set();
   const readWindows = [];

package/scripts/run-suite.mjs

@@ -25,7 +25,6 @@ export const SUITES = {
     'dead-owner-attach-test.mjs',
     'debounced-skills-async-save-test.mjs',
     'dispatch-persist-recovery-test.mjs',
-    'explore-prompt-policy-test.mjs',
     'find-fuzzy-hidden-test.mjs',
     'ingest-pure-conversation-smoke.mjs',
     'internal-tools-normalization-test.mjs',

package/src/app.mjs

@@ -87,7 +87,6 @@ export async function run(argv = [], classifiedInvocation = null) {
       model: opts.model,
       effort: opts.effort,
       fast: opts.fast,
-      explore: opts.explore,
       webSearch: opts.webSearch,
       memory: opts.memory,
       cwd: process.cwd(),

package/src/defaults/agents.json

@@ -1,17 +1,5 @@
 {
   "agents": [
-    {
-      "agent": "explorer",
-      "slot": "explore",
-      "systemFile": "rules/agent/30-explorer.md",
-      "description": "Filesystem navigation agent invoked by the `explore` MCP tool",
-      "invokedBy": "explore",
-      "toolSchemaProfile": "read",
-      "schemaAllowedTools": ["grep", "find", "glob", "code_graph"],
-      "kind": "retrieval",
-      "permission": "read",
-      "stallCap": { "idleSeconds": 240, "toolRunningSeconds": 180 }
-    },
     {
       "agent": "cycle1-agent",
       "slot": "cycle1",

package/src/defaults/skills/setup/SKILL.md

@@ -73,7 +73,7 @@ apply it, and verify the result.
 ### Workflow / agent definitions
 
 1. Workflows and agents are Markdown packs. Built-in services are Web Search,
-   Explore, and Maintainer. Mixdog ships editable starter agents `worker`,
+   and Maintainer. Mixdog ships editable starter agents `worker`,
    `heavy-worker`, and `reviewer`; custom packs live at
    `<mixdogData>/workflows/<id>/WORKFLOW.md` and
    `<mixdogData>/agents/<id>/AGENT.md`.

package/src/headless-command.mjs

@@ -1,10 +1,9 @@
 const VALUE_OPTIONS = new Set(['--provider', '--model', '--effort', '--workflow']);
 const FLAG_OPTIONS = new Set([
   '--readonly', '--help', '-h', '--plain', '--react', '--remote', '--onboarding', '--fast',
-  '--explore', '--web-search', '--memory',
+  '--web-search', '--memory',
 ]);
 const HEADLESS_ROLE_ALIASES = new Map([
-  ['explorer', 'explore'], ['explore', 'explore'],
   ['maint', 'maintainer'], ['maintenance', 'maintainer'], ['maintainer', 'maintainer'],
   ['worker', 'worker'],
   ['heavy', 'heavy-worker'], ['heavyworker', 'heavy-worker'], ['heavy-worker', 'heavy-worker'],
@@ -108,7 +107,6 @@ export function classifyCliInvocation(argv = []) {
     model: parsed.values['--model'],
     effort: parsed.values['--effort'],
     fast: argv.includes('--fast'),
-    explore: argv.includes('--explore'),
     webSearch: argv.includes('--web-search'),
     memory: argv.includes('--memory'),
     toolMode: argv.includes('--readonly') ? 'readonly' : 'full',

package/src/headless-role.mjs

@@ -83,7 +83,6 @@ export async function runHeadlessRole({
   model,
   effort,
   fast,
-  explore = false,
   webSearch = false,
   memory = false,
   cwd = process.cwd(),
@@ -93,11 +92,10 @@ export async function runHeadlessRole({
 } = {}) {
   const cleanAgent = clean(agent);
   const cleanMessage = clean(message);
-  // Classic headless surface: explorer, web search, and memory tools start OFF
-  // and opt back in per run (--explore / --web-search / --memory). An explicit
+  // Classic headless surface: web search and memory tools start OFF
+  // and opt back in per run (--web-search / --memory). An explicit
   // MIXDOG_FEATURE_* value from the caller environment always wins.
   for (const [key, enabled] of [
-    ['MIXDOG_FEATURE_EXPLORE', explore],
     ['MIXDOG_FEATURE_WEB_SEARCH', webSearch],
     ['MIXDOG_FEATURE_MEMORY', memory],
   ]) {

package/src/help.mjs

@@ -21,7 +21,7 @@ export const HELP_LINES = [
   '',
   'Headless role commands require an explicit provider/model pair and run with',
   'ephemeral config/data; host behavioral config and personal state are not loaded.',
-  'Roles: explore, worker, heavy-worker, reviewer, maintainer, web-researcher.',
+  'Roles: worker, heavy-worker, reviewer, maintainer, web-researcher.',
   '',
   'Slash commands (inside mixdog):',
   '  /clear                        start a fresh chat (alias: /new)',

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

@@ -11,12 +11,6 @@
   durable compact English memory→`memory`; explicit project change→`cwd`;
   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 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
@@ -38,7 +32,8 @@
   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
+  issue `apply_patch` calls serially, never in parallel; use one cohesive call
+  with one file section per target, 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

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

@@ -47,7 +47,7 @@ import { resourceAdmission } from '../../../shared/resource-admission.mjs';
 export { resolveMaintenanceRoute } from './maintenance-route.mjs';
 
 // Cap agent role synthesis to ~3000 tokens (~12 KB at the 4 B/tok
-// working average). Pool B explore/recall/search answers occasionally land
+// working average). Pool B recall/search answers occasionally land
 // 8-10k-token walls that then ride in the Lead context for the rest of the
 // turn; the cap keeps those outliers bounded without touching the 95%+ of
 // answers already under the threshold.
@@ -68,7 +68,7 @@ function formatCompactElapsedSeconds(ms) {
 
 // True when an abort explicitly opted into partial salvage — the error object
 // or the abort reason carries `salvagePartial: true`. A DEADLINE-driven caller
-// (explore hard timeout) sets it so the anchors the sub-agent already produced
+// A hard timeout sets it so partial output the sub-agent already produced
 // are returned instead of discarded; user cancellation (ESC) never sets it and
 // keeps the throw-everything behaviour.
 function salvagePartialRequested(error, signal) {
@@ -151,7 +151,7 @@ export function resolveHiddenRoleSchemaAllowedTools(hidden) {
  *     against config.presets.
  *   - null — unresolved.
  *
- * Explore and memory hidden roles mirror public spawning precedence:
+ * Hidden maintenance roles mirror public spawning precedence:
  * `agents.<role>` (including the `agents.maintenance` alias) → workflow route →
  * maintenance route → Main. The cycle1/2/3 agents share the memory knob via
  * their `maintKey: 'memory'` override. Scheduler and webhook are unchanged.
@@ -293,7 +293,7 @@ export function makeAgentDispatch(opts = {}) {
             agentId: agent,
         });
 
-        // Callers (e.g. aiWrapped explore dispatch) may pass an explicit
+        // Callers may pass an explicit
         // `cwd` to scope the agent's filesystem view. Absolute path expected
         // (aiWrapped already expands `~` and resolves relatives). When unset
         // we pass `null` through instead of falling back to `process.cwd()`
@@ -418,7 +418,7 @@ export function makeAgentDispatch(opts = {}) {
         const _idleController = (agentWatchdogPolicyActive(_watchdogPolicy) && _linkSignal)
             ? new AbortController()
             : null;
-        // Do not link factory parent, per-call explore cancellation, and the
+        // Do not link factory parent, per-call cancellation, and the
         // watchdog one at a time: each link replaces the previous listener in
         // runtime-liveness.  One composite survives askSession's controller
         // swap and makes every source reach the provider call.
@@ -497,7 +497,7 @@ export function makeAgentDispatch(opts = {}) {
             });
             process.stderr.write(`[agent-dispatch] agent=${agent} session=${session.id} elapsed=${Date.now() - _agentDispatchT0}ms\n`);
             const raw = result?.content || '';
-            // Brief cap. Agent role answers (explore/recall/search)
+            // Brief cap. Agent role answers (recall/search)
             // occasionally balloon to 8-10k token walls that then ride in the
             // parent Lead's context for the rest of the turn. A 3000-token
             // (~12 KB) ceiling trims the long tail while leaving the vast

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

@@ -1,7 +1,5 @@
 /**
- * Agent loop ceilings. Lead and general delegated agents share one high
- * runaway guard. Explorer is the sole bounded exception: locator work gets at
- * at most five tool-capable turns, followed by the loop's tool-less report turn.
+ * Agent loop ceilings. Lead and delegated agents share one high runaway guard.
  */
 
 function envPositiveInt(name, fallback) {
@@ -15,29 +13,8 @@ function envPositiveInt(name, fallback) {
 // to raise/lower the safety ceiling, never used as a general task-length budget.
 export const LEAD_MAX_LOOP_ITERATIONS = envPositiveInt('MIXDOG_AGENT_MAX_LOOP', 200);
 
-// Explorer's first turn is the whole maximum-fanout search; turns 2-5 are
-// bounded miss recovery. The override may shorten this but never add a sixth.
-export const EXPLORE_MAX_LOOP_ITERATIONS = Math.min(
-    5,
-    envPositiveInt('MIXDOG_EXPLORE_MAX_LOOP', 5),
-);
-
-/**
- * Resolve the hard cap used by agentLoop for this session.
- *
- * Explorer: the lowest positive explicit/session value, clamped to its
- * dedicated five-turn ceiling. Others: explicit → session-pinned → shared guard.
- */
+/** Resolve the hard cap used by agentLoop for this session. */
 export function resolveSessionMaxLoopIterations(sessionRef, explicit) {
-    const sessionAgent = String(sessionRef?.agent || '').trim().toLowerCase();
-    if (sessionAgent === 'explorer' || sessionAgent === 'explore') {
-        const requested = Number.isFinite(explicit) && explicit > 0
-            ? Math.floor(explicit)
-            : Number.isFinite(sessionRef?.maxLoopIterations) && sessionRef.maxLoopIterations > 0
-                ? Math.floor(sessionRef.maxLoopIterations)
-                : EXPLORE_MAX_LOOP_ITERATIONS;
-        return Math.min(EXPLORE_MAX_LOOP_ITERATIONS, requested);
-    }
     if (Number.isFinite(explicit) && explicit > 0) return Math.floor(explicit);
     if (Number.isFinite(sessionRef?.maxLoopIterations) && sessionRef.maxLoopIterations > 0) {
         return Math.floor(sessionRef.maxLoopIterations);

package/src/runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs

@@ -17,7 +17,7 @@ import {
 // Ordering guarantee, stated in stall-policy.mjs: the provider layer — which
 // can retry in place or fall back to non-streaming — must fire STRICTLY before
 // the agent watchdog's terminal abort. Role abort budgets (worker/reviewer
-// 300s, explore 240s) sat at or BELOW the provider semantic-idle window
+// 300s) sat at or BELOW the provider semantic-idle window
 // (300s), inverting that order: the watchdog aborted the shared signal first,
 // so the provider's recovery never ran and the `agent_stall` failure — which
 // the classifier calls retryable — died on throwIfAborted instead. Hold the
@@ -140,7 +140,7 @@ export function watchdogPartialHandoffFromError(error, session, messageStartInde
 }
 
 // Salvage path for NON-watchdog aborts that explicitly opt in (the abort error
-// / abort reason carries `salvagePartial: true` — e.g. the explore wall-clock
+// / abort reason carries `salvagePartial: true` — e.g. a bounded wall-clock
 // hard timeout). Same collection rule as the watchdog handoff: only assistant
 // text appended during this run. Plain user cancellation never opts in, so ESC
 // still discards the run.
@@ -266,7 +266,7 @@ export function resolveAgentWatchdogPolicy(agent, overrides = {}) {
             ? Math.min(DEFAULT_STALE_TIMEOUT_MS, backstopMs)
             : DEFAULT_STALE_TIMEOUT_MS;
         // Same floor for the public backstop: a workflow role (worker 300s,
-        // explore 240s) must not undercut the provider window either.
+        // role-specific caps must not undercut the provider window either.
         idleStaleMs = Math.max(idleStaleMs, PROVIDER_RECOVERY_FLOOR_MS);
     }
 

package/src/runtime/agent/orchestrator/agent-runtime/maintenance-route.mjs

@@ -29,7 +29,7 @@ export function resolveMaintenanceRoute({ preset, optsPreset, agent, config: cfg
         try {
             const config = cfgIn || loadConfig({ secrets: false });
             const key = hidden.maintKey || hidden.slot;
-            const role = key === 'explore' ? 'explore' : (key === 'memory' ? 'maintainer' : '');
+            const role = key === 'memory' ? 'maintainer' : '';
             if (!role) return config?.maintenance?.[key] ?? null;
             const candidates = [
                 ...configuredAgentRouteCandidates(config, role),

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

@@ -49,7 +49,7 @@ function normalizeAgentCompactionConfig(value = {}, { memoryEnabled = true } = {
 
 /**
  * @param {object} opts
- * @param {string}  opts.agent         — canonical agent name ('worker', 'explorer', ...)
+ * @param {string}  opts.agent         — canonical agent name ('worker', 'reviewer', ...)
  * @param {string}  opts.presetName    — resolved preset identifier
  * @param {object}  opts.preset        — resolved preset object from agent-config
  * @param {object}  opts.runtimeSpec   — resolveRuntimeSpec output; must carry .scopeKey / .lane

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

@@ -137,7 +137,6 @@ const TOOL_ARG_KEYS = {
     list: ['path', 'head_limit', 'offset'],
     recall: ['query', 'limit', 'session_id', 'cwd'],
     search: ['query', 'limit', 'cwd'],
-    explore: ['query', 'queries', 'limit', 'cwd'],
     code_graph: ['mode', 'file', 'files', 'symbol', 'symbols', 'body', 'language', 'limit', 'depth', 'page', 'cwd'],
     shell: ['command', 'cwd', 'timeout', 'mode', 'run_in_background', 'persistent', 'session_id'],
     task: ['task_id', 'action', 'timeout_ms', 'poll_ms'],

package/src/runtime/agent/orchestrator/config.mjs

@@ -22,13 +22,12 @@ export function getPluginData() {
 // Canonical maintenance defaults. Single source of truth — imported by
 // llm/index.mjs and setup-server.mjs so UI/runtime cannot drift from config.
 //
-// Explore and Maintainer start without a route so they dynamically inherit the
-// Main route. Their explicit routes live canonically in `agents.explore` and
-// `agents.maintainer`; load-time migration still accepts the older workflow /
-// maintenance aliases.
+// Maintainer starts without a route so it dynamically inherits the Main route.
+// Its explicit route lives canonically in `agents.maintainer`; load-time
+// migration still accepts the older workflow / maintenance aliases.
 // Webhook endpoints may omit a model and use the fallback route below.
 // Legacy route slots accepted only at config ingress for migration.
-const MAINTENANCE_SLOTS = Object.freeze(['explore', 'memory']);
+const MAINTENANCE_SLOTS = Object.freeze(['memory']);
 
 // --- User profile (statusline /profile) -------------------------------------
 // Supported response languages for the /profile picker. `system` is the default
@@ -340,7 +339,8 @@ function canonicalizeShellStorage(value) {
 function canonicalizeModulesStorage(value) {
     const modules = configObject(value);
     delete modules.memory;
-    for (const name of ['search', 'explore']) {
+    delete modules.explore;
+    for (const name of ['search']) {
         if (!Object.prototype.hasOwnProperty.call(modules, name)) continue;
         const raw = modules[name];
         modules[name] = {

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

@@ -711,8 +711,7 @@ export function loadScopedRoleInstructions(agent, provider = null) {
             agentRuleSectionsToEmit = hiddenPairs.map(p => `## ${p.name}\n\n${p.body}`);
             agentSectionsToEmit = agentSections;
         } else if (agent && classification.retrieval.has(agent)) {
-            // Retrieval agents (explorer) get their own contract section
-            // (rules/agent/30-explorer.md) in BP2.
+            // Retrieval agents get their own contract section in BP2.
             const self = hiddenPairs.find(p => p.name === agent);
             agentRuleSectionsToEmit = self ? [`## ${self.name}\n\n${self.body}`] : [];
             agentSectionsToEmit = agentSections.filter(s =>

package/src/runtime/agent/orchestrator/dispatch-persist.mjs

@@ -8,7 +8,7 @@
  *
  * This module persists the minimum needed to recover:
  *   - handle   (`dispatch_<tool>_...`)
- *   - tool     (`recall` / `search` / `explore`)
+ *   - tool     (`recall` / `search`)
  *   - queries  (for the abort message)
  *   - createdAt
  *

package/src/runtime/agent/orchestrator/internal-agents.mjs

@@ -2,7 +2,7 @@
  * Internal hidden agents — Mixdog-managed, user-untouchable.
  *
  * Unlike public workflow agents, these hidden agents are NEVER exposed to callers of the `agent` tool. They are
- * invoked only by internal handlers (explore / recall / search) and carry
+ * invoked only by internal handlers (recall / search) and carry
  * their own system prompt + tool-set policy.
  *
  * Lookup order (agent-dispatch.resolveMaintenanceRoute):
@@ -20,7 +20,7 @@
  * found" error rather than silently mis-dispatching.
  *
  * Kind classification:
- *   - 'retrieval'   : short-lived hidden retrieval agents (explore).
+ *   - 'retrieval'   : short-lived hidden retrieval agents.
  *   - 'maintenance' : background-trigger hidden agents (memory cycle and
  *                     title generation). Receive only their own self section.
  *
@@ -184,7 +184,7 @@ export function listHiddenAgentsByKind(kind) {
 
 /**
  * Return the agents/<name>.md sections a hidden agent shares in its BP2 catalog
- * (in addition to its own self section). Drives the explorer→worker cache
+ * (in addition to its own self section). Drives hidden-role cache
  * alignment declaratively instead of a hard-coded agent-name branch in
  * collect.mjs. Returns [] when the agent declares none.
  */

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

@@ -105,6 +105,16 @@ const WS_MIDSTREAM_POLICY = {
 const HANDSHAKE_MAX_ATTEMPTS = MIDSTREAM_WS_TRANSIENT_RETRY_LIMIT + 1;
 const HANDSHAKE_BACKOFF_BASE_MS = 200;
 const HANDSHAKE_BACKOFF_CAP_MS = 3200;
+// These statuses are decisions made by the CURRENT attempt. They must never
+// be replaced by a stale transient from an earlier retry: auth recovery,
+// transport fallback, and Retry-After handling all depend on the live error.
+const CURRENT_ATTEMPT_DECISION_STATUSES = new Set([401, 403, 426, 429]);
+
+function _mustSurfaceCurrentAttempt(err, externalSignal) {
+    return CURRENT_ATTEMPT_DECISION_STATUSES.has(Number(err?.httpStatus || 0))
+        || externalSignal?.aborted
+        || err?.unsafeToRetry === true;
+}
 
 function _classifyHandshakeError(err, { retry429 = true } = {}) {
     return classifyHandshakeError(err, { retry429 });
@@ -738,12 +748,12 @@ export async function sendViaWebSocket({
             // A later auth/upgrade decision must win over an earlier transient
             // failure so the caller can refresh or switch transport. Likewise,
             // never replace a current cancellation with stale retry history.
-            const currentStatus = Number(err?.httpStatus || 0);
-            const surfaceCurrent = currentStatus === 401
-                || currentStatus === 426
-                || externalSignal?.aborted
-                || err?.unsafeToRetry === true;
-            if (surfaceCurrent) {
+            if (_mustSurfaceCurrentAttempt(err, externalSignal)) {
+                if (retryable && attemptIndex >= MAX_MIDSTREAM_RETRIES) {
+                    try { err.midstreamRetries = attemptIndex; } catch {}
+                    try { err.midstreamClassifier = classifier; } catch {}
+                    try { err.wsRetriesExhausted = true; } catch {}
+                }
                 emitSendSpan('error');
                 throw _stampTool(_stampLiveText(err));
             }
@@ -1126,12 +1136,7 @@ export async function sendViaWebSocket({
             // Not retryable, OR we've already exhausted the retry budget.
             // Do not let stale retry history mask a current auth/upgrade
             // decision, cancellation, or newly unsafe-to-replay outcome.
-            const currentStatus = Number(err?.httpStatus || 0);
-            const surfaceCurrent = currentStatus === 401
-                || currentStatus === 426
-                || externalSignal?.aborted
-                || err?.unsafeToRetry === true;
-            if (surfaceCurrent) {
+            if (_mustSurfaceCurrentAttempt(err, externalSignal)) {
                 emitSendSpan('error');
                 throw _stampTool(_stampLiveText(err));
             }

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

@@ -44,6 +44,10 @@ export const WS_IDLE_MS = resolveTimeoutMs(
 );
 const WS_HANDSHAKE_TIMEOUT_MS = PROVIDER_WS_HANDSHAKE_TIMEOUT_MS;
 const WS_ACQUIRE_TIMEOUT_MS = PROVIDER_WS_ACQUIRE_TIMEOUT_MS;
+// Enforced by `ws` while fragments are assembled, before a complete payload
+// reaches the stream consumer or is decoded. Shared by Codex, direct OpenAI,
+// and xAI so no provider can opt into an unbounded receive allocation.
+export const WS_MAX_INCOMING_FRAME_BYTES = 16 * 1024 * 1024;
 // A write that never reaches the ws callback is indistinguishable from a
 // wedged transport. Keep it under the same short bound as socket acquisition
 // so the caller can discard the entry and reconnect before arming stream
@@ -459,7 +463,11 @@ function _openSocket({ auth, sessionToken, turnState, externalSignal, cacheKey,
             }
             (ok ? resolve : reject)(val);
         };
-        const socket = new WebSocket(url, { headers, handshakeTimeout: WS_HANDSHAKE_TIMEOUT_MS });
+        const socket = new WebSocket(url, {
+            headers,
+            handshakeTimeout: WS_HANDSHAKE_TIMEOUT_MS,
+            maxPayload: WS_MAX_INCOMING_FRAME_BYTES,
+        });
         acquireTimer = setTimeout(() => {
             if (settled) return;
             if (process.env.MIXDOG_DEBUG_AGENT) {

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

@@ -33,7 +33,7 @@ import {
     streamStalledError,
 } from '../stall-policy.mjs';
 import { customToolCallFromResponseItem } from './custom-tool-wire.mjs';
-import { _wsErrLabel } from './openai-ws-pool.mjs';
+import { _wsErrLabel, WS_MAX_INCOMING_FRAME_BYTES } from './openai-ws-pool.mjs';
 import {
     _sansInput,
     _stableStringify,
@@ -100,10 +100,9 @@ export const WS_PRE_RESPONSE_CREATED_MS = (() => {
 // including metadata/keepalive, proves the socket is live.
 export const WS_INTER_CHUNK_MS = PROVIDER_WS_INTER_CHUNK_TIMEOUT_MS;
 // Bound the second allocation performed when ws RawData is decoded to UTF-8.
-// The ws library has already assembled the Buffer by this point, so this check
-// must stay before data.toString() below. xAI shares this stream implementation
-// but retains its existing unbounded behavior.
-const OPENAI_WS_MAX_INCOMING_FRAME_BYTES = 16 * 1024 * 1024;
+// The pool also applies this bound as `maxPayload` before assembly; this
+// defense-in-depth check must stay before data.toString() for injected sockets
+// and test seams.
 const X_CODEX_TURN_STATE_HEADER = 'x-codex-turn-state';
 const WS_TRACE_ENABLED = process.env.MIXDOG_WS_TRACE === '1';
 
@@ -288,9 +287,10 @@ export async function _streamResponse({
     }
     const preResponseCreatedMs = _positiveInt(_timeouts?.preResponseCreatedMs, WS_PRE_RESPONSE_CREATED_MS);
     const interChunkMs = _positiveInt(_timeouts?.interChunkMs, WS_INTER_CHUNK_MS);
-    const maxIncomingFrameBytes = traceProvider === 'xai'
-        ? 0
-        : _positiveInt(_timeouts?.maxIncomingFrameBytes, OPENAI_WS_MAX_INCOMING_FRAME_BYTES);
+    const maxIncomingFrameBytes = _positiveInt(
+        _timeouts?.maxIncomingFrameBytes,
+        WS_MAX_INCOMING_FRAME_BYTES,
+    );
     // First-MEANINGFUL-frame deadline. Distinct from preResponseCreatedMs (a
     // short pre-created byte-silence window that resetIdle clears on the FIRST
     // frame of any kind): this timer is cleared only by a meaningful response
@@ -804,7 +804,7 @@ export async function _streamResponse({
             const frameBytes = _incomingFrameByteLength(data);
             if (maxIncomingFrameBytes > 0 && frameBytes != null && frameBytes > maxIncomingFrameBytes) {
                 const err = new Error(
-                    `OpenAI WebSocket response frame is too large (${frameBytes} bytes; limit ${maxIncomingFrameBytes} bytes); request is retryable`,
+                    `${errLabel} response frame is too large (${frameBytes} bytes; limit ${maxIncomingFrameBytes} bytes); request is retryable`,
                 );
                 err.code = 'EOPENAIWSFRAMETOOLARGE';
                 err.wsFrameTooLarge = true;
@@ -1375,6 +1375,16 @@ export async function _streamResponse({
             if (WS_TRACE_ENABLED) _writeWsLifecycleTrace('error');
             if (done) return;
             const wrapped = err instanceof Error ? err : new Error(String(err));
+            // `ws` rejects an over-limit fragmented message before assembly
+            // with this typed code. Preserve the same retry classification as
+            // the defense-in-depth complete-frame check above.
+            if (wrapped.code === 'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH') {
+                try {
+                    wrapped.wsFrameTooLarge = true;
+                    wrapped.retryable = true;
+                    midState.wsFrameTooLarge = true;
+                } catch {}
+            }
             if (terminalError) {
                 // Preserve the first terminalError; chain the later socket
                 // error in via `cause` (or `suppressed` if cause already set)