mixdog 0.9.85 → 0.9.86

package/src/runtime/agent/orchestrator/session/context-utils.mjs

@@ -1,6 +1,12 @@
 import { isOffloadedToolResultText } from './tool-result-offload.mjs';
 import { createHash } from 'node:crypto';
 import { createRequire } from 'node:module';
+import { bpeEncodeCount } from './token-bpe.mjs';
+import {
+    countTokensNative,
+    nativeTokenCounterEnabled,
+    prewarmNativeTokenCounter,
+} from './token-native.mjs';
 import {
     isFinalizedProviderRequestTools,
     providerNativeToolPrefixCount,
@@ -78,48 +84,49 @@ function bpeEncoder() {
 const TOKEN_COUNT_CACHE_MIN_CHARS = 512;
 const TOKEN_COUNT_CACHE_MAX_ENTRIES = 1_024;
 const tokenCountCache = new Map();
-// 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
-// (observed live via inspector: compact-smoke hung inside tiktoken encode).
-// 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
-// (compact-smoke asserts est === real o200k count). Only a whitespace-free
-// degenerate run falls back to a hard cut (±1 token per boundary, safely
-// inside the estimate's safety multiplier). 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;
-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;
+
+function _tokenCacheSet(key, count) {
+    if (tokenCountCache.size >= TOKEN_COUNT_CACHE_MAX_ENTRIES) {
+        tokenCountCache.delete(tokenCountCache.keys().next().value);
     }
-    return total;
+    tokenCountCache.set(key, count);
+}
+
+// ── Native offload for large encodes ────────────────────────────────────────
+// estimateTokens is a SYNC api polled from context gauges and compaction
+// pressure checks. A large fresh string (big tool result) costs tens of ms to
+// encode; under many parallel agents those encodes serialize the one shared
+// event loop. Strings at/above BPE_ASYNC_THRESHOLD_CHARS with no cache entry
+// are therefore counted by the mixdog-token native server (SINGLE offload
+// engine — no worker-thread fallback by design): the caller immediately gets
+// the conservative legacy heuristic, the precise count lands in
+// tokenCountCache, and the next poll returns the exact value. Smaller
+// strings (the vast majority) keep exact synchronous counting. With the
+// native server unavailable (MIXDOG_TOKEN_NATIVE=0, missing binary before
+// the first token-v release), large strings encode synchronously — exact,
+// pre-offload semantics.
+const BPE_ASYNC_THRESHOLD_CHARS = 32_768;
+const _nativePendingKeys = new Set();
+
+// Offload one large count to the native mixdog-token server. Returns false
+// when the native path cannot be attempted (caller encodes synchronously). A
+// mid-flight failure just drops the pending key: the next poll re-evaluates
+// and encodes synchronously if the server is really gone.
+function _offloadTokenCountNative(key, s) {
+    if (!nativeTokenCounterEnabled()) return false;
+    _nativePendingKeys.add(key);
+    countTokensNative(s).then((count) => {
+        if (!_nativePendingKeys.delete(key)) return;
+        if (Number.isFinite(count) && count >= 0) _tokenCacheSet(key, count);
+    }).catch(() => {
+        _nativePendingKeys.delete(key);
+    });
+    return true;
 }
+
+// Returns the exact count, or null when the string was handed to the native
+// server
+// (caller falls back to the legacy heuristic until the precise count lands).
 function bpeTokenCount(enc, s) {
     if (s.length < TOKEN_COUNT_CACHE_MIN_CHARS) return bpeEncodeCount(enc, s);
     const key = `${s.length}:${createHash('sha1').update(s).digest('base64')}`;
@@ -129,11 +136,12 @@ function bpeTokenCount(enc, s) {
         tokenCountCache.set(key, hit);
         return hit;
     }
-    const count = bpeEncodeCount(enc, s);
-    if (tokenCountCache.size >= TOKEN_COUNT_CACHE_MAX_ENTRIES) {
-        tokenCountCache.delete(tokenCountCache.keys().next().value);
+    if (s.length >= BPE_ASYNC_THRESHOLD_CHARS) {
+        if (!_nativePendingKeys.has(key)) _offloadTokenCountNative(key, s);
+        if (_nativePendingKeys.has(key)) return null;
     }
-    tokenCountCache.set(key, count);
+    const count = bpeEncodeCount(enc, s);
+    _tokenCacheSet(key, count);
     return count;
 }
 
@@ -203,12 +211,32 @@ export function estimateTokens(text) {
     const enc = bpeEncoder();
     if (enc) {
         try {
-            return Math.ceil(bpeTokenCount(enc, s) * TOKEN_ESTIMATE_SAFETY_MULTIPLIER);
+            const count = bpeTokenCount(enc, s);
+            // null = precise count is being computed in the worker; return the
+            // conservative heuristic until it lands in the cache.
+            if (count !== null) return Math.ceil(count * TOKEN_ESTIMATE_SAFETY_MULTIPLIER);
         } catch { /* corrupt input — degrade to the heuristic below */ }
     }
     return legacyEstimateTokens(s);
 }
 
+/**
+ * Boot prewarm: load the o200k encoder (WASM init), run one small encode
+ * (JIT), and spawn the token-count worker so the first large transcript
+ * estimate of a session neither blocks on WASM init nor waits for the
+ * worker spawn. Best-effort; returns true when the encoder is live.
+ */
+export function prewarmTokenEstimator() {
+    const enc = bpeEncoder();
+    if (enc) {
+        try { bpeEncodeCount(enc, 'mixdog tokenizer warmup — 워밍업 텍스트 0123456789'); } catch { /* best-effort */ }
+    }
+    // Native server boots its encoder (~100-300ms) off the first estimate;
+    // with no binary yet, this also kicks the one-shot release fetch.
+    try { prewarmNativeTokenCounter(); } catch { /* best-effort */ }
+    return !!enc;
+}
+
 // Legacy conservative Unicode-aware estimate (fallback only). Iterates by
 // code point, takes the max of the weighted sum and the chars/4 ASCII floor,
 // then applies the safety multiplier.

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

@@ -1,9 +1,10 @@
 // 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 tool calls start executing the instant the
-// provider streams a tool_use event so execution overlaps the remaining SSE
-// parse; writes/unknown tools wait for the serial batch loop. Behavior
-// identical to the inline closures it replaced.
+// the mutation epoch. FULL-PARALLEL policy: every tool call starts executing
+// the instant the provider streams its tool_use event (or at batch start),
+// shell/MCP/writes included — the model owns ordering by splitting dependent
+// work into separate turns. Only apply_patch (ordered mutation) waits for the
+// serial batch loop.
 import { normalizeToolEnvelope } from './tool-envelope.mjs';
 import { isInvalidToolArgsMarker } from '../providers/openai-compat-stream.mjs';
 import { _intraTurnSig, _isReadTool, _isScopedCacheableTool, _stripMcpPrefix } from './loop/tool-classify.mjs';
@@ -11,7 +12,7 @@ import { tryReadCached, tryScopedToolCached } from './read-dedup.mjs';
 import { preDispatchDenyForSession } from './loop/pre-dispatch-deny.mjs';
 import { executeTool } from './loop/tool-exec.mjs';
 import { crossTurnSignature } from './loop/completion-guards.mjs';
-import { getToolKind, isEagerDispatchable, isToolCallDedupEligible } from './loop/tool-helpers.mjs';
+import { getToolKind, isParallelDispatchable, isToolCallDedupEligible } from './loop/tool-helpers.mjs';
 
 export function createEagerDispatcher({
     tools, cwd, sessionId, sessionRef, signal, opts,
@@ -40,7 +41,7 @@ export function createEagerDispatcher({
         const _eagerInFlightSigs = new Map();
         const epoch = { mutation: 0 };
         const startEagerTool = (call) => {
-            if (!call?.id || pending.has(call.id) || !isEagerDispatchable(call.name, tools)) return null;
+            if (!call?.id || pending.has(call.id) || !isParallelDispatchable(call.name)) return null;
             // Never eager-execute a call whose arguments failed to parse
             // (invalid-args marker). It has no usable arguments; the serial
             // body handles it via the invalid-args feedback path.
@@ -157,26 +158,22 @@ export function createEagerDispatcher({
         const startEagerRun = (calls, startIndex, dupSet) => {
             for (let j = startIndex; j < calls.length; j += 1) {
                 const call = calls[j];
-                if (!call?.id || !isEagerDispatchable(call.name, tools)) break;
+                // Full-parallel: only the ordered mutation (apply_patch) is
+                // skipped — it executes in the serial batch body. No barrier:
+                // later calls keep starting in parallel past it.
+                if (!call?.id || !isParallelDispatchable(call.name)) continue;
                 if (dupSet && dupSet.has(call.id)) continue;
-                // A null return here is NOT a state barrier: the loop above
-                // already breaks at the first non-eager (mutation/bash/unknown)
-                // tool, so every call reached here is read-only. A null means a
+                // 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
                 // short-circuit. `continue` (not `break`) so a stub in the
-                // middle of a contiguous eager run does not stop LATER
-                // independent eager reads from starting early.
+                // middle of the run does not stop LATER independent calls from
+                // starting early.
                 if (!startEagerTool(call) && !pending.has(call.id)) continue;
             }
         };
-        let _streamEagerBlocked = false;
         const onToolCall = (call) => {
-            if (!isEagerDispatchable(call?.name, tools)) {
-                _streamEagerBlocked = true;
-                return;
-            }
-            if (_streamEagerBlocked) return;
+            if (!isParallelDispatchable(call?.name)) return;
             startEagerTool(call);
         };
     return { pending, epoch, startEagerTool, startEagerRun, onToolCall };

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

@@ -42,7 +42,7 @@ export function agentContextOverflowError({ stage, sessionId, sessionRef, model,
 // etc.). This is NOT "latest turn cannot fit the context budget" — masking it
 // as AGENT_CONTEXT_OVERFLOW hides the real failure and misroutes downstream
 // overflow handling. Genuine provider send overflow keeps AgentContextOverflowError.
-export class AgentCompactFailedError extends Error {
+class AgentCompactFailedError extends Error {
     constructor({ stage, sessionId, provider, model }, cause) {
         const target = [provider, model].filter(Boolean).join('/') || 'target model';
         const causeMsg = cause && cause.message ? `: ${cause.message}` : '';

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

@@ -12,6 +12,7 @@ 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
@@ -40,6 +41,18 @@ 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.
+export function isParallelDispatchable(name) {
+    return typeof name === 'string' && name.length > 0 && !_isMutationTool(name);
+}
+
 // Read-only is necessary but not sufficient for result deduplication. Loader
 // calls mutate the active session tool surface and must execute on every
 // explicit invocation so repeats can truthfully report `alreadyActive`.

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

@@ -3,10 +3,10 @@
 // mutex-guarded turn loop (askSession) plus the abort-aware call wrapper
 // (_api_call_with_interrupt). Behavior-preserving move — every runtime
 // helper it used in manager.mjs is now imported from its split module.
-import { createHash } from 'crypto';
+import { createHash, randomUUID } from 'crypto';
 import { getProvider } from '../../providers/registry.mjs';
 import { normalizeCompactType, DEFAULT_COMPACT_TYPE } from '../compact.mjs';
-import { loadSession, saveSessionAsync, saveSessionAsyncDeferred, readSessionLifecycleFromDisk } from '../store.mjs';
+import { loadSession, saveSession, saveSessionAsync, saveSessionAsyncDeferred, readSessionLifecycleFromDisk } from '../store.mjs';
 import { createAbortController } from '../../../../shared/abort-controller.mjs';
 import { logLlmCall } from '../../../../shared/llm/usage-log.mjs';
 import { appendAgentTrace } from '../../agent-trace.mjs';
@@ -56,6 +56,12 @@ import {
     persistCompactedOutgoingAfterAskFailure,
 } from './message-sanitize.mjs';
 import { createTurnInterruptionTracker } from './turn-interruption.mjs';
+import {
+    clearTurnCheckpoint,
+    recoverTurnCheckpoint,
+    turnMessagesForCheckpoint,
+    writeTurnCheckpoint,
+} from './turn-checkpoint.mjs';
 import { _getAgentLoop } from './runtime-loaders.mjs';
 import { getAgentRuntimeSync } from './agent-runtime-singleton.mjs';
 import { recordProviderContextBaseline } from '../loop/compact-policy.mjs';
@@ -208,6 +214,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
     // Hoisted so the outer finally (which runs once after the whole turn loop)
     // can compare against the last turn's generation.
     let askGeneration = 0;
+    let _crashRecoveryChecked = false;
     try {
       // Turn loop (pendingMessages pattern): run the current prompt, then drain
       // any `agent type=send` messages that were queued while this turn was in
@@ -262,6 +269,17 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
         if (preSession.closed === true) {
             throw new SessionClosedError(sessionId, 'session already closed');
         }
+        if (!_crashRecoveryChecked) {
+            _crashRecoveryChecked = true;
+            const recovery = recoverTurnCheckpoint(preSession);
+            if (recovery.changed) {
+                saveSession(preSession, {
+                    sync: true,
+                    expectedGeneration: preSession.generation,
+                });
+                if (recovery.turnToken) clearTurnCheckpoint(sessionId, recovery.turnToken);
+            }
+        }
         // A prior crash/partial-save during compaction may have pinned
         // compaction.lastStage='compacting'. This ask is starting fresh, so
         // recover the stale transient stage before the loop's pre-send compact
@@ -306,11 +324,62 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
         let cancelledUserTurnContent = '';
         let _turnOutgoing = null;
         const _turnInterruption = createTurnInterruptionTracker();
+        const _turnCheckpointToken = randomUUID();
+        const _turnCheckpointStartedAt = Date.now();
+        const _TURN_CHECKPOINT_THROTTLE_MS = 150;
+        let _turnCheckpointTimer = null;
+        let _turnCheckpointStopped = false;
+        let _turnCheckpointLastAt = 0;
+        let _turnCheckpointWarned = false;
+        const _flushTurnCheckpoint = () => {
+            if (_turnCheckpointStopped || !_turnOutgoing || !cancelledUserTurnContent) return false;
+            try {
+                const written = writeTurnCheckpoint({
+                    sessionId,
+                    generation: askGeneration,
+                    turnToken: _turnCheckpointToken,
+                    startedAt: _turnCheckpointStartedAt,
+                    currentUserContent: cancelledUserTurnContent,
+                    turnMessages: turnMessagesForCheckpoint(_turnOutgoing, cancelledUserTurnContent),
+                    interruption: _turnInterruption.snapshot(),
+                });
+                if (written) _turnCheckpointLastAt = Date.now();
+                return written;
+            } catch (error) {
+                if (!_turnCheckpointWarned) {
+                    _turnCheckpointWarned = true;
+                    try { process.stderr.write(`[turn-checkpoint] write failed session=${sessionId}: ${error?.message || error}\n`); } catch {}
+                }
+                return false;
+            }
+        };
+        const _scheduleTurnCheckpoint = (immediate = false) => {
+            if (_turnCheckpointStopped || !_turnOutgoing) return;
+            if (immediate || Date.now() - _turnCheckpointLastAt >= _TURN_CHECKPOINT_THROTTLE_MS) {
+                if (_turnCheckpointTimer) clearTimeout(_turnCheckpointTimer);
+                _turnCheckpointTimer = null;
+                _flushTurnCheckpoint();
+                return;
+            }
+            if (_turnCheckpointTimer) return;
+            const waitMs = Math.max(1, _TURN_CHECKPOINT_THROTTLE_MS - (Date.now() - _turnCheckpointLastAt));
+            _turnCheckpointTimer = setTimeout(() => {
+                _turnCheckpointTimer = null;
+                _flushTurnCheckpoint();
+            }, waitMs);
+            _turnCheckpointTimer.unref?.();
+        };
+        const _stopTurnCheckpoint = () => {
+            _turnCheckpointStopped = true;
+            if (_turnCheckpointTimer) clearTimeout(_turnCheckpointTimer);
+            _turnCheckpointTimer = null;
+        };
         const _sessionStartMetaInjectedBeforeTurn = preSession.sessionStartMetaInjected === true;
         let _interruptionSnapshot = null;
         const _prepareCloseSnapshot = (abortReason) => {
             if (_interruptionSnapshot) return _interruptionSnapshot;
             if (!activeSession) return null;
+            _stopTurnCheckpoint();
             activeSession.liveTurnMessages = null;
             _turnInterruption.restoreTombstonedText();
             const finalized = _turnInterruption.finalize({
@@ -319,6 +388,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                 abortReason,
             });
             activeSession.messages = finalized.messages;
+            delete activeSession.activeTurnCheckpoint;
             if (!finalized.responsePreserved) {
                 if (finalized.userTurnPreserved) {
                     // A non-user detach keeps the provisional prompt but makes
@@ -455,6 +525,15 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             // user turn is introduced.
             session.messages = filterModelVisibleSessionMessages(outgoing);
             session.liveTurnMessages = outgoing;
+            session.activeTurnCheckpoint = {
+                version: 1,
+                turnToken: _turnCheckpointToken,
+                startedAt: _turnCheckpointStartedAt,
+            };
+            // The sidecar lands synchronously before provider execution. Even
+            // if the async canonical-session preflight save has not reached its
+            // worker when the process is killed, recovery still has the prompt.
+            _scheduleTurnCheckpoint(true);
             saveSessionAsync(session, { expectedGeneration: askGeneration }).catch((err) => {
                 try { process.stderr.write(`[session] preflight user-turn save failed: ${err?.message || err}\n`); } catch {}
             });
@@ -488,6 +567,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             const agentLoop = await _getAgentLoop();
             const _trackTextDelta = (chunk) => {
                 _turnInterruption.recordTextDelta(chunk);
+                _scheduleTurnCheckpoint();
                 if (typeof askOpts?.onTextDelta === 'function') askOpts.onTextDelta(chunk);
             };
             const _trackTextReset = async (detail) => {
@@ -504,23 +584,28 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                 }
                 if (!acknowledged) return false;
                 _turnInterruption.tombstoneText(detail?.chars);
+                _scheduleTurnCheckpoint(true);
                 return true;
             };
             const _trackReasoningDelta = (chunk) => {
                 _turnInterruption.recordReasoningDelta(chunk);
+                _scheduleTurnCheckpoint();
                 if (typeof askOpts?.onReasoningDelta === 'function') askOpts.onReasoningDelta(chunk);
             };
             const _trackAssistantText = (text) => {
                 _turnInterruption.recordAssistantText(text);
+                _scheduleTurnCheckpoint(true);
                 if (typeof askOpts?.onAssistantText === 'function') askOpts.onAssistantText(text);
             };
             const _trackedOnToolCall = async (iteration, calls) => {
                 _turnInterruption.recordToolCalls(calls);
+                _scheduleTurnCheckpoint(true);
                 if (typeof onToolCall === 'function') return await onToolCall(iteration, calls);
                 return undefined;
             };
             const _trackToolResult = (message) => {
                 _turnInterruption.recordToolResult(message);
+                _scheduleTurnCheckpoint(true);
                 if (typeof askOpts?.onToolResult === 'function') askOpts.onToolResult(message);
             };
             const priorToolApprovalHook = session.toolApprovalHook;
@@ -539,10 +624,22 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                     onReasoningDelta: _trackReasoningDelta,
                     onAssistantText: _trackAssistantText,
                     takeAssistantTranscriptMetadata: _takeAssistantTranscriptMetadata,
-                    onAssistantMessageCommitted: () => _turnInterruption.markAssistantMessageCommitted(),
-                    onAssistantToolCallObserved: (call, detail) => _turnInterruption.recordToolCalls([call], detail),
-                    onProviderSendStarted: () => _turnInterruption.markProviderSendStarted(),
-                    onToolPhaseStarted: () => _turnInterruption.markToolPhaseStarted(),
+                    onAssistantMessageCommitted: () => {
+                        _turnInterruption.markAssistantMessageCommitted();
+                        _scheduleTurnCheckpoint(true);
+                    },
+                    onAssistantToolCallObserved: (call, detail) => {
+                        _turnInterruption.recordToolCalls([call], detail);
+                        _scheduleTurnCheckpoint(true);
+                    },
+                    onProviderSendStarted: () => {
+                        _turnInterruption.markProviderSendStarted();
+                        _scheduleTurnCheckpoint(true);
+                    },
+                    onToolPhaseStarted: () => {
+                        _turnInterruption.markToolPhaseStarted();
+                        _scheduleTurnCheckpoint(true);
+                    },
                     onUsageDelta: (d) => {
                         persistIterationMetrics(d).catch(() => {});
                         // provider_send usage arrives before agentLoop appends
@@ -565,7 +662,10 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                     },
                     onToolResult: _trackToolResult,
                     onToolApproval: typeof askOpts?.onToolApproval === 'function' ? askOpts.onToolApproval : undefined,
-                    onCompactEvent: typeof askOpts?.onCompactEvent === 'function' ? askOpts.onCompactEvent : undefined,
+                    onCompactEvent: (event) => {
+                        _scheduleTurnCheckpoint(true);
+                        try { askOpts?.onCompactEvent?.(event); } catch {}
+                    },
                     // 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).
@@ -586,7 +686,10 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                         // post-loop _pendingTail drain below.
                         return out;
                     },
-                    onSteerMessage: typeof askOpts?.onSteerMessage === 'function' ? askOpts.onSteerMessage : undefined,
+                    onSteerMessage: (text, detail) => {
+                        _scheduleTurnCheckpoint(true);
+                        try { askOpts?.onSteerMessage?.(text, detail); } catch {}
+                    },
                     notifyFn: typeof askOpts?.notifyFn === 'function' ? askOpts.notifyFn : undefined,
                     promptCacheKey: session.promptCacheKey || sessionId,
                     // Provider-scoped cache key (mixdog-codex, mixdog-claude…).
@@ -639,6 +742,8 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             // Turn committed into session.messages; drop the live-turn alias so
             // contextStatus() reverts to the authoritative committed transcript.
             session.liveTurnMessages = null;
+            _stopTurnCheckpoint();
+            delete session.activeTurnCheckpoint;
             const _assistantTranscriptMeta = persistedAssistantTranscriptMetadata(_rawTranscriptMeta);
             if (result.content || result.reasoningContent) {
                 // Max-output recovery returns the complete concatenated text to
@@ -846,6 +951,10 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                 ? saveSessionAsyncDeferred
                 : saveSessionAsync;
             const terminalSave = saveTerminalSession(session, { expectedGeneration: askGeneration });
+            terminalSave.then(
+                () => clearTurnCheckpoint(sessionId, _turnCheckpointToken),
+                () => {},
+            );
             finalizePendingMessageDelivery(
                 session,
                 _turnPendingEntries,
@@ -867,10 +976,14 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             markSessionDone(sessionId, { empty: isEmptyFinal });
             _result = terminalResultPreview;
         } catch (err) {
+            _stopTurnCheckpoint();
             // Cancellation/error paths bypass the commit point above; drop the
             // live-turn alias so contextStatus() stops estimating from the
             // stale in-flight array once the turn unwinds.
-            if (activeSession) activeSession.liveTurnMessages = null;
+            if (activeSession) {
+                activeSession.liveTurnMessages = null;
+                delete activeSession.activeTurnCheckpoint;
+            }
             // Restore before ANY finalization path. In particular, cancellation
             // can race the acknowledged non-streaming restart and surface as a
             // SessionClosedError; its interruption snapshot must include the
@@ -899,6 +1012,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                             } else {
                                 await durableSave;
                             }
+                            clearTurnCheckpoint(sessionId, _turnCheckpointToken);
                         } catch { /* cancellation cleanup is best-effort */ }
                         if (currentRuntime) currentRuntime.session = activeSession;
                     } else releasePendingMessages(sessionId, _turnPendingEntries);
@@ -918,6 +1032,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             const preserveProviderPartial = restoredResetText
                 || err?.liveTextEmitted === true
                 || err?.unsafeToRetry === true;
+            let _errorStateDurable = false;
             if (preserveProviderPartial && activeSession && _turnInterruption.hasResponseStarted()) {
                 const finalized = _prepareCloseSnapshot('provider-error');
                 if (finalized.responsePreserved) recordPendingMessageDelivery(activeSession, _turnPendingEntries);
@@ -932,6 +1047,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                     } else {
                         await durableSave;
                     }
+                    _errorStateDurable = true;
                 } catch { /* provider-failure history persistence is best-effort */ }
                 const currentRuntime = _getRuntimeEntry(sessionId);
                 if (currentRuntime) currentRuntime.session = activeSession;
@@ -951,11 +1067,19 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                             activeSession, _turnPendingEntries, durableSave,
                             () => saveSessionAsync(activeSession, { expectedGeneration: askGeneration }),
                         );
+                        _errorStateDurable = true;
                     } catch {}
                 } else {
                     releasePendingMessages(sessionId, _turnPendingEntries);
                 }
             }
+            if (!_errorStateDurable && activeSession) {
+                try {
+                    await saveSessionAsync(activeSession, { expectedGeneration: askGeneration });
+                    _errorStateDurable = true;
+                } catch { /* retain checkpoint when canonical persistence fails */ }
+            }
+            if (_errorStateDurable) clearTurnCheckpoint(sessionId, _turnCheckpointToken);
             markSessionError(sessionId, err && err.message ? err.message : String(err));
             throw err;
         }
@@ -1000,6 +1124,8 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
         return _result;
       }
     } finally {
+        // A thrown setup/provider path must never leave a delayed checkpoint
+        // writer alive after the turn lock is released.
         // Clear the controller only if it's still ours (closeSession may have
         // swapped it). Leave the rest of the runtime entry intact so agent type=list
         // can still surface the final stage (done/error/cancelling).

package/src/runtime/agent/orchestrator/session/manager/pending-messages.mjs

@@ -569,18 +569,30 @@ export function hydratePendingMessages(sessionId, options = {}) {
 
 function clearPersistedPendingMessages(sessionId) {
     if (!isValidPendingSessionId(sessionId)) return;
-    try {
-        updateJsonAtomicSync(pendingMessagesPath(), (raw) => {
-            const next = normalizePendingStore(raw);
-            if (!Object.prototype.hasOwnProperty.call(next.sessions, sessionId)) return undefined;
-            delete next.sessions[sessionId];
-            if (next.sessionTouchedAt) delete next.sessionTouchedAt[sessionId];
-            next.updatedAt = Date.now();
-            return next;
-        }, { compact: true, lock: true, mode: PENDING_MESSAGES_MODE, fsync: false });
-    } catch (err) {
-        try { process.stderr.write(`[session] pending-message clear failed sessionId=${sessionId}: ${err?.message || err}\n`); } catch {}
-    }
+    // ASYNC, chained behind this session's persist tail. The previous SYNC
+    // variant self-deadlocked: closeSession ran it on the event loop while an
+    // in-flight async spool op (persist/ack/hydrate) in the SAME process held
+    // the lock — the sync wait starved the holder's continuations, so every
+    // such race burned the full 8s lock timeout (observed as an 8s shard-child
+    // stall after each one-shot session close). In-memory queues are already
+    // dropped synchronously by _dropPendingMessageState; only the durable
+    // spool row lags behind, exactly like the ack path.
+    const preceding = _pendingPersistTails.get(sessionId) || Promise.resolve();
+    const operation = preceding.catch(() => {}).then(() => updateJsonAtomic(pendingMessagesPath(), (raw) => {
+        const next = normalizePendingStore(raw);
+        if (!Object.prototype.hasOwnProperty.call(next.sessions, sessionId)) return undefined;
+        delete next.sessions[sessionId];
+        if (next.sessionTouchedAt) delete next.sessionTouchedAt[sessionId];
+        next.updatedAt = Date.now();
+        return next;
+    }, { compact: true, lock: true, mode: PENDING_MESSAGES_MODE, fsync: false }))
+        .catch((err) => {
+            try { process.stderr.write(`[session] pending-message clear failed sessionId=${sessionId}: ${err?.message || err}\n`); } catch {}
+        });
+    _pendingPersistTails.set(sessionId, operation);
+    operation.finally(() => {
+        if (_pendingPersistTails.get(sessionId) === operation) _pendingPersistTails.delete(sessionId);
+    }).catch(() => {});
 }
 
 function shouldEvictPendingSession(sessionId, ttlMs, entryTouchedAt, now = Date.now()) {
@@ -913,5 +925,12 @@ export function _dropPendingMessageState(id, { clearPersisted = true } = {}) {
 }
 
 setImmediate(() => {
+    // Spool hygiene belongs to the lead/daemon process. Worker-mode children
+    // (channels worker, agent shard) share the same spool file; a boot-time
+    // SYNC sweep in every child contends on the cross-process lock against
+    // the lead's writes (observed in the first live shard run: "atomic lock
+    // timeout after 8000ms: session-pending-messages.json.lock") for zero
+    // benefit — the lead already sweeps.
+    if (process.env.MIXDOG_WORKER_MODE === '1') return;
     try { sweepOrphanedPendingMessages(); } catch { /* ignore */ }
 });

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

@@ -11,6 +11,7 @@ import { SessionClosedError } from './session-errors.mjs';
 import { _dropPendingMessageState } from './pending-messages.mjs';
 import { _stopToolActivityHeartbeat, _getRuntimeEntry, _clearSessionRuntime } from './runtime-liveness.mjs';
 import { _closeBashSessionLazy } from './runtime-loaders.mjs';
+import { clearTurnCheckpoint } from './turn-checkpoint.mjs';
 
 /**
  * Close a session. Plants a `closed=true` tombstone on disk with a bumped
@@ -69,6 +70,9 @@ export function closeSession(id, reason = 'manual', opts = {}) {
     //    write could silently overwrite the session after the user resumes
     //    it back (BL: burned-session late-save clobber).
     const newGen = tombstone ? markSessionClosed(id, reason) : bumpSessionGeneration(id, reason);
+    // prepareCloseSnapshot was folded into the synchronous generation write
+    // above. Only now is it safe to remove the crash fallback.
+    if (typeof newGen === 'number') clearTurnCheckpoint(id);
     // 2. Mark runtime as closed so post-await validation in askSession fires.
     if (entry) {
         entry.closed = true;