mixdog 0.9.36 → 0.9.38

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

@@ -16,10 +16,23 @@ import { isAgentOwner } from '../../agent-owner.mjs';
 // Eager-dispatch: tools with readOnlyHint:true in their declaration are safe
 // to execute during SSE parsing so tool work overlaps with the rest of the
 // stream. Writes, bash, MCP and skills stay serial after send() returns.
+// Memoized: the read-only name Set is built once per distinct `tools` array
+// (keyed by identity via a module-level WeakMap) so repeated per-call lookups
+// are O(1) instead of O(N) tools.find scans.
+const _eagerNameSetByTools = new WeakMap();
 export function isEagerDispatchable(name, tools) {
     if (!Array.isArray(tools)) return false;
-    const def = tools.find(t => t?.name === name);
-    return def?.annotations?.readOnlyHint === true;
+    let set = _eagerNameSetByTools.get(tools);
+    if (set === undefined) {
+        set = new Set();
+        for (const t of tools) {
+            if (t?.annotations?.readOnlyHint === true && typeof t.name === 'string') {
+                set.add(t.name);
+            }
+        }
+        _eagerNameSetByTools.set(tools, set);
+    }
+    return set.has(name);
 }
 export function messagesArrayChanged(before, after) {
     if (!Array.isArray(before) || !Array.isArray(after)) return before !== after;

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

@@ -44,14 +44,6 @@ import { _tryBridgeExplicitPrefetch } from './prefetch-bridge.mjs';
 import { sanitizeSessionMessagesForModel, persistCompactedOutgoingAfterAskFailure } from './message-sanitize.mjs';
 import { _getAgentLoop } from './runtime-loaders.mjs';
 import { getAgentRuntimeSync } from './agent-runtime-singleton.mjs';
-import { nonNegativeIntEnv } from './env-utils.mjs';
-
-// Cap how long the terminal unwind blocks on the post-result session save.
-// The result is already produced (and relayed for agent surfaces) before this
-// save, so a stalled disk write must not hold askSession() open — otherwise the
-// owning background task is stranded in `running` and its completion
-// notification never fires. A slow write finishes in the background.
-const TERMINAL_SAVE_TIMEOUT_MS = nonNegativeIntEnv('MIXDOG_TERMINAL_SAVE_TIMEOUT_MS', 5_000);
 
 /**
  * Wrap an async call so that if the session's controller aborts mid-flight,
@@ -340,25 +332,24 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                     onToolResult: typeof askOpts?.onToolResult === 'function' ? askOpts.onToolResult : undefined,
                     onToolApproval: typeof askOpts?.onToolApproval === 'function' ? askOpts.onToolApproval : undefined,
                     onCompactEvent: typeof askOpts?.onCompactEvent === 'function' ? askOpts.onCompactEvent : undefined,
-                    // Mid-turn steering drain. agentLoop calls this at every
-                    // tool-batch boundary (before the next provider.send) and
-                    // injects any returned strings as user turns — so input
-                    // (user typing, `agent type=send`) that arrives WHILE a
-                    // long multi-tool turn is in flight is picked up on the
-                    // model's very next iteration instead of waiting for the
-                    // whole task to finish. The post-turn _pendingTail drain
-                    // below still handles "followUp" input that lands after the
-                    // agent would otherwise stop. Same queue, two drain points.
-                    drainSteering: (sid) => {
+                    // Claude Code parity: mid-chain queued prompt/notification
+                    // drain is owned by agentLoop at provider-continuation
+                    // boundaries (after a tool batch, before the next send).
+                    // The post-loop _pendingTail drain below still handles
+                    // items that arrive after the model would otherwise stop.
+                    drainSteering: (sid, drainOptions = {}) => {
                         const out = [];
                         if (typeof askOpts?.drainSteering === 'function') {
                             try {
-                                const drained = askOpts.drainSteering(sid || sessionId);
+                                const drained = askOpts.drainSteering(sid || sessionId, drainOptions);
                                 if (Array.isArray(drained)) out.push(...drained);
                             } catch { /* best-effort steering drain */ }
                         }
-                        try { out.push(...drainPendingMessages(sid || sessionId)); }
-                        catch { /* best-effort pending drain */ }
+                        // Do NOT drain manager/pending-messages here: those
+                        // entries have no mode/priority/slash metadata, so
+                        // draining them mid-chain would bypass Claude Code's
+                        // queued_command filters. They are consumed by the
+                        // post-loop _pendingTail drain below.
                         return out;
                     },
                     onSteerMessage: typeof askOpts?.onSteerMessage === 'function' ? askOpts.onSteerMessage : undefined,
@@ -568,35 +559,17 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             // query/provider send (agentLoop pre-send), not after the previous
             // answer. This lets queued follow-up prompts resume immediately;
             // if they need compaction, their own spinner shows compacting first.
-            // Bounded, best-effort terminal save. The result is already produced
-            // and (for agent surfaces) relayed via onTerminalResult above. If the
-            // disk write stalls, blocking the terminal unwind here would strand the
-            // owning background task in `running` and suppress its completion
-            // notification. Cap the wait; let a slow write finish in the
-            // background instead of holding askSession() open indefinitely.
-            {
-                const savePromise = saveSessionAsync(session, { expectedGeneration: askGeneration });
-                let saveTimer = null;
-                const saveTimeout = new Promise((resolveTimeout) => {
-                    saveTimer = setTimeout(() => resolveTimeout('__save_timeout__'), TERMINAL_SAVE_TIMEOUT_MS);
-                    saveTimer.unref?.();
-                });
-                try {
-                    const outcome = await Promise.race([
-                        savePromise.then(() => '__save_ok__', (err) => { throw err; }),
-                        saveTimeout,
-                    ]);
-                    if (outcome === '__save_timeout__') {
-                        try { process.stderr.write(`[session] terminal save exceeded ${TERMINAL_SAVE_TIMEOUT_MS}ms; continuing best-effort (${sessionId})\n`); } catch {}
-                        // Don't drop the write — let it settle in the background.
-                        savePromise.catch((err) => {
-                            try { process.stderr.write(`[session] deferred terminal save failed: ${err?.message || err}\n`); } catch {}
-                        });
-                    }
-                } finally {
-                    if (saveTimer) { try { clearTimeout(saveTimer); } catch {} }
-                }
-            }
+            // Fire-and-forget terminal save. The result is already produced and
+            // (for agent surfaces) relayed via onTerminalResult above, and
+            // saveSessionAsync() has already published the in-memory snapshot via
+            // setLiveSession(), so read-your-writes holds in-process without
+            // awaiting disk. Never block the terminal unwind on the write — that
+            // would strand the owning background task in `running` and suppress
+            // its completion notification. A slow write finishes in the
+            // background.
+            saveSessionAsync(session, { expectedGeneration: askGeneration }).catch((err) => {
+                try { process.stderr.write(`[session] terminal save failed: ${err?.message || err}\n`); } catch {}
+            });
             activeSession = session;
             runtime.session = session;
             // Tag empty-synthesis BEFORE markSessionDone so the watchdog
@@ -674,11 +647,13 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             const _mergedTail = _mergePendingMessageEntries(_drained);
             if (_mergedTail?.content) {
                 _pendingTail.push(_mergedTail.content);
-                const refreshed = loadSession(sessionId);
-                if (refreshed && refreshed.closed !== true) {
-                    activeSession = refreshed;
-                    runtime.session = refreshed;
-                }
+                // Carry the just-committed in-memory session into the follow-up
+                // turn so the queued tail sees the preceding assistant/tool
+                // context. loadSession() would return this same live snapshot
+                // (setLiveSession published it), so skip the disk round-trip.
+                // NOTE: `session` (try-block const, :179) is out of scope here —
+                // `activeSession` already holds the committed session.
+                runtime.session = activeSession;
                 continue;
             }
         }

package/src/runtime/agent/orchestrator/session/manager/prompt-utils.mjs

@@ -73,13 +73,13 @@ function temporalPromptText(content) {
 function promptNeedsDateReminder(content) {
     const text = temporalPromptText(content);
     if (!text) return false;
-    return /(?:오늘|내일|어제|모레|그저께|요즘|최근|방금|아까|현재\s*(?:날짜|시간|시각)|지금\s*(?:몇\s*시|시간|날짜|요일)|몇\s*월\s*몇\s*일|몇\s*시|무슨\s*요일|요일|날짜|이번\s*(?:주|달|월|년)|지난\s*(?:주|달|월|년)|다음\s*(?:주|달|월|년)|올해|작년|내년|today|tomorrow|yesterday|recently|current\s+(?:date|time)|what\s+(?:date|time)|which\s+day|weekday|this\s+(?:week|month|year)|last\s+(?:week|month|year)|next\s+(?:week|month|year))/i.test(text);
+    return /(?:\uC624\uB298|\uB0B4\uC77C|\uC5B4\uC81C|\uBAA8\uB808|\uADF8\uC800\uAED8|\uC694\uC998|\uCD5C\uADFC|\uBC29\uAE08|\uC544\uAE4C|\uD604\uC7AC\s*(?:\uB0A0\uC9DC|\uC2DC\uAC04|\uC2DC\uAC01)|\uC9C0\uAE08\s*(?:\uBA87\s*\uC2DC|\uC2DC\uAC04|\uB0A0\uC9DC|\uC694\uC77C)|\uBA87\s*\uC6D4\s*\uBA87\s*\uC77C|\uBA87\s*\uC2DC|\uBB34\uC2A8\s*\uC694\uC77C|\uC694\uC77C|\uB0A0\uC9DC|\uC774\uBC88\s*(?:\uC8FC|\uB2EC|\uC6D4|\uB144)|\uC9C0\uB09C\s*(?:\uC8FC|\uB2EC|\uC6D4|\uB144)|\uB2E4\uC74C\s*(?:\uC8FC|\uB2EC|\uC6D4|\uB144)|\uC62C\uD574|\uC791\uB144|\uB0B4\uB144|today|tomorrow|yesterday|recently|current\s+(?:date|time)|what\s+(?:date|time)|which\s+day|weekday|this\s+(?:week|month|year)|last\s+(?:week|month|year)|next\s+(?:week|month|year))/i.test(text);
 }
 
 function promptNeedsTimeReminder(content) {
     const text = temporalPromptText(content);
     if (!text) return false;
-    return /(?:현재\s*(?:시간|시각)|지금\s*(?:몇\s*시|시간)|몇\s*시|시각|시간|current\s+time|what\s+time|time\s+is\s+it)/i.test(text);
+    return /(?:\uD604\uC7AC\s*(?:\uC2DC\uAC04|\uC2DC\uAC01)|\uC9C0\uAE08\s*(?:\uBA87\s*\uC2DC|\uC2DC\uAC04)|\uBA87\s*\uC2DC|\uC2DC\uAC01|\uC2DC\uAC04|current\s+time|what\s+time|time\s+is\s+it)/i.test(text);
 }
 
 export function buildCurrentTimeBlock(content) {

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

@@ -34,6 +34,27 @@ import { getAgentRuntimeSync, warnAgentRuntimeResolveFailureOnce } from './agent
 import { mintSessionId } from './session-id.mjs';
 import { providerCacheKey } from './provider-cache-key.mjs';
 
+function buildSessionProviderCacheOpts(providerName, sessionId, agent = null) {
+    // Keep this in sync with createSession's provider-cache policy: only
+    // explicit-breakpoint providers get BP cache opts here; OpenAI/key-prefix
+    // providers use promptCacheKey and request-time strategy instead.
+    if (cacheCapabilityForProvider(providerName) !== 'explicit-breakpoint') return null;
+    try {
+        let autoClear = null;
+        if (!agent || agent === 'lead') {
+            const loadedConfig = loadConfig({ secrets: false });
+            const normalizedAutoClear = normalizeAutoClearConfig(loadedConfig?.autoClear);
+            autoClear = {
+                ...normalizedAutoClear,
+                idleMs: resolveAutoClearIdleMs(loadedConfig, providerName),
+            };
+        }
+        return buildProviderCacheOpts(providerName, sessionId, agent, { autoClear });
+    } catch {
+        return null;
+    }
+}
+
 // --- agent spawn (createSession) ---
 // opts can pass either a `preset` object (from config.presets) or raw provider/model.
 // Preset shape: { name, provider, model, effort?, fast?, tools? }
@@ -107,22 +128,7 @@ export function createSession(opts) {
     // cacheRetention:'24h' shape) were never exercised by createSession
     // before this change, and are left untouched to avoid altering live
     // OpenAI/other-provider request shape as a side effect of this fix.
-    if (!providerCacheOpts && cacheCapabilityForProvider(providerName) === 'explicit-breakpoint') {
-        try {
-            let autoClear = null;
-            if (!opts.agent || opts.agent === 'lead') {
-                const loadedConfig = loadConfig({ secrets: false });
-                const normalizedAutoClear = normalizeAutoClearConfig(loadedConfig?.autoClear);
-                autoClear = {
-                    ...normalizedAutoClear,
-                    idleMs: resolveAutoClearIdleMs(loadedConfig, providerName),
-                };
-            }
-            providerCacheOpts = buildProviderCacheOpts(providerName, id, opts.agent, { autoClear });
-        } catch {
-            providerCacheOpts = null;
-        }
-    }
+    if (!providerCacheOpts) providerCacheOpts = buildSessionProviderCacheOpts(providerName, id, opts.agent);
     const messages = [];
     const ownerIsAgent = isAgentOwner(opts.owner);
     const resolvedAgent = opts.agent || opts.role || profile?.taskType || null;
@@ -425,6 +431,8 @@ export function updateSessionRoute(id, route = {}) {
         || (route.model && route.model !== previousModel);
     if (routeChanged) {
         const now = Date.now();
+        session.promptCacheKey = providerCacheKey(session.provider);
+        session.providerCacheOpts = buildSessionProviderCacheOpts(session.provider, session.id, session.agent) || null;
         session.lastInputTokens = 0;
         session.lastOutputTokens = 0;
         session.lastCachedReadTokens = 0;

package/src/runtime/agent/orchestrator/session/result-classification.mjs

@@ -8,6 +8,8 @@
  *
  * Matches documented tool-return error conventions:
  *   "Error: ..."      — Node/MCP tool errors (grep, find_symbol, read, code_graph, etc.)
+ *   "Error: [shell-tool-failed] ..." — shell tool/control-plane failure
+ *   "Error: [shell-run-failed] ..."  — shell command process failure
  *   "Error [code N]:" — structured builtin tool errors
  *   "[error ..."      — bracketed error format
  *   "[exit code: ..." — bash non-zero exit

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

@@ -256,7 +256,16 @@ function _flushScheduled(id) {
 // Single long-lived Worker serializes all saveSessionAsync calls.
 // The worker's message queue preserves generation-race ordering.
 let _saveWorker = null;
-let _saveWorkerPending = new Map(); // reqId → { resolve, reject, session, opts }
+// In-flight writes, keyed by reqId. Value: { id, session, opts, waiters:[{resolve,reject}] }.
+// At most ONE entry per session id at a time (single-in-flight-per-id).
+let _saveWorkerPending = new Map();
+// Latest-wins queued payload per session, keyed by id. Value: { session, opts, waiters:[] }.
+// At most ONE queued write per id: a newer saveSessionAsync while a write is in
+// flight overwrites session/opts here and appends its resolver to waiters, so
+// every superseded caller resolves when this single queued write finally lands.
+let _saveAsyncQueued = new Map();
+// id → reqId of the in-flight write for that id (enforces one-in-flight-per-id).
+let _saveAsyncInflight = new Map();
 let _saveWorkerReqId = 0;
 let _saveWorkerRefCount = 0;
 
@@ -273,12 +282,37 @@ function _getOrSpawnWorker() {
         // becomes unref'd again once all in-flight writes settle. _saveWorker
         // null-check covers the error/exit race where the worker died first.
         if (--_saveWorkerRefCount === 0 && _saveWorker) _saveWorker.unref();
-        if (ok) p.resolve();
-        else p.reject(new Error(`[session-store] worker save failed: ${error}`));
+        const { id, waiters } = p;
+        _saveAsyncInflight.delete(id);
+        // Resolve/reject every caller whose payload this write represents
+        // (the originating call plus any that coalesced onto it before it was
+        // posted). A supersede never lands here as a rejection — only a real
+        // worker failure does.
+        if (ok) { for (const w of waiters) w.resolve(); }
+        else {
+            const e = new Error(`[session-store] worker save failed: ${error}`);
+            for (const w of waiters) w.reject(e);
+        }
+        // Promote the latest-wins queued payload (if any) into the now-free
+        // in-flight slot for this id. Runs regardless of ok: the queued write
+        // is a newer, independent payload and must still be attempted so its
+        // (possibly superseded) waiters resolve when it lands.
+        const q = _saveAsyncQueued.get(id);
+        if (q) {
+            _saveAsyncQueued.delete(id);
+            try {
+                _postAsyncWrite(id, q.session, q.opts, q.waiters);
+            } catch (err) {
+                for (const w of q.waiters) w.reject(err);
+            }
+        }
     });
     _saveWorker.on('error', (err) => {
-        for (const [, p] of _saveWorkerPending) p.reject(err);
+        for (const [, p] of _saveWorkerPending) for (const w of p.waiters) w.reject(err);
         _saveWorkerPending.clear();
+        for (const [, q] of _saveAsyncQueued) for (const w of q.waiters) w.reject(err);
+        _saveAsyncQueued.clear();
+        _saveAsyncInflight.clear();
         _saveWorkerRefCount = 0;
         _saveWorker = null;
     });
@@ -290,8 +324,11 @@ function _getOrSpawnWorker() {
         // saveSessionAsync registered a resolver but before the worker
         // received the message.
         const err = new Error(`[session-store] save worker exited with code ${code}`);
-        for (const [, p] of _saveWorkerPending) p.reject(err);
+        for (const [, p] of _saveWorkerPending) for (const w of p.waiters) w.reject(err);
         _saveWorkerPending.clear();
+        for (const [, q] of _saveAsyncQueued) for (const w of q.waiters) w.reject(err);
+        _saveAsyncQueued.clear();
+        _saveAsyncInflight.clear();
         _saveWorkerRefCount = 0;
         _saveWorker = null;
     });
@@ -299,14 +336,45 @@ function _getOrSpawnWorker() {
     return _saveWorker;
 }
 
+/**
+ * Post one in-flight write for `id` to the worker and register it as the
+ * single in-flight entry for that id. Callers guarantee no write is already
+ * in flight for `id`. Throws (after cleaning its own map entries) if the
+ * worker postMessage fails so the caller can reject the affected waiters.
+ */
+function _postAsyncWrite(id, session, opts, waiters) {
+    const reqId = ++_saveWorkerReqId;
+    _saveWorkerPending.set(reqId, { id, session, opts, waiters });
+    _saveAsyncInflight.set(id, reqId);
+    try {
+        const w = _getOrSpawnWorker();
+        w.postMessage({ session, opts, reqId });
+        // Ref AFTER successful postMessage so a queue/throw failure path does
+        // not leave the worker held alive with no pending message. Paired with
+        // the unref in the message handler when count hits 0.
+        if (++_saveWorkerRefCount === 1) w.ref();
+    } catch (err) {
+        _saveWorkerPending.delete(reqId);
+        _saveAsyncInflight.delete(id);
+        throw err;
+    }
+}
+
 /**
  * Async save via a dedicated Worker thread.
  * Errors surface as thrown Errors — callers must not silently swallow them.
+ *
+ * Per-session latest-wins coalescing: for a given id there is at most one
+ * write in flight plus one queued follow-up. N rapid saves for the same id in
+ * a turn collapse to (in-flight + one queued-latest), keeping the single
+ * worker's backlog bounded. Per-id write ORDERING is preserved (a queued write
+ * is only posted once the prior in-flight write for that id settles); different
+ * ids interleave freely as before.
  */
 export function saveSessionAsync(session, opts) {
     _ensureLifecycleFields(session);
     setLiveSession(session);
-    const reqId = ++_saveWorkerReqId;
+    const id = session.id;
     const safeOpts = opts || null;
     // The Worker `postMessage` below structured-clones the whole session on the
     // main thread. `session.liveTurnMessages` (live working transcript) and
@@ -322,18 +390,28 @@ export function saveSessionAsync(session, opts) {
         ? (() => { const { liveTurnMessages: _dropLTM, toolApprovalHook: _dropTAH, ...rest } = session; return rest; })()
         : session;
     return new Promise((resolve, reject) => {
-        // Persist {session, opts} so drainSessionStore can sync-flush
-        // outstanding writes if process exit interrupts the worker queue.
-        _saveWorkerPending.set(reqId, { resolve, reject, session: clonePayload, opts: safeOpts });
+        const waiter = { resolve, reject };
+        if (_saveAsyncInflight.has(id)) {
+            // A write is already on disk for this id — coalesce into the single
+            // latest-wins queued slot. Existing queued waiters carry over so a
+            // superseded caller resolves when THIS newer write lands (never
+            // hang, never reject on supersede).
+            const q = _saveAsyncQueued.get(id);
+            if (q) {
+                q.session = clonePayload;
+                q.opts = safeOpts;
+                q.waiters.push(waiter);
+            } else {
+                _saveAsyncQueued.set(id, { session: clonePayload, opts: safeOpts, waiters: [waiter] });
+            }
+            return;
+        }
+        // Idle for this id — post immediately as the in-flight write. The
+        // in-flight entry persists {session, opts} so drainSessionStore can
+        // sync-flush outstanding writes if process exit interrupts the queue.
         try {
-            const w = _getOrSpawnWorker();
-            w.postMessage({ session: clonePayload, opts: safeOpts, reqId });
-            // Ref AFTER successful postMessage so a queue/throw failure path
-            // does not leave the worker held alive with no pending message.
-            // Paired with the unref in the message handler when count hits 0.
-            if (++_saveWorkerRefCount === 1) w.ref();
+            _postAsyncWrite(id, clonePayload, safeOpts, [waiter]);
         } catch (err) {
-            _saveWorkerPending.delete(reqId);
             reject(err);
         }
     });
@@ -431,18 +509,35 @@ export function drainSessionStore() {
     // is sync-flushed directly here. The Promise is then rejected so the
     // caller's await site does not leak unresolved (caller is at process
     // exit so the rejection is informational, not actionable).
+    const _drainErr = new Error('[session-store] drain: worker-queue interrupted by process exit');
+    // Flush in-flight writes FIRST, then the latest-wins queued payloads, so
+    // for any id with both an in-flight and a queued write the queued (newest)
+    // state is written LAST and wins on disk — no lost last write.
     for (const [, pending] of _saveWorkerPending) {
-        if (!pending.session) continue;
+        if (pending.session) {
+            try {
+                _saveSessionSync(pending.session, pending.opts);
+            } catch (err) {
+                process.stderr.write(`[session-store] drain worker-queue save failed: ${err?.message}\n`);
+            }
+        }
+        for (const w of pending.waiters) {
+            try { w.reject(_drainErr); } catch { /* best-effort */ }
+        }
+    }
+    for (const [, q] of _saveAsyncQueued) {
         try {
-            _saveSessionSync(pending.session, pending.opts);
+            _saveSessionSync(q.session, q.opts);
         } catch (err) {
             process.stderr.write(`[session-store] drain worker-queue save failed: ${err?.message}\n`);
         }
-        try {
-            pending.reject(new Error('[session-store] drain: worker-queue interrupted by process exit'));
-        } catch { /* best-effort */ }
+        for (const w of q.waiters) {
+            try { w.reject(_drainErr); } catch { /* best-effort */ }
+        }
     }
     _saveWorkerPending.clear();
+    _saveAsyncQueued.clear();
+    _saveAsyncInflight.clear();
     _saveWorkerRefCount = 0;
 }
 

package/src/runtime/agent/orchestrator/session/tool-batch.mjs

@@ -96,6 +96,9 @@ export async function processToolBatch(ctx) {
             if (isBuiltinTool(call.name)) {
                 call.name = canonicalizeBuiltinToolName(call.name);
             }
+            // Per-call cross-turn signature, computed at most once (lazily, only
+            // when the call is eager — both consumer sites are eager-gated).
+            let _ctSig = null;
             if (_duplicateCallIds.has(call.id)) {
                 const _firstId = _dupFirstId.get(call.id);
                 const _stub = `[intra-turn-dedup] identical read-only \`${call.name}\` call was already executed in this same assistant turn as tool_use_id=${_firstId}. The first call's tool_result is in context immediately above; skipping re-execution to save tokens. If you needed a different slice of the file, narrow the next call (different path / offset / limit / pattern) so it has a distinct signature.`;
@@ -113,7 +116,7 @@ export async function processToolBatch(ctx) {
             // escalation tail once the session has emitted 5+ dedup stubs total.
             // Never applies to write/bash/MCP/skill tools (not eager-dispatchable).
             if (isEagerDispatchable(call.name, tools)) {
-                const _ctSig = crossTurnSignature(call.name, call.arguments);
+                _ctSig = crossTurnSignature(call.name, call.arguments);
                 const _prior = crossTurnCalls.get(_ctSig);
                 if (_prior && _prior.firstIteration < iterations) {
                     _prior.count += 1;
@@ -576,7 +579,7 @@ export async function processToolBatch(ctx) {
                 if (_executeOk) {
                     const _isEager = isEagerDispatchable(call.name, tools);
                     if (_isEager) {
-                        const _ctSig = crossTurnSignature(call.name, call.arguments);
+                        if (_ctSig === null) _ctSig = crossTurnSignature(call.name, call.arguments);
                         if (!crossTurnCalls.has(_ctSig)) {
                             crossTurnCalls.set(_ctSig, { count: 1, firstIteration: iterations });
                             if (crossTurnCalls.size > crossTurnCap) {

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

@@ -191,6 +191,43 @@ export const PROVIDER_WS_ACQUIRE_TIMEOUT_MS = resolveTimeoutMs(
     { minMs: 5_000, maxMs: PROVIDER_MAX_BEFORE_WARN_MS },
 );
 
+// WS pool liveness (ping/pong) — closes the gap between a socket going
+// half-open (peer gone / TLS wedge) and the semantic-idle watchdog noticing
+// (120s). Node `ws` send() is fire-and-forget, so a dead pooled socket
+// silently blackholes response.create frames until a downstream timeout. An
+// idle pooled socket is pinged on this cadence; a reused socket that has been
+// quiet longer than the stale window is ping-probed before hand-out.
+// Gated OFF by default for codex/opencode parity — neither pings model
+// sockets. Enable with MIXDOG_PROVIDER_WS_PING_ENABLED=1. When disabled, no
+// liveness interval is armed and the acquire-reuse ping probe is skipped (the
+// non-OPEN eviction scan still runs); lastAliveAt stamping is harmless.
+const _wsPingRaw = process.env.MIXDOG_PROVIDER_WS_PING_ENABLED;
+export const PROVIDER_WS_PING_ENABLED = _wsPingRaw === '1' || _wsPingRaw === 'true' || _wsPingRaw === 'yes';
+
+export const PROVIDER_WS_PING_INTERVAL_MS = resolveTimeoutMs(
+    'MIXDOG_PROVIDER_WS_PING_INTERVAL_MS',
+    30_000,
+    { minMs: 5_000, maxMs: PROVIDER_MAX_BEFORE_WARN_MS },
+);
+
+// Missed-pong grace: after a ping, the pong must land within this bound or the
+// socket is treated as dead (closed + evicted). Doubles as the short probe
+// bound on the acquire-reuse path so a busy caller is never handed a wedged
+// socket.
+export const PROVIDER_WS_PONG_TIMEOUT_MS = resolveTimeoutMs(
+    'MIXDOG_PROVIDER_WS_PONG_TIMEOUT_MS',
+    5_000,
+    { minMs: 1_000, maxMs: 60_000 },
+);
+
+// Activity freshness window: a pooled socket with observed activity (pong /
+// release) newer than this is assumed live and skips the acquire-reuse probe.
+export const PROVIDER_WS_LIVENESS_STALE_MS = resolveTimeoutMs(
+    'MIXDOG_PROVIDER_WS_LIVENESS_STALE_MS',
+    30_000,
+    { minMs: 5_000, maxMs: PROVIDER_MAX_BEFORE_WARN_MS },
+);
+
 // Single inter-chunk idle timer (300s), matching the upstream WS provider's
 // default stream idle timeout. Mixdog resets one idle timer on every received
 // WS frame (openai-oauth-ws messageHandler resets on every parsed event). There
@@ -219,6 +256,24 @@ export const PROVIDER_WS_FIRST_MEANINGFUL_TIMEOUT_MS = resolveTimeoutMs(
     { minMs: 10_000, maxMs: STALL_WARN_MS },
 );
 
+// WS-specific semantic idle window. Do NOT reuse
+// PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS here: that shared SSE default was raised to
+// ~285s to avoid false-aborting Anthropic effort-mode streams that legitimately
+// produce no deltas while thinking. The WS transport is different: a silent
+// OpenAI/xAI websocket turn can sit with only connection/metadata activity while
+// the TUI lead-turn watchdog is also 300s. If the provider waits ~285-300s
+// before surfacing the stall, the UI watchdog often wins and the user only sees
+// "Turn timed out after 300s" instead of a provider retry/fallback.
+//
+// Keep WS hangs bounded well below the TUI watchdog while still allowing normal
+// long reasoning streams that emit reasoning/text/tool deltas (those reset this
+// timer). Env-overridable for experiments.
+export const PROVIDER_WS_SEMANTIC_IDLE_TIMEOUT_MS = resolveTimeoutMs(
+    ['MIXDOG_PROVIDER_WS_SEMANTIC_IDLE_TIMEOUT_MS', 'MIXDOG_PROVIDER_WS_OUTPUT_IDLE_TIMEOUT_MS'],
+    120_000,
+    { minMs: 10_000, maxMs: PROVIDER_MAX_BEFORE_WARN_MS },
+);
+
 // First retry has a small floor (250ms) instead of 0ms: an immediate reissue on
 // a transient 5xx burst lets parallel workers thundering-herd the backend in
 // lockstep (jitter alone can't decluster a 0ms base). Subsequent steps keep the