mixdog 0.9.85 → 0.9.86

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

@@ -34,6 +34,7 @@ import {
 import { getAgentRuntimeSync, warnAgentRuntimeResolveFailureOnce } from './agent-runtime-singleton.mjs';
 import { mintSessionId } from './session-id.mjs';
 import { providerCacheKey } from './provider-cache-key.mjs';
+import { clearTurnCheckpoint, recoverTurnCheckpoint } from './turn-checkpoint.mjs';
 
 function buildSessionProviderCacheOpts(providerName, sessionId, agent = null) {
     // Keep this in sync with createSession's provider-cache policy: only
@@ -657,6 +658,19 @@ export async function resumeSession(sessionId, preset, options = {}) {
         }
         return attached;
     }
+    const crashRecovery = recoverTurnCheckpoint(session);
+    if (crashRecovery.changed) {
+        // Resume must not expose a recovered frame that exists only in memory.
+        // Persist synchronously, then remove the sidecar; a second crash at
+        // either boundary therefore leaves at least one complete copy.
+        saveSession(session, {
+            sync: true,
+            expectedGeneration: session.generation,
+        });
+        if (crashRecovery.turnToken) {
+            clearTurnCheckpoint(sessionId, crashRecovery.turnToken);
+        }
+    }
     const oldTools = session.tools || [];
     const cached = _preparedResumes.get(sessionId);
     _preparedResumes.delete(sessionId);

package/src/runtime/agent/orchestrator/session/manager/turn-checkpoint.mjs

@@ -0,0 +1,170 @@
+import {
+    existsSync,
+    mkdirSync,
+    readFileSync,
+    unlinkSync,
+    writeFileSync,
+} from 'fs';
+import { randomBytes } from 'crypto';
+import { join } from 'path';
+import { getPluginData } from '../../config.mjs';
+import { renameWithRetrySync } from '../../../../shared/atomic-file.mjs';
+import { sanitizeContentForStoredHistory } from '../../providers/media-normalization.mjs';
+import { promptContentText } from './prompt-utils.mjs';
+import { finalizeTurnInterruptionSnapshot } from './turn-interruption.mjs';
+
+const TURN_CHECKPOINT_VERSION = 1;
+const SESSION_ID = /^[A-Za-z0-9_-]+$/;
+
+function checkpointDir() {
+    const dir = join(getPluginData(), 'turn-checkpoints');
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    return dir;
+}
+
+function turnCheckpointPath(sessionId) {
+    if (!SESSION_ID.test(String(sessionId || ''))) {
+        throw new Error(`[turn-checkpoint] invalid session id: ${JSON.stringify(sessionId)}`);
+    }
+    return join(checkpointDir(), `${sessionId}.json`);
+}
+
+function checkpointMessage(message) {
+    if (!message || typeof message !== 'object') return message;
+    const content = sanitizeContentForStoredHistory(message.content);
+    return content === message.content ? message : { ...message, content };
+}
+
+function matchingUserMessage(message, currentUserContent) {
+    return message?.role === 'user'
+        && (message.content === currentUserContent
+            || promptContentText(message.content) === promptContentText(currentUserContent));
+}
+
+export function turnMessagesForCheckpoint(messages, currentUserContent) {
+    const source = Array.isArray(messages) ? messages : [];
+    let start = -1;
+    for (let index = source.length - 1; index >= 0; index -= 1) {
+        if (matchingUserMessage(source[index], currentUserContent)) {
+            start = index;
+            break;
+        }
+    }
+    const turn = start >= 0 ? source.slice(start) : [];
+    return turn.map(checkpointMessage);
+}
+
+export function writeTurnCheckpoint(checkpoint) {
+    if (!checkpoint?.sessionId || !checkpoint?.turnToken) return false;
+    const target = turnCheckpointPath(checkpoint.sessionId);
+    const temp = `${target}.${randomBytes(6).toString('hex')}.tmp`;
+    const payload = {
+        ...checkpoint,
+        version: TURN_CHECKPOINT_VERSION,
+        currentUserContent: sanitizeContentForStoredHistory(checkpoint.currentUserContent),
+        turnMessages: (Array.isArray(checkpoint.turnMessages) ? checkpoint.turnMessages : [])
+            .map(checkpointMessage),
+        updatedAt: Date.now(),
+    };
+    try {
+        writeFileSync(temp, JSON.stringify(payload), 'utf8');
+        renameWithRetrySync(temp, target);
+        return true;
+    } catch (error) {
+        try { unlinkSync(temp); } catch {}
+        throw error;
+    }
+}
+
+export function readTurnCheckpoint(sessionId) {
+    const target = turnCheckpointPath(sessionId);
+    try {
+        const value = JSON.parse(readFileSync(target, 'utf8'));
+        if (value?.version !== TURN_CHECKPOINT_VERSION
+            || value?.sessionId !== sessionId
+            || !value?.turnToken
+            || !Array.isArray(value?.turnMessages)) {
+            return null;
+        }
+        return value;
+    } catch {
+        return null;
+    }
+}
+
+export function clearTurnCheckpoint(sessionId, turnToken = null) {
+    const target = turnCheckpointPath(sessionId);
+    if (!existsSync(target)) return true;
+    if (turnToken) {
+        const current = readTurnCheckpoint(sessionId);
+        // A token guard prevents an older turn's late terminal save from
+        // deleting the checkpoint already created by its queued follow-up.
+        if (current?.turnToken && current.turnToken !== turnToken) return false;
+    }
+    try {
+        unlinkSync(target);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+function findPersistedTurnStart(messages, currentUserContent) {
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        if (matchingUserMessage(messages[index], currentUserContent)) return index;
+    }
+    return -1;
+}
+
+/**
+ * Merge a force-killed turn checkpoint into a loaded session. The caller must
+ * durably save the mutated session before clearing the returned token.
+ */
+export function recoverTurnCheckpoint(session) {
+    if (!session?.id || session.closed === true) {
+        return { changed: false, recovered: false, turnToken: null };
+    }
+    const checkpoint = readTurnCheckpoint(session.id);
+    const marker = session.activeTurnCheckpoint;
+    if (!checkpoint) {
+        if (!marker) return { changed: false, recovered: false, turnToken: null };
+        delete session.activeTurnCheckpoint;
+        return { changed: true, recovered: false, turnToken: null };
+    }
+
+    const sessionGeneration = Number(session.generation) || 0;
+    const checkpointGeneration = Number(checkpoint.generation) || 0;
+    const markerToken = typeof marker?.turnToken === 'string' ? marker.turnToken : null;
+    const markerMatches = markerToken === checkpoint.turnToken;
+    const checkpointIsNewer = Number(checkpoint.updatedAt) > Number(session.updatedAt || 0);
+    if (checkpointGeneration !== sessionGeneration
+        || (markerToken && !markerMatches)
+        || (!markerToken && !checkpointIsNewer)) {
+        clearTurnCheckpoint(session.id, checkpoint.turnToken);
+        if (markerToken === checkpoint.turnToken) delete session.activeTurnCheckpoint;
+        return { changed: false, recovered: false, turnToken: null };
+    }
+
+    const finalized = finalizeTurnInterruptionSnapshot({
+        turnOutgoing: checkpoint.turnMessages,
+        currentUserContent: checkpoint.currentUserContent,
+        snapshot: checkpoint.interruption,
+        abortReason: 'process-crash',
+    });
+    const current = Array.isArray(session.messages) ? session.messages : [];
+    const start = findPersistedTurnStart(current, checkpoint.currentUserContent);
+    session.messages = [
+        ...(start >= 0 ? current.slice(0, start) : current),
+        ...finalized.messages,
+    ];
+    delete session.activeTurnCheckpoint;
+    delete session.providerState;
+    session.updatedAt = Date.now();
+    session.lastUsedAt = Date.now();
+    return {
+        changed: true,
+        recovered: true,
+        turnToken: checkpoint.turnToken,
+        responsePreserved: finalized.responsePreserved,
+    };
+}

package/src/runtime/agent/orchestrator/session/manager/turn-interruption.mjs

@@ -8,6 +8,8 @@ import { filterModelVisibleSessionMessages } from './message-sanitize.mjs';
 const INTERRUPT_MESSAGE = '[Request interrupted by user]';
 const INTERRUPT_MESSAGE_FOR_TOOL_USE = '[Request interrupted by user for tool use]';
 const STREAMING_INTERRUPTED_TOOL_RESULT = 'Interrupted by user';
+const PROCESS_RESTART_INTERRUPT_MESSAGE = '[Request interrupted by process restart]';
+const PROCESS_RESTART_TOOL_RESULT = 'Interrupted by process restart';
 const TOOL_USE_REJECT_RESULT = "The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). STOP what you are doing and wait for the user to tell you how to proceed.";
 
 // Abort reasons that represent an EXPLICIT user cancellation of this turn.
@@ -134,9 +136,11 @@ function finalizeInterruptedTurn({
         const executionStarted = phase === 'tools' || observed?.eagerStarted === true;
         messages.push({
             role: 'tool',
-            content: executionStarted
-                ? TOOL_USE_REJECT_RESULT
-                : STREAMING_INTERRUPTED_TOOL_RESULT,
+            content: abortReason === 'process-crash'
+                ? PROCESS_RESTART_TOOL_RESULT
+                : (executionStarted
+                    ? TOOL_USE_REJECT_RESULT
+                    : STREAMING_INTERRUPTED_TOOL_RESULT),
             toolCallId: callId,
             toolKind: 'error',
         });
@@ -149,9 +153,11 @@ function finalizeInterruptedTurn({
     if (abortReason !== 'interrupt' && abortReason !== 'provider-error') {
         pairedMessages.push({
             role: 'user',
-            content: phase === 'tools'
-                ? INTERRUPT_MESSAGE_FOR_TOOL_USE
-                : INTERRUPT_MESSAGE,
+            content: abortReason === 'process-crash'
+                ? PROCESS_RESTART_INTERRUPT_MESSAGE
+                : (phase === 'tools'
+                    ? INTERRUPT_MESSAGE_FOR_TOOL_USE
+                    : INTERRUPT_MESSAGE),
         });
     }
     return { messages: pairedMessages, responsePreserved: true, userTurnPreserved: true };
@@ -247,6 +253,19 @@ export function createTurnInterruptionTracker() {
             phase = 'tools';
             responseStarted = true;
         },
+        snapshot() {
+            return {
+                responseStarted,
+                // A reset acknowledged by the UI temporarily tombstones text.
+                // A process crash cannot complete that replacement, so retain
+                // the same visible bytes the normal error path restores.
+                partialAssistantContent: partialAssistantContent + tombstonedAssistantContent,
+                partialReasoningContent,
+                phase,
+                observedToolCalls: [...observedToolCalls.entries()],
+                observedToolResults: [...observedToolResults.entries()],
+            };
+        },
         finalize({ turnOutgoing, currentUserContent, abortReason = null }) {
             return finalizeInterruptedTurn({
                 turnOutgoing,
@@ -262,3 +281,23 @@ export function createTurnInterruptionTracker() {
         },
     };
 }
+
+export function finalizeTurnInterruptionSnapshot({
+    turnOutgoing,
+    currentUserContent,
+    snapshot,
+    abortReason = 'process-crash',
+}) {
+    const source = snapshot && typeof snapshot === 'object' ? snapshot : {};
+    return finalizeInterruptedTurn({
+        turnOutgoing,
+        currentUserContent,
+        responseStarted: source.responseStarted === true,
+        partialAssistantContent: String(source.partialAssistantContent || ''),
+        partialReasoningContent: String(source.partialReasoningContent || ''),
+        observedToolCalls: new Map(Array.isArray(source.observedToolCalls) ? source.observedToolCalls : []),
+        observedToolResults: new Map(Array.isArray(source.observedToolResults) ? source.observedToolResults : []),
+        phase: source.phase === 'tools' ? 'tools' : 'streaming',
+        abortReason,
+    });
+}

package/src/runtime/agent/orchestrator/session/store-summary-reader.mjs

@@ -173,6 +173,25 @@ function scanSessionFiles(heartbeatMtimes = sessionHeartbeatMtimes()) {
         (right.lastUsedAt || right.updatedAt || 0) - (left.lastUsedAt || left.updatedAt || 0));
 }
 
+function sessionFilesAreNewerThan(indexPath) {
+    const directory = join(dataDir(), 'sessions');
+    if (!existsSync(directory)) return false;
+    let indexMtime = 0;
+    try { indexMtime = statSync(indexPath).mtimeMs || 0; }
+    catch { return true; }
+    try {
+        for (const filename of readdirSync(directory)) {
+            if (!filename.endsWith('.json')) continue;
+            try {
+                if ((statSync(join(directory, filename)).mtimeMs || 0) > indexMtime) return true;
+            } catch { /* session disappeared after readdir */ }
+        }
+    } catch {
+        return true;
+    }
+    return false;
+}
+
 export function listStoredSessionSummaries(options = {}) {
     const heartbeatMtimes = sessionHeartbeatMtimes();
     if (options.refreshFromStorage === true) return scanSessionFiles(heartbeatMtimes);
@@ -185,6 +204,13 @@ export function listStoredSessionSummaries(options = {}) {
                 .filter((row) => row && isLeadVisibleRow(row))
                 .sort((left, right) =>
                     (right.lastUsedAt || right.updatedAt || 0) - (left.lastUsedAt || left.updatedAt || 0));
+            // A crashed/non-blocking sidecar writer can leave a valid but old,
+            // non-empty index indefinitely. Detect only newer session JSONs
+            // (heartbeat churn does not count), then recover read-only from the
+            // authoritative files without trying to rewrite the stuck index.
+            if (options.rebuildIfMissing !== false && sessionFilesAreNewerThan(indexPath)) {
+                return scanSessionFiles(heartbeatMtimes);
+            }
             if (rows.length > 0 || options.rebuildIfMissing === false) return rows;
         }
     } catch {

package/src/runtime/agent/orchestrator/session/token-bpe.mjs

@@ -0,0 +1,42 @@
+// Chunked o200k BPE encode-count, shared by the main thread (context-utils)
+// and the token-count worker. BPE merge cost is quadratic in WORD length, not
+// text length: a degenerate single-word run ('p'.repeat(250k), base64/minified
+// blobs) forms one giant pat_str word and encode() spins for minutes while the
+// event loop is blocked. Encoding fixed-size slices caps the worst-case word at
+// the chunk size, so cost stays linear. Chunk cuts snap back to the nearest
+// whitespace so the next slice starts at a natural ` word` boundary — o200k
+// tokenizes that identically to the unsliced text, keeping estimates EXACT for
+// prose. Only a whitespace-free degenerate run falls back to a hard cut
+// (±1 token per boundary). Hard cuts avoid splitting a surrogate pair so
+// sliced emoji/CJK-ext code points still encode cleanly.
+const BPE_ENCODE_CHUNK_CHARS = 4_096;
+const BPE_CHUNK_BOUNDARY_SCAN = 512;
+
+export function bpeEncodeCount(enc, s) {
+    if (s.length <= BPE_ENCODE_CHUNK_CHARS) return enc.encode(s, undefined, []).length;
+    let total = 0;
+    let i = 0;
+    while (i < s.length) {
+        let end = Math.min(s.length, i + BPE_ENCODE_CHUNK_CHARS);
+        if (end < s.length) {
+            // Prefer cutting BEFORE a whitespace run: the next chunk then
+            // starts with ` word`, which o200k merges exactly as it would
+            // mid-text. Scan a bounded window so degenerate inputs stay O(1).
+            let ws = -1;
+            const scanFloor = Math.max(i + 1, end - BPE_CHUNK_BOUNDARY_SCAN);
+            for (let j = end - 1; j >= scanFloor; j -= 1) {
+                const c = s.charCodeAt(j);
+                if (c === 0x20 || c === 0x0A || c === 0x0D || c === 0x09) { ws = j; break; }
+            }
+            if (ws > i) {
+                end = ws; // next chunk starts at the whitespace
+            } else {
+                const last = s.charCodeAt(end - 1);
+                if (last >= 0xD800 && last <= 0xDBFF) end += 1;
+            }
+        }
+        total += enc.encode(s.slice(i, end), undefined, []).length;
+        i = end;
+    }
+    return total;
+}

package/src/runtime/agent/orchestrator/session/token-native.mjs

@@ -0,0 +1,186 @@
+// Native mixdog-token client: persistent stdio server (transport lifecycle
+// modeled on tools/patch/native-server.mjs) that serves precise o200k BPE
+// counts ~5-12x faster than the in-process tiktoken WASM worker.
+//
+// Wire format: length-prefixed BINARY frames (raw utf8 payload, no JSON
+// escape/parse on either side — that overhead dominated once the encoder
+// went linear-time):
+//   request  : u8 op (1=ping, 2=count) | u32le id | u32le byteLen | payload
+//   response : u8 op                   | u32le id | u64le count
+// A stale JSON-only server never answers a binary ping, so the ready probe
+// times out and this module degrades to the WASM worker path.
+//
+// Strictly a best-effort accelerator behind context-utils' async count path:
+// unavailable binary / dead server / timeout all resolve `null`, and the
+// caller falls back to the JS worker thread. Kill switch:
+// MIXDOG_TOKEN_NATIVE=0 (mode `auto` is the default; MIXDOG_TOKEN_NATIVE_BIN
+// overrides binary resolution).
+import { existsSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { resolve as pathResolve, dirname as pathDirname, join as pathJoin } from 'node:path';
+import { startChildGuardian } from '../../../shared/child-guardian.mjs';
+import { getPluginData } from '../config.mjs';
+import { ensureTokenBinary, findCachedTokenBinary } from '../tools/token-binary-fetcher.mjs';
+
+const PLUGIN_ROOT = process.env.MIXDOG_ROOT
+    || pathResolve(pathDirname(fileURLToPath(import.meta.url)), '../../../../..');
+const BIN_NAME = process.platform === 'win32' ? 'mixdog-token.exe' : 'mixdog-token';
+const LOCAL_BIN = pathJoin(PLUGIN_ROOT, 'native/mixdog-token/target/release', BIN_NAME);
+const READY_TIMEOUT_MS = 10_000;
+const REQUEST_TIMEOUT_MS = 30_000;
+const OP_PING = 1;
+const OP_COUNT = 2;
+const RESPONSE_FRAME_BYTES = 13;
+const UNKNOWN_OP_SENTINEL = 0xFFFF_FFFF_FFFF_FFFFn;
+const EMPTY_PAYLOAD = Buffer.alloc(0);
+
+function nativeTokenMode() {
+    return String(process.env.MIXDOG_TOKEN_NATIVE || 'auto').toLowerCase();
+}
+
+function nativeTokenModeEnabled() {
+    return !/^(0|false|no|off|js)$/i.test(nativeTokenMode());
+}
+
+let _binPath; // undefined = not resolved, null = none found
+function _resolveBinary() {
+    if (_binPath !== undefined) return _binPath;
+    const candidates = [
+        String(process.env.MIXDOG_TOKEN_NATIVE_BIN || '').trim() || null,
+        LOCAL_BIN,
+    ].filter(Boolean);
+    _binPath = candidates.find((candidate) => {
+        try { return existsSync(candidate); } catch { return false; }
+    }) || null;
+    if (!_binPath) {
+        // Release-supply cache (sha256-verified against the bundled manifest).
+        try { _binPath = findCachedTokenBinary(getPluginData()) || null; } catch { _binPath = null; }
+    }
+    return _binPath;
+}
+
+let _server = null; // { child, pending: Map, seq, ready }  null after hard failure
+let _serverFailed = false;
+
+function _dropServer(error) {
+    const server = _server;
+    _server = null;
+    if (!server) return;
+    const reason = error instanceof Error ? error : new Error(String(error || 'mixdog-token server closed'));
+    for (const [, entry] of server.pending) {
+        clearTimeout(entry.timer);
+        entry.resolve(null);
+        void reason;
+    }
+    server.pending.clear();
+    try { server.child.kill(); } catch { /* already down */ }
+}
+
+function _ensureServer() {
+    if (_server || _serverFailed || !nativeTokenModeEnabled()) return _server;
+    const bin = _resolveBinary();
+    if (!bin) { _serverFailed = true; return null; }
+    let child;
+    try {
+        child = spawn(bin, [], { stdio: ['pipe', 'pipe', 'ignore'], windowsHide: true });
+    } catch {
+        _serverFailed = true;
+        return null;
+    }
+    const server = { child, pending: new Map(), seq: 0, ready: null };
+    let inbox = EMPTY_PAYLOAD;
+    child.stdout.on('data', (chunk) => {
+        inbox = inbox.length ? Buffer.concat([inbox, chunk]) : chunk;
+        while (inbox.length >= RESPONSE_FRAME_BYTES) {
+            const id = inbox.readUInt32LE(1);
+            const count = inbox.readBigUInt64LE(5);
+            inbox = inbox.subarray(RESPONSE_FRAME_BYTES);
+            const entry = server.pending.get(id);
+            if (!entry) continue;
+            server.pending.delete(id);
+            clearTimeout(entry.timer);
+            entry.resolve(count === UNKNOWN_OP_SENTINEL ? null : Number(count));
+        }
+    });
+    child.on('error', () => { _serverFailed = true; _dropServer('spawn error'); });
+    child.on('exit', () => { _dropServer('exited'); });
+    // Best-effort accelerator: never keeps the process alive. Unref the
+    // stdio PIPES too — child.unref() alone leaves the socket handles ref'd,
+    // which kept short-lived hosts (node --test suites) from ever exiting.
+    child.unref();
+    child.stdin?.unref?.();
+    child.stdout?.unref?.();
+    child.stdin?.on?.('error', () => { /* EPIPE on teardown */ });
+    try {
+        startChildGuardian({ childPid: child.pid, label: 'mixdog-token', orphanGraceMs: 8000, forceGraceMs: 3000 });
+    } catch { /* guardian best-effort */ }
+    server.ready = _request(server, OP_PING, null, READY_TIMEOUT_MS).then((count) => count !== null);
+    _server = server;
+    return server;
+}
+
+function _request(server, op, text, timeoutMs = REQUEST_TIMEOUT_MS) {
+    return new Promise((resolve) => {
+        const id = ++server.seq;
+        const timer = setTimeout(() => {
+            server.pending.delete(id);
+            resolve(null);
+        }, timeoutMs);
+        timer.unref?.();
+        server.pending.set(id, { resolve, timer });
+        try {
+            const payload = text ? Buffer.from(text, 'utf8') : EMPTY_PAYLOAD;
+            const header = Buffer.allocUnsafe(9);
+            header[0] = op;
+            header.writeUInt32LE(id >>> 0, 1);
+            header.writeUInt32LE(payload.length >>> 0, 5);
+            const stdin = server.child.stdin;
+            stdin.cork();
+            stdin.write(header);
+            if (payload.length) stdin.write(payload);
+            stdin.uncork();
+        } catch {
+            server.pending.delete(id);
+            clearTimeout(timer);
+            resolve(null);
+        }
+    });
+}
+
+/** True when the native counter can be attempted (mode on + binary present). */
+export function nativeTokenCounterEnabled() {
+    return nativeTokenModeEnabled() && !_serverFailed && Boolean(_resolveBinary());
+}
+
+/** Precise o200k count via the native server; null on any unavailability. */
+export async function countTokensNative(text) {
+    const server = _ensureServer();
+    if (!server) return null;
+    const ready = await server.ready;
+    if (!ready) { _serverFailed = true; _dropServer('ready failed'); return null; }
+    const count = await _request(server, OP_COUNT, String(text ?? ''));
+    return Number.isFinite(count) && count >= 0 ? count : null;
+}
+
+let _fetchAttempted = false;
+
+/** Boot prewarm: spawn the server + build the encoder off the first estimate.
+ *  With no local/env/cached binary, kick ONE background manifest fetch; on
+ *  success the resolution cache resets so the next estimate adopts it. */
+export function prewarmNativeTokenCounter() {
+    const server = _ensureServer();
+    if (!server) {
+        if (!_fetchAttempted && nativeTokenModeEnabled() && !_resolveBinary()) {
+            _fetchAttempted = true;
+            void ensureTokenBinary(getPluginData()).then((path) => {
+                if (!path) return;
+                _binPath = undefined;
+                _serverFailed = false;
+            }).catch(() => { /* soft degrade — WASM worker path remains */ });
+        }
+        return false;
+    }
+    server.ready?.catch?.(() => {});
+    return true;
+}

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

@@ -32,6 +32,7 @@ import { crossTurnSignature, crossTurnDedupStub, isEditProgressTool } from './lo
 import {
     getToolKind,
     isEagerDispatchable,
+    isParallelDispatchable,
     isToolCallDedupEligible,
     parseNativeToolSearchPayload,
 } from './loop/tool-helpers.mjs';
@@ -181,7 +182,11 @@ export async function processToolBatch(ctx) {
             // re-issue it cleanly in a new turn instead of copying back a
             // `[mixdog compacted …]` placeholder. Emits a matching is_error
             // tool_result so the assistant tool_use is not orphaned.
-            if (_orderedMutationFailed && _isOrderedGateSkippable(call.name)) {
+            // Full-parallel caveat: a call that ALREADY started (pending eager
+            // promise) cannot be "skipped" — its side effects are running, so
+            // its real result must be consumed below. The gate only skips
+            // calls that have not started (apply_patch never starts eagerly).
+            if (_orderedMutationFailed && _isOrderedGateSkippable(call.name) && !pending.has(call.id)) {
                 if (call?.id) restoreToolCallBodyForId(assistantTurnMsg, calls, call.id);
                 pushToolResultMessage({
                     role: 'tool',
@@ -252,13 +257,18 @@ export async function processToolBatch(ctx) {
                     _executeOk = true;
                 } else {
                 // Fallback for providers that don't stream tool calls early:
-                // execute a contiguous read-only run in parallel, but never
-                // cross a write/bash/MCP boundary that may change state.
-                if (isEagerDispatchable(call.name, tools)) {
+                // start the whole remaining batch in parallel (full-parallel
+                // policy; only apply_patch stays in this serial body).
+                if (isParallelDispatchable(call.name)) {
                     startEagerRun(calls, callIndex, _duplicateCallIds);
                 }
                 let eager = pending.get(call.id);
-                if (eager !== undefined && eager.mutationEpoch < epoch.mutation) {
+                // Post-mutation invalidation applies ONLY to read-only results:
+                // a read that raced an apply_patch re-executes for fresh
+                // content. Non-read-only parallel calls (shell/MCP/...) already
+                // ran — their side effects are real, so their results are
+                // consumed as-is and NEVER re-executed.
+                if (eager !== undefined && eager.mutationEpoch < epoch.mutation && isEagerDispatchable(call.name, tools)) {
                     pending.delete(call.id);
                     eager = undefined;
                 }

package/src/runtime/agent/orchestrator/tools/builtin/bash-tool.mjs

@@ -39,6 +39,7 @@ import {
     resolveExecutionMode,
 } from '../../../../shared/background-tasks.mjs';
 import { resolveShellFor } from './shell-runtime.mjs';
+import { prewarmPwshStandbyPool } from '../lib/pwsh-standby-pool.mjs';
 import { smartMiddleTruncate } from './shell-output.mjs';
 import { normalizeOutputPath } from './path-utils.mjs';
 import { normalizeErrorMessage } from './path-diagnostics.mjs';
@@ -58,6 +59,25 @@ import { resourceAdmission } from '../../../../shared/resource-admission.mjs';
 export function _captureTrackedMtimes(_scope) {
     return new Map();
 }
+
+/**
+ * Boot prewarm: build the EXACT spawn env/spec a real shell call uses and warm
+ * the pwsh standby pool with it, so the first shell call of a session skips
+ * the pwsh startup cost. No-op off Windows / non-pwsh. Best-effort.
+ */
+export function prewarmShellStandbys() {
+    try {
+        const spec = resolveShellFor('default');
+        if (!spec || spec.shellType !== 'powershell') return false;
+        const env = { ...process.env, LANG: 'C.UTF-8', LC_ALL: 'C.UTF-8' };
+        scrubProviderSecrets(env);
+        scrubLoaderVars(env);
+        scrubRuntimeRootVars(env);
+        return prewarmPwshStandbyPool({ shell: spec.shell, shellArgs: spec.shellArgs, env }) === true;
+    } catch {
+        return false;
+    }
+}
 export function _trackedDriftNoteAfter(_scope, _pre) {
     return '';
 }

package/src/runtime/agent/orchestrator/tools/builtin/builtin-tools.mjs

@@ -74,7 +74,7 @@ export const BUILTIN_TOOLS = [
         name: 'shell',
         title: 'Mixdog Shell',
         annotations: { title: 'Mixdog Shell', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true, compressible: true },
-        description: `Run programs or change system state; not for reading, listing or searching. Shell/write calls are serial.${_shellSyntaxCheat} ${TOOL_ASYNC_EXECUTION_CONTRACT}`,
+        description: `Run programs or change system state; not for reading, listing or searching. Independent calls in one turn run in parallel; order-dependent commands go in one command or later turns.${_shellSyntaxCheat} ${TOOL_ASYNC_EXECUTION_CONTRACT}`,
         inputSchema: {
             type: 'object',
             properties: {

package/src/runtime/agent/orchestrator/tools/builtin/shell-job-process.mjs

@@ -117,6 +117,30 @@ function normalizeWindowsSnapshot(snapshot) {
     return rows;
 }
 
+// Standby-pool support: does `pid` currently own live descendant processes?
+// FRESH snapshot on purpose — the 750ms cache could miss a just-spawned
+// grandchild and wrongly certify a polluted standby shell as clean. Unknown
+// snapshots answer true (conservative: the pool discards instead of reusing).
+export async function windowsPidHasDescendants(pid, { spawnFn = spawn } = {}) {
+    if (!Number.isFinite(pid) || pid <= 0) return false;
+    if (process.platform !== 'win32') return false;
+    let rows = null;
+    try { rows = await windowsProcessSnapshot({ fresh: true, spawnFn }); } catch { rows = null; }
+    if (!rows) return true;
+    const owned = new Set([pid]);
+    let discovered = true;
+    while (discovered) {
+        discovered = false;
+        for (const row of rows.values()) {
+            if (!owned.has(row.pid) && owned.has(row.parentPid)) {
+                owned.add(row.pid);
+                discovered = true;
+            }
+        }
+    }
+    return owned.size > 1;
+}
+
 // Invoke onQuiescent exactly once, synchronously when already quiescent or
 // after positive liveness probes stop observing the owned tree/group.
 export function trackProcessTreeQuiescence(