mixdog 0.9.95 → 0.9.96

package/src/runtime/agent/orchestrator/providers/stream-json-pool.mjs

@@ -0,0 +1,291 @@
+import { availableParallelism } from 'node:os';
+import { Worker } from 'node:worker_threads';
+import { currentProviderAdmissionOwner } from './admission-scheduler.mjs';
+
+const DEFAULT_MIN_BATCH_BYTES = 32 * 1024;
+
+function positiveInt(value, fallback) {
+    const parsed = Math.floor(Number(value));
+    return Number.isFinite(parsed) && parsed >= 1 ? parsed : fallback;
+}
+
+function configuredWorkerCount(env = process.env) {
+    const configured = Number(env.MIXDOG_PROVIDER_STREAM_WORKERS);
+    if (configured === 0) return 0;
+    if (Number.isFinite(configured) && configured > 0) return Math.floor(configured);
+    return Math.max(1, Math.min(4, availableParallelism() - 1));
+}
+
+function abortError(signal) {
+    return signal?.reason instanceof Error
+        ? signal.reason
+        : new Error(String(signal?.reason || 'provider stream parse canceled'));
+}
+
+function syntaxError(details) {
+    const error = new SyntaxError(String(details?.message || 'invalid JSON'));
+    error.name = String(details?.name || 'SyntaxError');
+    return error;
+}
+
+/**
+ * Reusable worker pool for the CPU part of provider SSE handling.
+ *
+ * Small deltas stay inline because a Worker round-trip costs more than parsing
+ * them. Large events and multi-event network chunks are parsed off the daemon
+ * event loop. Calls are never admission-capped: every request is posted
+ * immediately and workers consume their independent message queues.
+ */
+export function createStreamJsonPool({
+    maxWorkers = configuredWorkerCount(),
+    minBatchBytes = Number(process.env.MIXDOG_PROVIDER_STREAM_WORKER_MIN_BYTES)
+        || DEFAULT_MIN_BATCH_BYTES,
+    maxPendingBytes = (Number(process.env.MIXDOG_PROVIDER_STREAM_PENDING_MB) || 32)
+        * 1024 * 1024,
+    WorkerImpl = Worker,
+} = {}) {
+    const workerMax = Math.max(0, Math.floor(Number(maxWorkers) || 0));
+    const inlineBelowBytes = Math.max(0, Math.floor(Number(minBatchBytes) || 0));
+    const slots = [];
+    const ownerAffinities = new Map();
+    const waiting = [];
+    const pendingByteMax = Math.max(1024 * 1024, Math.floor(Number(maxPendingBytes) || 0));
+    let pendingBytes = 0;
+    let waitingBytes = 0;
+    let sequence = 0;
+    let closed = false;
+    const stats = {
+        inlineBatches: 0,
+        offloadedBatches: 0,
+        fallbackBatches: 0,
+        parsedBytes: 0,
+    };
+
+    function parseInline(payloads) {
+        return payloads.map((payload) => JSON.parse(payload));
+    }
+
+    function removeSlot(slot) {
+        const index = slots.indexOf(slot);
+        if (index >= 0) slots.splice(index, 1);
+        for (const [owner, assigned] of ownerAffinities) {
+            if (assigned === slot) ownerAffinities.delete(owner);
+        }
+    }
+
+    function failSlot(slot) {
+        if (slot.failed) return;
+        slot.failed = true;
+        removeSlot(slot);
+        for (const task of slot.tasks.values()) {
+            pendingBytes = Math.max(0, pendingBytes - task.bytes);
+            task.detach();
+            if (task.aborted) continue;
+            stats.fallbackBatches += 1;
+            try { task.resolve(parseInline(task.payloads)); }
+            catch (error) { task.reject(error); }
+        }
+        slot.tasks.clear();
+        try { slot.worker.terminate(); } catch {}
+        drainWaiting();
+    }
+
+    function createSlot() {
+        const worker = new WorkerImpl(new URL('./stream-json-worker.mjs', import.meta.url), {
+            execArgv: [],
+        });
+        worker.unref?.();
+        const slot = { worker, tasks: new Map(), failed: false };
+        worker.on('message', (message) => {
+            const task = slot.tasks.get(Number(message?.id));
+            if (!task) return;
+            slot.tasks.delete(Number(message.id));
+            pendingBytes = Math.max(0, pendingBytes - task.bytes);
+            task.detach();
+            if (task.aborted) return;
+            if (message?.ok === true) task.resolve(message.values);
+            else task.reject(syntaxError(message?.error));
+            drainWaiting();
+        });
+        worker.on('error', () => failSlot(slot));
+        worker.on('exit', () => {
+            if (!closed) failSlot(slot);
+            else removeSlot(slot);
+        });
+        slots.push(slot);
+        return slot;
+    }
+
+    function pickSlot(ownerKey) {
+        const ready = slots.filter((slot) => !slot.failed);
+        const owner = String(ownerKey || '').trim().slice(0, 240);
+        const assigned = owner ? ownerAffinities.get(owner) : null;
+        if (assigned && !assigned.failed) return assigned;
+        const least = ready.sort((left, right) => left.tasks.size - right.tasks.size)[0] || null;
+        const slot = ready.length < workerMax && (!least || least.tasks.size > 0)
+            ? createSlot()
+            : least || createSlot();
+        if (owner) {
+            ownerAffinities.set(owner, slot);
+            while (ownerAffinities.size > 4096) {
+                ownerAffinities.delete(ownerAffinities.keys().next().value);
+            }
+        }
+        return slot;
+    }
+
+    function removeWaiting(task) {
+        const index = waiting.indexOf(task);
+        if (index < 0) return false;
+        waiting.splice(index, 1);
+        waitingBytes = Math.max(0, waitingBytes - task.bytes);
+        return true;
+    }
+
+    function postTask(task) {
+        const slot = pickSlot(task.ownerKey);
+        task.slot = slot;
+        slot.tasks.set(task.id, task);
+        pendingBytes += task.bytes;
+        try {
+            slot.worker.postMessage({ id: task.id, payloads: task.payloads });
+        } catch {
+            slot.tasks.delete(task.id);
+            pendingBytes = Math.max(0, pendingBytes - task.bytes);
+            task.detach();
+            stats.fallbackBatches += 1;
+            try { task.resolve(parseInline(task.payloads)); }
+            catch (error) { task.reject(error); }
+            drainWaiting();
+        }
+    }
+
+    function drainWaiting() {
+        while (waiting.length > 0) {
+            const task = waiting[0];
+            if (pendingBytes > 0 && pendingBytes + task.bytes > pendingByteMax) return;
+            waiting.shift();
+            waitingBytes = Math.max(0, waitingBytes - task.bytes);
+            if (task.aborted) continue;
+            postTask(task);
+        }
+    }
+
+    function parseBatch(values, {
+        signal = null,
+        ownerKey = currentProviderAdmissionOwner(),
+    } = {}) {
+        const payloads = (Array.isArray(values) ? values : [values]).map((value) => String(value));
+        if (signal?.aborted) return Promise.reject(abortError(signal));
+        const bytes = payloads.reduce((sum, payload) => sum + Buffer.byteLength(payload), 0);
+        stats.parsedBytes += bytes;
+        if (workerMax === 0 || bytes < inlineBelowBytes) {
+            stats.inlineBatches += 1;
+            try { return Promise.resolve(parseInline(payloads)); }
+            catch (error) { return Promise.reject(error); }
+        }
+        if (closed) return Promise.reject(new Error('provider stream JSON pool is closed'));
+        if (bytes > pendingByteMax) {
+            const error = new Error(
+                `provider stream JSON batch exceeded ${pendingByteMax} bytes`,
+            );
+            error.code = 'ERESOURCEPRESSURE';
+            return Promise.reject(error);
+        }
+
+        const id = ++sequence;
+        stats.offloadedBatches += 1;
+        return new Promise((resolve, reject) => {
+            const task = {
+                id,
+                ownerKey,
+                bytes,
+                payloads,
+                resolve,
+                reject,
+                aborted: false,
+                onAbort: null,
+                detach() {
+                    if (!task.onAbort || !signal) return;
+                    try { signal.removeEventListener('abort', task.onAbort); } catch {}
+                    task.onAbort = null;
+                },
+            };
+            if (signal) {
+                task.onAbort = () => {
+                    if (task.aborted) return;
+                    task.aborted = true;
+                    task.detach();
+                    if (removeWaiting(task)) {
+                        reject(abortError(signal));
+                        return;
+                    }
+                    reject(abortError(signal));
+                };
+                signal.addEventListener('abort', task.onAbort, { once: true });
+            }
+            if (pendingBytes > 0 && pendingBytes + bytes > pendingByteMax) {
+                if (waitingBytes + bytes > pendingByteMax) {
+                    task.detach();
+                    const error = new Error(
+                        `provider stream JSON backlog exceeded ${pendingByteMax} bytes`,
+                    );
+                    error.code = 'ERESOURCEPRESSURE';
+                    reject(error);
+                    return;
+                }
+                waiting.push(task);
+                waitingBytes += bytes;
+                return;
+            }
+            postTask(task);
+        });
+    }
+
+    async function close(reason = 'provider stream JSON pool closed') {
+        if (closed) return;
+        closed = true;
+        const error = new Error(reason);
+        for (const task of waiting.splice(0)) {
+            task.detach();
+            if (!task.aborted) task.reject(error);
+        }
+        waitingBytes = 0;
+        const workers = [];
+        for (const slot of slots.splice(0)) {
+            for (const task of slot.tasks.values()) {
+                task.detach();
+                if (!task.aborted) task.reject(error);
+            }
+            slot.tasks.clear();
+            workers.push(Promise.resolve(slot.worker.terminate()).catch(() => {}));
+        }
+        ownerAffinities.clear();
+        await Promise.all(workers);
+    }
+
+    function snapshot() {
+        return {
+            workers: slots.filter((slot) => !slot.failed).length,
+            workerMax,
+            activeBatches: slots.reduce((sum, slot) => sum + slot.tasks.size, 0),
+            pendingBytes,
+            waitingBatches: waiting.length,
+            waitingBytes,
+            maxPendingBytes: pendingByteMax,
+            ownerAffinities: ownerAffinities.size,
+            inlineBatches: stats.inlineBatches,
+            offloadedBatches: stats.offloadedBatches,
+            fallbackBatches: stats.fallbackBatches,
+            parsedBytes: stats.parsedBytes,
+        };
+    }
+
+    return { parseBatch, close, snapshot };
+}
+
+export const providerStreamJsonPool = createStreamJsonPool();
+export const parseProviderJsonBatch = (payloads, options) =>
+    providerStreamJsonPool.parseBatch(payloads, options);
+export const providerStreamJsonSnapshot = () => providerStreamJsonPool.snapshot();
+export const closeProviderStreamJsonPool = (reason) => providerStreamJsonPool.close(reason);

package/src/runtime/agent/orchestrator/providers/stream-json-worker.mjs

@@ -0,0 +1,21 @@
+import { parentPort } from 'node:worker_threads';
+
+if (!parentPort) throw new Error('provider stream JSON worker requires parentPort');
+
+parentPort.on('message', (message) => {
+    const id = Number(message?.id);
+    const payloads = Array.isArray(message?.payloads) ? message.payloads : [];
+    try {
+        const values = payloads.map((payload) => JSON.parse(String(payload)));
+        parentPort.postMessage({ id, ok: true, values });
+    } catch (error) {
+        parentPort.postMessage({
+            id,
+            ok: false,
+            error: {
+                name: String(error?.name || 'SyntaxError'),
+                message: String(error?.message || error || 'invalid JSON'),
+            },
+        });
+    }
+});

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

@@ -403,13 +403,18 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
     // Continuations since the last executed tool batch — bounds the text-only
     // continuation runaway (see PROVIDER_CONTINUATION_NO_TOOL_LIMIT).
     let _continuationsSinceToolBatch = 0;
-    // Loop-level transport replays consumed this ask (see send-with-recovery
-    // TRANSPORT_RETRY_MAX): bounded per turn, reset only with a fresh ask.
+    // Loop-level transport replays consumed since the last SUCCESSFUL send
+    // (see send-with-recovery TRANSPORT_RETRY_MAX). Reference parity: codex
+    // starts each sampling request at retries=0 (and resets on transport
+    // fallback), cc's withRetry budget is per request, opencode schedules
+    // retries per stream call. A per-ask budget instead let one early blip in
+    // a long turn leave every later iteration with zero replays.
     let _transportRetriesUsed = 0;
     // Queued prompt/task notifications are attached after a
     // tool batch, before the continuation provider send. Normal batches drain
     // up to 'next'; a Sleep-like tool grants a 'later' flush.
     let _toolBatchJustCompleted = false;
+    let _lastToolBatchEndedAt = 0;
     let _lastToolBatchHadSleep = false;
     const isSleepLikeToolCall = (call) => {
         const name = String(call?.name || call?.toolName || call?.function?.name || '').toLowerCase();
@@ -457,7 +462,7 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
                 // non-empty final so callers never see an empty response.
                 if (response && !String(response.content || '').trim()) {
                     response.content = sessionAgent === 'explorer'
-                        ? 'EXPLORATION_FAILED'
+                        ? 'EXPLORATION_FAILED [iteration-cap] — explorer hit its tool-turn cap with zero anchors; retry once with changed tokens or a narrower root'
                         : '[iteration cap reached before final text]';
                     if (Array.isArray(response.toolCalls)) response.toolCalls = [];
                 }
@@ -632,6 +637,10 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
                 return result;
             };
         const sendStartedAt = Date.now();
+        const preSendMs = sendStartedAt - _iterT0;
+        const toolResumeMs = _lastToolBatchEndedAt
+            ? sendStartedAt - _lastToolBatchEndedAt
+            : null;
         try { opts.onProviderSendStarted?.(); } catch {}
         const _sendResult = await runWithProviderRequestToolsScope(
             requestToolScope,
@@ -659,6 +668,10 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
         opts.onToolCall = undefined;
         delete opts.cacheBreakIntent;
         contextOverflowRetryUsed = false;
+        // A completed send ends the outage this budget was covering; the next
+        // iteration is a fresh request and must get the full replay budget
+        // again (mirrors contextOverflowRetryUsed above).
+        _transportRetriesUsed = 0;
         // Capture opaque state for the next turn only when the provider
         // explicitly returned the field. Absence means "no update"; an own
         // property with null/undefined means "clear".
@@ -679,6 +692,8 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
                 sessionId,
                 iteration: iterations,
                 sendMs: Date.now() - sendStartedAt,
+                preSendMs,
+                toolResumeMs,
                 messageCount: Array.isArray(messages) ? messages.length : 0,
                 bodyBytesEst: _traceVerbose
                     ? estimateProviderPayloadBytes(messages, model, sendTools)
@@ -1050,15 +1065,24 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
         }));
         // Settle the stop hook on the batch that actually executed.
         _toolFailureStopHook.endBatch(_callsToExecute);
+        const _toolsEndedAt = Date.now();
+        try {
+            opts.onToolPhaseCompleted?.({
+                iteration: nextIteration,
+                calls: _callsToExecute.length,
+                elapsedMs: _toolsEndedAt - _toolsT0,
+            });
+        } catch {}
         // Loop-phase timing (diagnostics): where non-model time goes per
         // iteration — presend (repair/compact/snapshot), send (provider
         // round-trip incl. streaming), tools (batch execution). Gated by the
         // same env as [turn-timing] so bench runs opt in via -AgentEnv.
         if (process.env.MIXDOG_TURN_TIMING === '1') {
             try {
-                process.stderr.write(`[loop-timing] iter=${nextIteration} presend=${sendStartedAt - _iterT0}ms send=${_sendEndedAt - sendStartedAt}ms tools=${Date.now() - _toolsT0}ms calls=${_callsToExecute.length}\n`);
+                process.stderr.write(`[loop-timing] iter=${nextIteration} presend=${preSendMs}ms send=${_sendEndedAt - sendStartedAt}ms tools=${_toolsEndedAt - _toolsT0}ms calls=${_callsToExecute.length}\n`);
             } catch { /* diagnostics only */ }
         }
+        _lastToolBatchEndedAt = _toolsEndedAt;
         _toolBatchJustCompleted = true;
         _continuationsSinceToolBatch = 0;
         _lastToolBatchHadSleep = _callsToExecute.some(isSleepLikeToolCall);

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

@@ -1,13 +1,11 @@
 // Eager tool-dispatch controller, extracted from agent-loop.mjs. Owns the
 // per-turn pending promise map, the intra-turn in-flight signature set, and
-// the mutation epoch. Read-only calls may start while the provider is still
-// streaming. Side-effect calls stream-start too until the first apply_patch
-// appears in the stream (they are definitively in segment 0); after that they
-// wait for their segment bounded by apply_patch barriers. Patches execute
-// serially as barriers, so a failed patch can skip every later side effect.
+// the mutation epoch. Every valid call may start while the provider is still
+// streaming, including apply_patch and shell in the same batch. Tool-local
+// conflict guards own safety; results are collected later in call order.
 import { normalizeToolEnvelope } from './tool-envelope.mjs';
 import { isInvalidToolArgsMarker } from '../providers/openai-compat-stream.mjs';
-import { _intraTurnSig, _isMutationTool, _isOrderedGateSkippable, _isReadTool, _isScopedCacheableTool, _stripMcpPrefix } from './loop/tool-classify.mjs';
+import { _intraTurnSig, _isReadTool, _isScopedCacheableTool, _stripMcpPrefix } from './loop/tool-classify.mjs';
 import { tryReadCached, tryScopedToolCached } from './read-dedup.mjs';
 import { preDispatchDenyForSession } from './loop/pre-dispatch-deny.mjs';
 import { executeTool } from './loop/tool-exec.mjs';
@@ -40,11 +38,6 @@ export function createEagerDispatcher({
         // resets at the turn boundary without leaking across getIterations().
         const _eagerInFlightSigs = new Map();
         const epoch = { mutation: 0 };
-        // True once an apply_patch tool_use has been seen in THIS turn's
-        // stream. Before that, every side-effect call streamed so far sits
-        // before the first patch in call order (segment 0), so it may start
-        // immediately — a patch that arrives later cannot gate an EARLIER call.
-        let _streamSeenMutation = false;
         const startEagerTool = (call) => {
             if (!call?.id || pending.has(call.id) || !isParallelDispatchable(call.name)) return null;
             // Never eager-execute a call whose arguments failed to parse
@@ -162,21 +155,10 @@ export function createEagerDispatcher({
             return entry;
         };
         const startEagerRun = (calls, startIndex, dupSet) => {
-            const _nextOrderedMutationIndex = calls.findIndex(
-                (call, index) => index >= startIndex && _isMutationTool(call?.name),
-            );
             for (let j = startIndex; j < calls.length; j += 1) {
                 const call = calls[j];
-                // Side effects may eager-start in the current segment but not
-                // across the next apply_patch barrier. Known read-only work
-                // may cross it and is protected by mutation-epoch re-execution.
                 if (!call?.id || !isParallelDispatchable(call.name)) continue;
                 if (dupSet && dupSet.has(call.id)) continue;
-                if (
-                    _nextOrderedMutationIndex >= 0
-                    && j >= _nextOrderedMutationIndex
-                    && _isOrderedGateSkippable(call.name)
-                ) continue;
                 // A null return here is NOT a state barrier. It means a
                 // non-barrier stub — intra-turn in-flight dup, repeat-failure /
                 // cross-turn dedup, pre-dispatch-deny, invalid-args, or a cache
@@ -187,17 +169,6 @@ export function createEagerDispatcher({
             }
         };
         const onToolCall = (call) => {
-            if (_isMutationTool(call?.name)) {
-                _streamSeenMutation = true;
-                return;
-            }
-            // Declared read-only calls always overlap streaming (epoch guard
-            // re-executes them if a later patch lands). Side-effect calls may
-            // stream-start only while NO apply_patch has streamed yet: their
-            // call-order position is already fixed before the first barrier,
-            // matching exactly what startEagerRun would do post-batch. Once a
-            // patch has streamed, later side effects wait for their segment.
-            if (!isEagerDispatchable(call?.name, tools) && _streamSeenMutation) return;
             startEagerTool(call);
         };
     return { pending, epoch, startEagerTool, startEagerRun, onToolCall };

package/src/runtime/agent/orchestrator/session/loop/pre-dispatch-deny.mjs

@@ -71,6 +71,19 @@ export function isLoopbackHttpUrl(value) {
  */
 export function routeWebFetchCall(call) {
     if (call?.name !== 'web_fetch') return call;
+    // A JSON-stringified array ('["https://a","https://b"]') is a common
+    // provider serialisation artifact. Parse it back into real URLs so the
+    // fetch surface routes and validates them instead of rejecting the call.
+    const rawUrl = call?.arguments?.url;
+    if (typeof rawUrl === 'string' && /^\s*\[/.test(rawUrl)) {
+        try {
+            const parsed = JSON.parse(rawUrl);
+            if (Array.isArray(parsed) && parsed.length > 0
+                && parsed.every((item) => typeof item === 'string' && item.trim())) {
+                call.arguments.url = parsed.map((item) => item.trim());
+            }
+        } catch { /* leave the original value for the downstream validator */ }
+    }
     const urls = callUrls(call);
     if (!urls.length) return call;
     if (urls.every(isLoopbackHttpUrl)) call.name = 'local_fetch';

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

@@ -28,8 +28,8 @@ export function isOutputLimitStopReason(reason) {
 // NOT a completed assistant turn even when it holds final-looking text: the
 // provider explicitly stated it intends to keep sampling inside the SAME user
 // turn. Two structured shapes are honored:
-//   - `endTurn === false` (Codex/Responses `end_turn=false`; see
-//     codex-rs/core/src/session/turn.rs Completed{ end_turn } → needs_follow_up)
+//   - `endTurn === false` (Responses `end_turn=false` on the completed frame,
+//     which means the turn needs a follow-up)
 //   - Anthropic `stop_reason: 'pause_turn'` (server-side pause; the turn is
 //     resumed by replaying the transcript unchanged)
 // Structural only — no lexical/progress-text heuristic is consulted, and a

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

@@ -15,30 +15,6 @@ export function _isMutationTool(name) {
     const n = _stripMcpPrefix(name);
     return n === 'apply_patch';
 }
-// Side-effect-free read-only tools that may eager-start across an upcoming
-// apply_patch barrier and may keep running after an earlier patch fails.
-// Everything NOT in this set waits for its side-effect segment and is skipped
-// after a failed patch. Kept separate from _isMutationTool, which stays
-// apply_patch-only for epoch counting.
-const ORDERED_GATE_SAFE_READONLY_TOOLS = new Set([
-    'read',
-    'find',
-    'glob',
-    'list',
-    'grep',
-    'code_graph',
-    'explore',
-    'search',
-    'web_fetch',
-]);
-// True when a LATER call in a batch must be skipped because an earlier ordered
-// mutation (apply_patch) already failed. Conservative: only the known
-// side-effect-free read-only tools above keep running; shell, write tools, and
-// unknown MCP tools are skipped so they cannot act on unchanged/partially
-// changed state.
-export function _isOrderedGateSkippable(name) {
-    return !ORDERED_GATE_SAFE_READONLY_TOOLS.has(_stripMcpPrefix(name));
-}
 const SCOPED_CACHEABLE_TOOLS = new Set([
     'code_graph',
     'grep',

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

@@ -227,36 +227,10 @@ export async function executeTool(name, args, cwd, callerSessionId, sessionRef,
     }
     if (name === 'apply_patch') {
         const patchArgs = typeof args === 'string' ? { patch: args } : { ...(args || {}) };
-        // post_shell: optional verification command executed through the normal
-        // one-shot shell path ONLY after the patch applies cleanly; a failed
-        // patch skips it. Patch text and shell output return as ONE tool
-        // result, so patch+verify costs a single call. Runtime-only knob:
-        // stripped before executePatchTool sees the args.
-        const postShell = typeof patchArgs.post_shell === 'string' && patchArgs.post_shell.trim()
-            ? patchArgs.post_shell.trim()
-            : null;
-        delete patchArgs.post_shell;
-        const patchResult = await executePatchTool(name, patchArgs, cwd, {
+        return executePatchTool(name, patchArgs, cwd, {
             sessionId: callerSessionId,
             toolCallId: executeOpts.toolCallId || null,
         });
-        if (!postShell) return patchResult;
-        const patchNorm = normalizeToolEnvelope(patchResult);
-        const patchText = typeof patchNorm.result === 'string' ? patchNorm.result : String(patchNorm.result ?? '');
-        // Text-based failure detection only: legacy string returns normalize
-        // to explicitSuccess:false even on success, so that flag is unusable here.
-        const patchFailed = /^Error[\s:[]/.test(patchText.trimStart());
-        if (patchFailed) {
-            return `${patchText}\n--- post_shell skipped: patch failed ---`;
-        }
-        const shellRes = await executeBuiltinTool('shell', { command: postShell }, cwd, completionToolOpts);
-        const shellNorm = normalizeToolEnvelope(shellRes);
-        const shellText = typeof shellNorm.result === 'string' ? shellNorm.result : String(shellNorm.result ?? '');
-        const shellFailed = /^Error[\s:[]/.test(shellText.trimStart());
-        const header = shellFailed
-            ? '--- post_shell FAILED (patch is applied; fix and re-verify) ---'
-            : '--- post_shell ---';
-        return `${patchText}\n\n${header}\n${shellText}`;
     }
     if (isBuiltinTool(name)) {
         // clientHostPid threaded for the same per-terminal job-scope reason as

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

@@ -12,7 +12,6 @@ import {
     isSkillDisabled,
 } from '../../context/collect.mjs';
 import { isAgentOwner } from '../../agent-owner.mjs';
-import { _isMutationTool } from './tool-classify.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
@@ -41,16 +40,13 @@ export function isEagerDispatchable(name, tools) {
     return set.has(name);
 }
 
-// Full-parallel dispatch policy: EVERY tool call in an assistant turn starts
-// executing immediately — ordering across dependent work is the MODEL's job
-// (split into separate turns). The only exception is the ordered mutation
-// (apply_patch), which stays in the serial batch body so multi-patch turns
-// keep deterministic order, the all-or-nothing failure gate, and cache
-// invalidation sequencing. isEagerDispatchable above remains the READ-ONLY
-// classifier used for dedup eligibility, steering, and post-mutation result
-// invalidation.
+// Full-parallel dispatch policy: EVERY valid tool call in an assistant turn
+// starts immediately. Mutations rely on their own conflict scope (apply_patch
+// uses per-path locks), so disjoint writes never wait behind a global barrier.
+// isEagerDispatchable above remains the READ-ONLY classifier used for dedup
+// eligibility, steering, and post-mutation result invalidation.
 export function isParallelDispatchable(name) {
-    return typeof name === 'string' && name.length > 0 && !_isMutationTool(name);
+    return typeof name === 'string' && name.length > 0;
 }
 
 // Read-only is necessary but not sufficient for result deduplication. Loader

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

@@ -645,10 +645,15 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                     onProviderSendStarted: () => {
                         _turnInterruption.markProviderSendStarted();
                         _scheduleTurnCheckpoint(true);
+                        try { askOpts?.onProviderSendStarted?.(); } catch {}
                     },
                     onToolPhaseStarted: () => {
                         _turnInterruption.markToolPhaseStarted();
                         _scheduleTurnCheckpoint(true);
+                        try { askOpts?.onToolPhaseStarted?.(); } catch {}
+                    },
+                    onToolPhaseCompleted: (detail) => {
+                        try { askOpts?.onToolPhaseCompleted?.(detail); } catch {}
                     },
                     onUsageDelta: (d) => {
                         persistIterationMetrics(d).catch(() => {});