mixdog 0.9.32 → 0.9.34

package/src/runtime/agent/orchestrator/session/compact/constants.mjs

@@ -27,6 +27,9 @@ export const SUMMARY_OUTPUT_TOKENS = 4_096;
 //   - recall-fasttrack injection cap (loop.mjs recallTokenCap)
 // Keep them in lockstep; do not fork per-consumer ratios without a decision.
 export const CONTEXT_SHARE_RATIO = 0.10;
+export const DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT = 90;
+export const COMPACT_TARGET_MIN_TOKENS = 4_000;
+export const COMPACT_SAFETY_PERCENT = 1.00;
 // Floor for the recall-injection cap so small-context models still get a
 // usable recall slice (cap = max(floor, contextWindow * CONTEXT_SHARE_RATIO)).
 export const RECALL_TOKEN_CAP_FLOOR_TOKENS = 2_048;

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

@@ -22,6 +22,9 @@ export {
     SUMMARY_PREFIX,
     SUMMARY_OUTPUT_TOKENS,
     CONTEXT_SHARE_RATIO,
+    DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT,
+    COMPACT_TARGET_MIN_TOKENS,
+    COMPACT_SAFETY_PERCENT,
     RECALL_TOKEN_CAP_FLOOR_TOKENS,
     COMPACT_SUMMARY_MIN_ROOM_TOKENS,
     COMPACT_TYPE_SEMANTIC,

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

@@ -1,5 +1,6 @@
 import { isOffloadedToolResultText } from './tool-result-offload.mjs';
 import { createHash } from 'node:crypto';
+import { isAgentOwner } from '../agent-owner.mjs';
 
 // ---------------------------------------------------------------------------
 // Conservative, Unicode-aware token estimator.
@@ -225,13 +226,45 @@ export function resolveCompactBufferTokens(boundaryTokens, cfg = {}, opts = {})
 }
 
 export function resolveCompactTriggerTokens(sessionOrConfig = {}, boundaryTokens = 0) {
-    const boundary = positiveTokenInt(boundaryTokens);
-    if (!boundary) return null;
+    return resolveSessionCompactPolicy(sessionOrConfig, boundaryTokens).triggerTokens;
+}
+
+// Single source of truth for per-session compaction policy math. Manager
+// (compactTriggerForSession), the turn loop (resolveWorkerCompactPolicy), and
+// the /context gauge all derive their trigger/buffer from here so the numbers
+// never diverge. Rules:
+//   - a truly-explicit sub-boundary auto-compact limit always wins
+//     (trigger = limit) for every session type;
+//   - agent-owned semantic sessions otherwise keep the default early-trigger
+//     buffer (config-driven, default 10% -> compact at 90% of the boundary);
+//   - main/user recall-fasttrack sessions have NO default buffer and compact on
+//     the boundary itself (100%).
+// Returns the sanitized explicit limit (null when absent/legacy full-window)
+// plus triggerTokens / bufferTokens / bufferRatio for the given boundary.
+export function resolveSessionCompactPolicy(sessionOrConfig = {}, boundaryTokens = 0) {
     const cfg = sessionOrConfig?.compaction || sessionOrConfig || {};
-    const autoLimit = positiveTokenInt(sessionOrConfig?.autoCompactTokenLimit ?? cfg?.autoCompactTokenLimit);
-    if (autoLimit && autoLimit < boundary) return Math.max(1, autoLimit);
-    const buffer = resolveCompactBufferTokens(boundary, cfg);
-    return Math.max(1, boundary - buffer);
+    const boundary = positiveTokenInt(boundaryTokens);
+    if (!boundary) {
+        return {
+            autoCompactTokenLimit: null,
+            triggerTokens: null,
+            bufferTokens: 0,
+            bufferRatio: resolveCompactBufferRatio(cfg),
+        };
+    }
+    const rawLimit = positiveTokenInt(sessionOrConfig?.autoCompactTokenLimit ?? cfg?.autoCompactTokenLimit);
+    const explicitLimit = rawLimit && rawLimit < boundary ? rawLimit : null;
+    let triggerTokens;
+    if (explicitLimit) {
+        triggerTokens = explicitLimit;
+    } else if (isAgentOwner(sessionOrConfig)) {
+        triggerTokens = Math.max(1, boundary - resolveCompactBufferTokens(boundary, cfg));
+    } else {
+        triggerTokens = boundary;
+    }
+    const bufferTokens = Math.max(0, boundary - triggerTokens);
+    const bufferRatio = bufferTokens / boundary;
+    return { autoCompactTokenLimit: explicitLimit, triggerTokens, bufferTokens, bufferRatio };
 }
 
 function stripSystemReminder(text) {

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

@@ -4,8 +4,7 @@
 // against live session state).
 import {
     estimateRequestReserveTokens,
-    resolveCompactBufferRatio,
-    resolveCompactBufferTokens,
+    resolveSessionCompactPolicy,
 } from '../context-utils.mjs';
 import {
     compactTypeIsRecallFastTrack,
@@ -13,18 +12,17 @@ import {
     DEFAULT_COMPACT_TYPE,
     DEFAULT_COMPACTION_KEEP_TOKENS,
     CONTEXT_SHARE_RATIO,
+    COMPACT_TARGET_MIN_TOKENS,
+    COMPACT_SAFETY_PERCENT,
     COMPACT_TYPE_RECALL_FASTTRACK,
 } from '../compact.mjs';
 import { positiveTokenInt, envFlag, envTokenInt } from './env.mjs';
 import { isAgentOwner } from '../../agent-owner.mjs';
 
-const COMPACT_SAFETY_PERCENT = 1.00;
 // Unified context-share rule (compact/constants.mjs CONTEXT_SHARE_RATIO): the
 // post-compaction target is 10% of the boundary/context window — the same 10%
 // the recall-fasttrack injection cap uses (loop.mjs recallTokenCap). One
 // number governs every "share of model context" budget.
-const COMPACT_TARGET_RATIO = CONTEXT_SHARE_RATIO;
-const COMPACT_TARGET_MIN_TOKENS = 4_000;
 
 function resolveSemanticCompactSetting(sessionRef, cfg = {}) {
     // Types are hard-locked (agent -> semantic, main/user -> recall-fasttrack).
@@ -55,9 +53,9 @@ function resolveCompactTargetRatio(cfg = {}) {
         ?? cfg.targetFraction
         ?? process.env.MIXDOG_AGENT_COMPACT_TARGET_PERCENT
         ?? process.env.MIXDOG_COMPACT_TARGET_PERCENT
-        ?? COMPACT_TARGET_RATIO;
+        ?? CONTEXT_SHARE_RATIO;
     const n = Number(raw);
-    if (!Number.isFinite(n) || n <= 0) return COMPACT_TARGET_RATIO;
+    if (!Number.isFinite(n) || n <= 0) return CONTEXT_SHARE_RATIO;
     return n > 1 ? n / 100 : n;
 }
 function resolveCompactTargetTokens(boundaryTokens, cfg = {}) {
@@ -92,22 +90,16 @@ export function resolveWorkerCompactPolicy(sessionRef, tools) {
         : (explicitBoundary || contextWindow || autoLimit);
     if (!boundaryTokens) return null;
     const compactBoundaryTokens = Math.max(1, Math.floor(boundaryTokens * COMPACT_SAFETY_PERCENT));
-    // Only an explicit auto-compact limit STRICTLY BELOW the boundary acts as
-    // the trigger. A persisted value == boundary (legacy derived full-window
-    // autoCompactTokenLimit) would set autoTriggerTokens == boundary and
-    // collapse/override the default trigger, so it is ignored in favor of the
-    // default boundary trigger.
-    const autoTriggerTokens = autoLimit && autoLimit < compactBoundaryTokens ? Math.max(1, autoLimit) : null;
-    // Sanitized explicit limit: only a sub-boundary value is a real auto-compact
-    // limit. Anything >= boundary is a legacy derived full-window artifact and
-    // is reported as null so rememberCompactTelemetry does not re-persist it
-    // back onto the session and re-collapse the buffer on the next turn.
-    const explicitAutoCompactTokenLimit = autoTriggerTokens;
-    const bufferTokens = autoTriggerTokens
-        ? Math.max(0, compactBoundaryTokens - autoTriggerTokens)
-        : resolveCompactBufferTokens(compactBoundaryTokens, cfg);
-    const bufferRatio = compactBoundaryTokens ? (bufferTokens / compactBoundaryTokens) : resolveCompactBufferRatio(cfg);
-    const triggerTokens = autoTriggerTokens || Math.max(1, compactBoundaryTokens - bufferTokens);
+    // Shared session-compaction policy (context-utils): agent semantic keeps the
+    // default early-trigger buffer (90%); main/user compact on the boundary
+    // (100%); a truly-explicit sub-boundary limit wins. explicitAutoCompactTokenLimit
+    // is the sanitized (null when legacy full-window) value so telemetry never
+    // re-persists a boundary-collapsing limit.
+    const policy = resolveSessionCompactPolicy(sessionRef, compactBoundaryTokens);
+    const explicitAutoCompactTokenLimit = policy.autoCompactTokenLimit;
+    const bufferTokens = policy.bufferTokens;
+    const bufferRatio = policy.bufferRatio;
+    const triggerTokens = policy.triggerTokens;
     const configuredReserve = positiveTokenInt(cfg.reservedTokens)
         || envTokenInt('MIXDOG_AGENT_COMPACT_RESERVED_TOKENS')
         || 0;

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

@@ -36,3 +36,31 @@ export function agentContextOverflowError({ stage, sessionId, sessionRef, model,
         messageTokensEst,
     }, cause);
 }
+
+// Distinct from AgentContextOverflowError: the compaction pipeline itself
+// failed (semantic-summary error, dead memory runtime, recall-fasttrack bail,
+// 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 {
+    constructor({ stage, sessionId, provider, model }, cause) {
+        const target = [provider, model].filter(Boolean).join('/') || 'target model';
+        const causeMsg = cause && cause.message ? `: ${cause.message}` : '';
+        super(`agent compact failed (${target}, stage=${stage || 'compact'})${causeMsg}`);
+        this.name = 'AgentCompactFailedError';
+        this.code = 'AGENT_COMPACT_FAILED';
+        this.sessionId = sessionId || null;
+        this.provider = provider || null;
+        this.model = model || null;
+        if (cause) this.cause = cause;
+    }
+}
+
+export function agentCompactFailedError({ stage, sessionId, sessionRef, model }, cause) {
+    return new AgentCompactFailedError({
+        stage,
+        sessionId,
+        provider: sessionRef?.provider || null,
+        model: sessionRef?.model || model || null,
+    }, cause);
+}

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

@@ -128,6 +128,11 @@ export async function runRecallFastTrackCompact({ sessionRef, messages, compactB
             messages,
             cwd: sessionRef?.cwd,
             limit: hydrateLimit,
+            // Pre-send fast-track compaction: these rows are about to be
+            // summarized away, so skip the bounded synchronous embedding-flush
+            // wait — kick the flush fire-and-forget. Mirrors the manual/auto-clear
+            // runner (manager/compaction-runner.mjs) embedWait:false policy.
+            embedWait: false,
         }, callerCtx);
     } catch (err) {
         ingestFailed = true;

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

@@ -17,6 +17,31 @@ export function _isMutationTool(name) {
     const n = _stripMcpPrefix(name);
     return n === 'apply_patch';
 }
+// Side-effect-free read-only tools that stay parallel even after an earlier
+// ordered mutation failed in the same batch. Everything NOT in this set is
+// treated as ordered-gate-skippable (see _isOrderedGateSkippable): apply_patch,
+// shell/bash_session, write/edit-style tools, and any (non-mixdog) MCP tool
+// whose effects are unknown. Kept separate from _isMutationTool, which stays
+// apply_patch-only for epoch-mutation counting and eager-dispatch gating.
+export 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));
+}
 export const SCOPED_CACHEABLE_TOOLS = new Set([
     'code_graph',
     'grep',

package/src/runtime/agent/orchestrator/session/manager/context-meta.mjs

@@ -1,8 +1,14 @@
 // Context-window sizing, compaction target math, and session context-meta
 // resolution. Extracted verbatim from manager.mjs (behavior-preserving).
 import { getModelMetadataSync } from '../../providers/model-catalog.mjs';
-import { resolveCompactTriggerTokens } from '../context-utils.mjs';
-import { COMPACT_TYPE_SEMANTIC, COMPACT_TYPE_RECALL_FASTTRACK, CONTEXT_SHARE_RATIO } from '../compact.mjs';
+import { resolveSessionCompactPolicy } from '../context-utils.mjs';
+import {
+    COMPACT_TYPE_SEMANTIC,
+    COMPACT_TYPE_RECALL_FASTTRACK,
+    CONTEXT_SHARE_RATIO,
+    DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT,
+    COMPACT_TARGET_MIN_TOKENS,
+} from '../compact.mjs';
 import { isAgentOwner } from '../../agent-owner.mjs';
 
 // Known context windows for the current-generation models this plugin
@@ -89,14 +95,12 @@ export function preserveBufferConfigFields(cfg = {}) {
     }
     return out;
 }
-const COMPACT_TARGET_RATIO = CONTEXT_SHARE_RATIO;
-const COMPACT_TARGET_MIN_TOKENS = 4_000;
 function compactTargetRatio() {
     const raw = process.env.MIXDOG_AGENT_COMPACT_TARGET_PERCENT
         ?? process.env.MIXDOG_COMPACT_TARGET_PERCENT
-        ?? COMPACT_TARGET_RATIO;
+        ?? CONTEXT_SHARE_RATIO;
     const n = Number(raw);
-    if (!Number.isFinite(n) || n <= 0) return COMPACT_TARGET_RATIO;
+    if (!Number.isFinite(n) || n <= 0) return CONTEXT_SHARE_RATIO;
     return n > 1 ? n / 100 : n;
 }
 function compactTargetTokensForBoundary(boundaryTokens) {
@@ -115,7 +119,8 @@ function defaultEffectiveContextWindowPercent(provider) {
     // Gateway/statusline route metadata reserves a universal 10% headroom from
     // the raw catalog window. Keep session compaction on the same effective
     // capacity so /context, the TUI statusline, and gateway telemetry agree.
-    return 90;
+    void provider;
+    return DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT;
 }
 const PROVIDER_SYNTHETIC_CONTEXT_DEFAULT = 1_000_000;
 function providerRawContextWindow(info, catalogInfo) {
@@ -201,7 +206,10 @@ export function resolveSessionContextMeta(provider, model, seed = {}) {
     };
 }
 export function compactTriggerForSession(session, boundaryTokens) {
-    return resolveCompactTriggerTokens(session, boundaryTokens);
+    // Delegates to the shared session-compaction policy (context-utils):
+    // agent semantic -> 90% (default buffer), main/user -> 100% (boundary),
+    // truly-explicit sub-boundary limit wins.
+    return resolveSessionCompactPolicy(session, boundaryTokens).triggerTokens;
 }
 export function compactTargetBudget(boundaryTokens, reserveTokens, _sourceTokens = null, _ratio = null) {
     const boundary = positiveContextWindow(boundaryTokens);

package/src/runtime/agent/orchestrator/session/pre-send-compact.mjs

@@ -26,6 +26,8 @@ import { estimateMessagesTokensSafe } from './loop/compact-debug.mjs';
 import { messagesArrayChanged } from './loop/tool-helpers.mjs';
 import { normalizeUsage, addUsage } from './loop/usage.mjs';
 import { agentContextOverflowError } from './loop/context-overflow.mjs';
+import { agentCompactFailedError } from './loop/context-overflow.mjs';
+import { isContextOverflowError } from '../providers/retry-classifier.mjs';
 import { traceAgentCompact, messagePrefixHash } from '../agent-trace.mjs';
 import { bumpUsageMetricsEpoch } from './manager.mjs';
 
@@ -252,6 +254,31 @@ export async function runPreSendCompactPass(state) {
                             );
                         } catch { /* best-effort */ }
                     } else {
+                    // A genuine cancellation/abort surfaced from the compact
+                    // pipeline is NOT a context overflow. The recall-fasttrack
+                    // pipeline (loop/recall-fasttrack.mjs) deliberately rethrows
+                    // the original abort error unchanged so the session records a
+                    // clean cancellation — and the manual/auto-clear runner
+                    // (manager/compaction-runner.mjs) likewise never fabricates an
+                    // AGENT_CONTEXT_OVERFLOW for an aborted compact. Mirror that
+                    // here: preserve the real error (code/name/cause intact)
+                    // instead of masking it as overflow. Detection is narrow on
+                    // purpose — signal.aborted or a true AbortError — so the
+                    // recall pipeline's SYNTHETIC "…aborted: memory … ; head
+                    // preserved" failure (a real compact failure, message text
+                    // aside) still escalates to overflow below.
+                    if (signal?.aborted === true
+                        || compactErr?.name === 'AbortError'
+                        || compactErr?.code === 'ABORT_ERR'
+                        || compactErr?.code === 'ABORT') {
+                        try {
+                            process.stderr.write(
+                                `[loop] pre-send compact cancelled (sess=${sessionId || 'unknown'}): ` +
+                                `${compactErr?.message || compactErr}\n`,
+                            );
+                        } catch { /* best-effort */ }
+                        throw compactErr;
+                    }
                     const compactFailMsg = compactErr && compactErr.message ? compactErr.message : String(compactErr);
                     const semanticFailMsg = semanticCompactError?.message || null;
                     const recallFailMsg = recallFastTrackError?.message || null;
@@ -324,14 +351,33 @@ export async function runPreSendCompactPass(state) {
                         durationMs: Date.now() - compactStartedAt,
                         error: compactErr && compactErr.message ? compactErr.message : String(compactErr),
                     });
-                    throw agentContextOverflowError({
+                    // Only a GENUINE provider context-overflow surfaced from the
+                    // compact pipeline (e.g. the semantic-summary send itself
+                    // overflowed the model window) deserves AGENT_CONTEXT_OVERFLOW.
+                    // Every other compact-stage failure (dead memory runtime,
+                    // recall-fasttrack bail, semantic summary error) is a compact
+                    // failure, not "latest turn cannot fit" — mislabeling it as
+                    // overflow hides the real cause and misroutes downstream
+                    // overflow handling. Surface an explicit compact-failed error.
+                    const genuineOverflow = compactErr?.code === 'AGENT_CONTEXT_OVERFLOW'
+                        || compactErr?.name === 'AgentContextOverflowError'
+                        || isContextOverflowError(compactErr);
+                    if (genuineOverflow) {
+                        throw agentContextOverflowError({
+                            stage: 'pre_send',
+                            sessionId,
+                            sessionRef,
+                            model,
+                            budgetTokens: compactBudgetTokens,
+                            reserveTokens: compactPolicy.reserveTokens,
+                            messageTokensEst,
+                        }, compactErr);
+                    }
+                    throw agentCompactFailedError({
                         stage: 'pre_send',
                         sessionId,
                         sessionRef,
                         model,
-                        budgetTokens: compactBudgetTokens,
-                        reserveTokens: compactPolicy.reserveTokens,
-                        messageTokensEst,
                     }, compactErr);
                     }
                 }

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

@@ -24,7 +24,7 @@ import {
 import { isInvalidToolArgsMarker, formatInvalidToolArgsResult } from '../providers/openai-compat-stream.mjs';
 import {
     _stripMcpPrefix, _isReadTool, _isMutationTool, _isScopedCacheableTool,
-    _isShellTool, _intraTurnSig,
+    _isShellTool, _isOrderedGateSkippable, _intraTurnSig,
 } from './loop/tool-classify.mjs';
 import { preDispatchDenyForSession } from './loop/pre-dispatch-deny.mjs';
 import { executeTool } from './loop/tool-exec.mjs';
@@ -80,6 +80,17 @@ export async function processToolBatch(ctx) {
         // between two tool results of the same multi-tool turn (which would put a
         // user message between tool(A) and tool(B) and break provider pairing).
         const _batchNewMessages = [];
+        // Ordered-mutation batch gate. apply_patch is a mutation tool (never
+        // eager-dispatchable), so multiple apply_patch calls in ONE assistant
+        // turn already execute serially in call-index order via this loop.
+        // This flag records the FIRST ordered mutation whose execution failed
+        // in this batch; every LATER apply_patch in the same batch is then
+        // skipped (not executed) because its edits may depend on the failed
+        // one and applying them against unchanged/partially-changed files
+        // risks corrupt or misplaced writes. Only apply_patch is gated —
+        // non-mutation tools (reads/grep/shell/...) keep their normal
+        // parallelism and behavior. Reset per batch (per assistant turn).
+        let _orderedMutationFailed = null;
         for (let callIndex = 0; callIndex < calls.length; callIndex += 1) {
             const call = calls[callIndex];
             if (isBuiltinTool(call.name)) {
@@ -151,6 +162,22 @@ export async function processToolBatch(ctx) {
                     continue;
                 }
             }
+            // Ordered-mutation skip: an earlier apply_patch in THIS batch failed,
+            // so this later apply_patch is skipped rather than executed. Restore
+            // its full patch body first (this call never ran) so the model can
+            // 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)) {
+                if (call?.id) restoreToolCallBodyForId(assistantTurnMsg, calls, call.id);
+                pushToolResultMessage({
+                    role: 'tool',
+                    content: `Error: [ordered-mutation-skip] an earlier apply_patch in this same tool batch (call index ${_orderedMutationFailed.index + 1}) failed; ordered mutations in one batch are all-or-nothing after a failure, so this later \`${call.name}\` was NOT executed — it may depend on the failed mutation and running it now against unchanged/partially-changed state could corrupt files. Re-issue it in a new turn after resolving the earlier failure.`,
+                    toolCallId: call.id,
+                    toolKind: 'error',
+                });
+                continue;
+            }
             if (sessionId) markSessionToolCall(sessionId, call.name, resolveToolSelfDeadlineMs(call.name, call.arguments));
             let result;
             let toolStartedAt;
@@ -416,9 +443,34 @@ export async function processToolBatch(ctx) {
             // This block runs unconditionally (not gated on _executeOk or _resultKind).
             if (sessionId && (!_executeOk || _resultKind === 'error') && _stripMcpPrefix(call.name) === 'apply_patch') {
                 clearReadDedupSession(sessionId);
+                // Scoped caches (grep/glob/list/code_graph) are refreshed only in
+                // the success-gated block above, so a FAILED/errored patch would
+                // otherwise leave later non-mutation tools in this batch reading
+                // stale scoped-cache entries for the (possibly partially-written)
+                // files. Invalidate targeted paths when the diff parses, else full
+                // wipe — file state is unknown after an error exit.
+                const _failBaseArg = call.arguments?.base_path;
+                const _failBase = (typeof _failBaseArg === 'string' && _failBaseArg.length > 0)
+                    ? (isAbsolute(_failBaseArg) ? _failBaseArg : resolvePath(cwd || process.cwd(), _failBaseArg))
+                    : (cwd || process.cwd());
+                const _failTouched = extractTouchedPathsFromPatch(call.arguments?.patch);
+                if (_failTouched.length > 0) {
+                    clearScopedToolsForSessionPaths(sessionId, _failTouched, _failBase);
+                    for (const _p of _failTouched) invalidatePrefetchCache(_p, _failBase);
+                } else {
+                    clearScopedToolsForSession(sessionId);
+                }
             }
             if (_isMutationTool(call.name)) {
                 epoch.mutation += 1;
+                // Record the first failed ordered mutation in this batch so any
+                // LATER apply_patch is skipped by the gate at the top of the
+                // loop. Keyed on exec outcome (not post-processing): a mutation
+                // whose write succeeded but post-processing threw still landed
+                // on disk, so it must NOT block subsequent ordered patches.
+                if ((!_executeOk || _resultKind === 'error') && !_orderedMutationFailed) {
+                    _orderedMutationFailed = { index: callIndex, callId: call.id, name: call.name };
+                }
             }
             // Bash always clears scoped cache UNCONDITIONALLY — a mutating bash
             // that throws or fails partway can still leave stale find_symbol / grep entries.

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

@@ -567,6 +567,16 @@ async function waitForGenericTask(taskId, { timeoutMs = 30_000, pollMs = 250, co
     };
 }
 
+function renderTaskCancelSuccess(taskId, task) {
+    const surface = task?.surface || 'task';
+    const operation = task?.operation || 'run';
+    return [
+        'status: completed',
+        `task_id: ${taskId}`,
+        `cancelled: ${surface}/${operation}`,
+    ].join('\n');
+}
+
 export async function executeTaskTool(args, options = {}) {
     const action = typeof args.action === 'string' ? args.action.toLowerCase() : (args.task_id ? 'wait' : 'list');
     if (action === 'list') return renderBackgroundTaskList({ context: options });
@@ -597,10 +607,10 @@ export async function executeTaskTool(args, options = {}) {
             cancelBackgroundShellJobWatch(taskId);
             clearShellJobNotifyCtx(taskId);
             cancelBackgroundTask(taskId, 'cancelled by task control');
-            return job ? renderBackgroundTask(getBackgroundTask(taskId, { context: options }) || task, { includeResult: true }) : buildJobNotFoundMessage(taskId);
+            return job ? renderTaskCancelSuccess(taskId, getBackgroundTask(taskId, { context: options }) || task) : buildJobNotFoundMessage(taskId);
         }
         cancelBackgroundTask(taskId, 'cancelled by task control');
-        return renderBackgroundTask(getBackgroundTask(taskId, { context: options }) || task, { includeResult: true });
+        return renderTaskCancelSuccess(taskId, getBackgroundTask(taskId, { context: options }) || task);
     }
 
     if (action !== 'wait') {