mixdog 0.9.92 → 0.9.94

package/src/runtime/agent/orchestrator/providers/openai-oauth-http-sse.mjs

@@ -7,7 +7,10 @@
  * (scripts/openai-oauth-http-sse-toolcall-smoke.mjs) and fallback headers.
  */
 import { randomBytes } from 'crypto';
+import zlib from 'node:zlib';
 import {
+    extractCacheWriteTokens,
+    extractCachedTokens,
     traceAgentFetch,
     traceAgentSse,
     traceAgentUsage,
@@ -47,6 +50,21 @@ const CODEX_REQUEST_MAX_RETRIES = 4;
 const CODEX_REQUEST_BACKOFF_MS = Object.freeze([200, 400, 800, 1600]);
 const CODEX_RETRY_JITTER_RATIO = 0.1;
 
+// Request-body zstd gate (see sendViaHttpSse). Namespace import: on Node
+// runtimes without zlib zstd bindings the named export would fail at module
+// load, so the call site typeof-guards zlib.zstdCompressSync instead.
+const OPENAI_REQ_ZSTD_MIN_BYTES = 8 * 1024;
+let _openaiReqZstdLatch = false;
+function _openaiReqZstdDisabled() {
+    return _openaiReqZstdLatch || process.env.MIXDOG_OPENAI_REQ_ZSTD === '0';
+}
+function _disableOpenaiReqZstd() { _openaiReqZstdLatch = true; }
+function _zstdHeaders(headers, bodyForSend) {
+    return bodyForSend.encoding
+        ? { ...headers, 'Content-Encoding': bodyForSend.encoding }
+        : headers;
+}
+
 export function _envFlag(name, fallback = true) {
     const raw = process.env[name];
     if (raw == null || raw === '') return fallback;
@@ -72,11 +90,6 @@ function _parseJsonObject(value) {
     }
 }
 
-function _extractCachedTokens(usage) {
-    const details = usage?.input_tokens_details || usage?.prompt_tokens_details || {};
-    return Number(details.cached_tokens ?? details.cached ?? usage?.cached_tokens ?? 0) || 0;
-}
-
 function _sseEventsFromBuffer(buffer) {
     const frames = [];
     let rest = buffer.replace(/\r\n/g, '\n');
@@ -231,6 +244,19 @@ export async function sendViaHttpSse({
     const responsesUrl = auth?.type === 'openai-direct'
         ? OPENAI_DIRECT_RESPONSES_URL
         : CODEX_RESPONSES_URL;
+    // Request-body zstd (codex parity: core client.rs
+    // responses_request_compression enables zstd for the codex backend on the
+    // OpenAI provider — the server decompresses Content-Encoding: zstd).
+    // openai-direct is excluded: only the codex backend is verified. Env
+    // kill-switch plus a process-wide latch flipped on the first 400 seen on
+    // a compressed request, which then replays that attempt uncompressed.
+    const _rawReqBytes = Buffer.from(JSON.stringify(body));
+    let _reqBodyForSend = auth?.type !== 'openai-direct'
+        && !_openaiReqZstdDisabled()
+        && typeof zlib.zstdCompressSync === 'function'
+        && _rawReqBytes.length >= OPENAI_REQ_ZSTD_MIN_BYTES
+        ? { bytes: zlib.zstdCompressSync(_rawReqBytes), encoding: 'zstd' }
+        : { bytes: _rawReqBytes, encoding: null };
     let response;
     for (let attempt = 0; attempt <= CODEX_REQUEST_MAX_RETRIES; attempt++) {
         const headerTimeout = createTimeoutSignal(
@@ -253,8 +279,8 @@ export async function sendViaHttpSse({
             } catch {}
             response = await fetchFn(responsesUrl, {
                 method: 'POST',
-                headers,
-                body: JSON.stringify(body),
+                headers: _zstdHeaders(headers, _reqBodyForSend),
+                body: _reqBodyForSend.bytes,
                 signal: headerTimeout.signal,
                 dispatcher: getLlmDispatcher(),
             });
@@ -267,6 +293,15 @@ export async function sendViaHttpSse({
             headerTimeout.cleanup();
         }
 
+        // zstd rejection fallback: a 400 on a compressed request latches
+        // compression OFF process-wide and replays this attempt uncompressed.
+        if (response && response.status === 400 && _reqBodyForSend.encoding) {
+            _disableOpenaiReqZstd();
+            _reqBodyForSend = { bytes: _rawReqBytes, encoding: null };
+            await response.arrayBuffer().catch(() => {});
+            response = undefined;
+            continue;
+        }
         const retryableStatus = response && response.status >= 500 && response.status <= 599;
         // Typed transient transport failures only (errno / SDK connection
         // type). An unknown pre-response failure throws immediately instead of
@@ -783,7 +818,8 @@ export async function sendViaHttpSse({
                     usage = {
                         inputTokens: resp.usage.input_tokens || 0,
                         outputTokens: resp.usage.output_tokens || 0,
-                        cachedTokens: _extractCachedTokens(resp.usage),
+                        cachedTokens: extractCachedTokens(resp.usage),
+                        cacheWriteTokens: extractCacheWriteTokens(resp.usage),
                         promptTokens: resp.usage.input_tokens || 0,
                         raw: serviceTier ? { ...resp.usage, service_tier: serviceTier } : resp.usage,
                     };

package/src/runtime/agent/orchestrator/providers/openai-ws-events.mjs

@@ -39,6 +39,9 @@ export function _combineUsageWithWarmup(actual, warmup, { separateMainContext =
         inputTokens: _usageNum(actual.inputTokens) + _usageNum(warmup.inputTokens),
         outputTokens: _usageNum(actual.outputTokens) + _usageNum(warmup.outputTokens),
         cachedTokens: _usageNum(actual.cachedTokens) + _usageNum(warmup.cachedTokens),
+        ...(actual.cacheWriteTokens != null || warmup.cacheWriteTokens != null
+            ? { cacheWriteTokens: _usageNum(actual.cacheWriteTokens) + _usageNum(warmup.cacheWriteTokens) }
+            : {}),
         promptTokens: _usageNum(actual.promptTokens) + _usageNum(warmup.promptTokens),
         warmupInputTokens: _usageNum(warmup.inputTokens),
         warmupCachedTokens: _usageNum(warmup.cachedTokens),

package/src/runtime/agent/orchestrator/providers/openai-ws-stream.mjs

@@ -16,6 +16,7 @@
 import { randomBytes } from 'crypto';
 import { performance } from 'node:perf_hooks';
 import {
+    extractCacheWriteTokens,
     extractCachedTokens,
     appendAgentTrace,
 } from '../agent-trace.mjs';
@@ -1090,6 +1091,7 @@ export async function _streamResponse({
                             inputTokens: u.input_tokens || 0,
                             outputTokens: u.output_tokens || 0,
                             cachedTokens: extractCachedTokens(u),
+                            cacheWriteTokens: extractCacheWriteTokens(u),
                             // openai-oauth reports input_tokens as the total
                             // prompt volume (cached portion is a subset, not
                             // additive). Alias into the cross-provider

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

@@ -227,7 +227,17 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
     // turn's push (deferBodies below) collapse to markers now — the model has
     // already seen them on that turn's follow-up send. Failed bodies stay
     // verbatim for retry.
-    compactSettledToolCallBodies(messages);
+    // Out-of-loop transcript mutations (post-turn/manual compaction in
+    // manager/compaction-runner.mjs) run where no send opts exist; they park a
+    // one-shot intent on the session so the FIRST send of the next turn tags
+    // its expected cache break instead of an unexplained prefix mismatch.
+    if (!opts.cacheBreakIntent && typeof sessionRef?.pendingCacheBreakIntent === 'string') {
+        opts.cacheBreakIntent = sessionRef.pendingCacheBreakIntent;
+        delete sessionRef.pendingCacheBreakIntent;
+    }
+    if (compactSettledToolCallBodies(messages) && !opts.cacheBreakIntent) {
+        opts.cacheBreakIntent = 'deferred_body_compaction';
+    }
     // ---- Codex turn stop hook (refs/codex core/src/session/turn.rs:372-404) --
     // A no-tool assistant message is TERMINAL. Only a structured provider
     // follow-up signal (end_turn=false / pause_turn), pending input, tool
@@ -526,7 +536,10 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
                 const _m = messages[_i];
                 if (_m && _m.role === 'tool' && typeof _m.content === 'string' && _m.content.includes('⚠')) {
                     const _stripped = stripSoftWarns(_m.content);
-                    if (_stripped !== _m.content) _m.content = _stripped;
+                    if (_stripped !== _m.content) {
+                        _m.content = _stripped;
+                        if (!opts.cacheBreakIntent) opts.cacheBreakIntent = 'soft_warn_strip';
+                    }
                 }
             }
             sendTools = snapshotProviderRequestTools({
@@ -645,14 +658,16 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
         );
         const _sendEndedAt = Date.now();
         if (_sendResult.action === 'retry') {
-            delete opts.cacheBreakIntent;
+            // Keep opts.cacheBreakIntent: the failed send never consumed the
+            // tag, and the reactive-compact retry that follows IS the tagged
+            // transition — deleting it here made retry-side cache_break rows
+            // log intentional_transition: null.
             contextOverflowRetryUsed = true;
             reactiveOverflowRetryPending = true;
             continue;
         }
         if (_sendResult.action === 'retry_transport') {
             _transportRetriesUsed += 1;
-            delete opts.cacheBreakIntent;
             continue;
         }
         response = _sendResult.response;
@@ -1021,7 +1036,9 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
         // Settle earlier deferred bodies before this turn's message lands:
         // every previous call already has its result row, so successful bodies
         // compact to markers while failed ones keep their full retry text.
-        compactSettledToolCallBodies(messages);
+        if (compactSettledToolCallBodies(messages) && !opts.cacheBreakIntent) {
+            opts.cacheBreakIntent = 'deferred_body_compaction';
+        }
         messages.push(_assistantTurnMsg);
         try { opts.onAssistantMessageCommitted?.(_assistantTurnMsg); } catch {}
         const _callsToExecute = calls;

package/src/runtime/agent/orchestrator/session/cache/scoped-cache.mjs

@@ -5,6 +5,7 @@
 import { join, resolve as _pathResolve, isAbsolute as _pathIsAbs, normalize as _pathNorm } from 'node:path';
 import { writeJsonAtomicSync } from '../../../../shared/atomic-file.mjs';
 import { _normalizeCacheKey } from './util.mjs';
+import { GREP_AUTO_CONTEXT_LINES } from '../../tools/builtin/path-utils.mjs';
 
 const MAX_PER_SESSION = 100;
 
@@ -43,6 +44,22 @@ function _firstArg(args, names) {
     return undefined;
 }
 
+const _GREP_CONTEXT_GROUPS = [
+    ['-A', ['-A', 'A', 'after', 'after_context', 'afterContext', '--after-context', 'after-context', 'afterLines', 'after_lines']],
+    ['-B', ['-B', 'B', 'before', 'before_context', 'beforeContext', '--before-context', 'before-context', 'beforeLines', 'before_lines']],
+    ['context', ['context', '-C', 'C', 'context_lines', 'contextLines', '--context', 'contextN', 'around', 'surrounding']],
+];
+
+function _canonicalizeGrepContextArgs(args) {
+    for (const [canonical, aliases] of _GREP_CONTEXT_GROUPS) {
+        const value = _firstArg(args, aliases);
+        for (const alias of aliases) delete args[alias];
+        if (value === undefined) continue;
+        const numeric = typeof value === 'string' && value.trim() !== '' ? Number(value) : value;
+        args[canonical] = Number.isFinite(numeric) && Number.isInteger(numeric) ? numeric : value;
+    }
+}
+
 function _canonicalToolArgs(toolName, args) {
     if (!args || typeof args !== 'object') return args;
     const next = { ...args };
@@ -59,12 +76,35 @@ function _canonicalToolArgs(toolName, args) {
             const alias = _firstArg(next, ['root', 'directory', 'dir']);
             if (alias !== undefined) next.path = alias;
         }
+        _canonicalizeGrepContextArgs(next);
         if ((next.output_mode === undefined || next.output_mode === null || next.output_mode === '') && typeof next.mode === 'string') {
             const mode = next.mode.trim();
-            if (['files_with_matches', 'content', 'count'].includes(mode)) next.output_mode = mode;
+            if (['files_with_matches', 'content', 'content_with_context', 'count'].includes(mode)) next.output_mode = mode;
         }
         for (const k of ['query', 'regex', 'regexp', 'needle', 'search', 'literal', 'file_pattern', 'filePattern', 'include', 'includes', 'files', 'root', 'directory', 'dir']) delete next[k];
-        if (next.output_mode && next.mode === next.output_mode) delete next.mode;
+        delete next.mode;
+
+        // Canonicalize by execution semantics, not caller spelling:
+        // omitted/content_with_context => content + automatic 25-line context;
+        // context:0 => bare content; context flags are ignored in count/files.
+        const requestedMode = typeof next.output_mode === 'string' ? next.output_mode.trim() : '';
+        if (requestedMode === 'files_with_matches' || requestedMode === 'count') {
+            next.output_mode = requestedMode;
+            delete next['-A'];
+            delete next['-B'];
+            delete next.context;
+        } else {
+            const hasExplicitContext = ['-A', '-B', 'context']
+                .some((key) => Object.prototype.hasOwnProperty.call(next, key));
+            next.output_mode = 'content';
+            if ((requestedMode === '' || requestedMode === 'content_with_context') && !hasExplicitContext) {
+                next.context = GREP_AUTO_CONTEXT_LINES;
+            }
+            if (next.context === 0 && !Object.prototype.hasOwnProperty.call(next, '-A')
+                && !Object.prototype.hasOwnProperty.call(next, '-B')) {
+                delete next.context;
+            }
+        }
     } else if (toolName === 'glob') {
         if (next.pattern === undefined || next.pattern === null || next.pattern === '') {
             const alias = _firstArg(next, ['glob', 'file_pattern', 'filePattern', 'name', 'include', 'includes', 'files']);

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

@@ -1,18 +1,18 @@
 // 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. 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.
+// the mutation epoch. Read-only calls may start while the provider is still
+// streaming. Side-effect calls stream-start too until the first apply_patch
+// appears in the stream (they are definitively in segment 0); after that they
+// wait for their segment bounded by apply_patch barriers. Patches execute
+// serially as barriers, so a failed patch can skip every later side effect.
 import { normalizeToolEnvelope } from './tool-envelope.mjs';
 import { isInvalidToolArgsMarker } from '../providers/openai-compat-stream.mjs';
-import { _intraTurnSig, _isMutationTool, _isReadTool, _isScopedCacheableTool, _isShellTool, _stripMcpPrefix } from './loop/tool-classify.mjs';
+import { _intraTurnSig, _isMutationTool, _isOrderedGateSkippable, _isReadTool, _isScopedCacheableTool, _stripMcpPrefix } from './loop/tool-classify.mjs';
 import { tryReadCached, tryScopedToolCached } from './read-dedup.mjs';
 import { preDispatchDenyForSession } from './loop/pre-dispatch-deny.mjs';
 import { executeTool } from './loop/tool-exec.mjs';
 import { crossTurnSignature } from './loop/completion-guards.mjs';
-import { getToolKind, isParallelDispatchable, isToolCallDedupEligible } from './loop/tool-helpers.mjs';
+import { getToolKind, isEagerDispatchable, isParallelDispatchable, isToolCallDedupEligible } from './loop/tool-helpers.mjs';
 
 export function createEagerDispatcher({
     tools, cwd, sessionId, sessionRef, signal, opts,
@@ -40,18 +40,11 @@ export function createEagerDispatcher({
         // resets at the turn boundary without leaking across getIterations().
         const _eagerInFlightSigs = new Map();
         const epoch = { mutation: 0 };
-        // Patch→shell ordering insurance: a shell call that appears AFTER an
-        // apply_patch in the same assistant turn must not eager-start before
-        // that patch has executed (serial body runs both in call order).
-        // Reads are already safe via the mutationEpoch re-execution gate;
-        // only shell's side effects would consume pre-patch file state.
-        let _streamSawMutation = false;
-        const _hasEarlierMutation = (calls, index) => {
-            for (let k = 0; k < index; k += 1) {
-                if (_isMutationTool(calls[k]?.name)) return true;
-            }
-            return false;
-        };
+        // True once an apply_patch tool_use has been seen in THIS turn's
+        // stream. Before that, every side-effect call streamed so far sits
+        // before the first patch in call order (segment 0), so it may start
+        // immediately — a patch that arrives later cannot gate an EARLIER call.
+        let _streamSeenMutation = false;
         const startEagerTool = (call) => {
             if (!call?.id || pending.has(call.id) || !isParallelDispatchable(call.name)) return null;
             // Never eager-execute a call whose arguments failed to parse
@@ -107,7 +100,7 @@ export function createEagerDispatcher({
             if (_dedupEligible) _eagerInFlightSigs.set(_sig, call.id);
             entry.promise = (async () => {
                 try {
-                    return { ok: true, value: await executeToolFn(call.name, call.arguments, cwd, sessionId, sessionRef, { toolCallId: call.id, signal, notifyFn: opts.notifyFn, toolApprovalHook: opts.onToolApproval, iteration: getNextIteration() }) };
+                    return { ok: true, value: await executeToolFn(call.name, call.arguments, cwd, sessionId, sessionRef, { toolCallId: call.id, signal, notifyFn: opts.notifyFn, toolApprovalHook: opts.onToolApproval, iteration: getNextIteration(), deferShellCwdCommit: true }) };
                 } catch (error) {
                     return { ok: false, error };
                 }
@@ -168,16 +161,21 @@ export function createEagerDispatcher({
             return entry;
         };
         const startEagerRun = (calls, startIndex, dupSet) => {
+            const _nextOrderedMutationIndex = calls.findIndex(
+                (call, index) => index >= startIndex && _isMutationTool(call?.name),
+            );
             for (let j = startIndex; j < calls.length; j += 1) {
                 const call = calls[j];
-                // 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.
+                // Side effects may eager-start in the current segment but not
+                // across the next apply_patch barrier. Known read-only work
+                // may cross it and is protected by mutation-epoch re-execution.
                 if (!call?.id || !isParallelDispatchable(call.name)) continue;
                 if (dupSet && dupSet.has(call.id)) continue;
-                // Patch→shell insurance: leave a shell that follows an
-                // apply_patch to the serial body so it runs after the patch.
-                if (_isShellTool(call.name) && _hasEarlierMutation(calls, j)) continue;
+                if (
+                    _nextOrderedMutationIndex >= 0
+                    && j >= _nextOrderedMutationIndex
+                    && _isOrderedGateSkippable(call.name)
+                ) continue;
                 // A null return here is NOT a state barrier. It means a
                 // non-barrier stub — intra-turn in-flight dup, repeat-failure /
                 // cross-turn dedup, pre-dispatch-deny, invalid-args, or a cache
@@ -188,9 +186,17 @@ export function createEagerDispatcher({
             }
         };
         const onToolCall = (call) => {
-            if (_isMutationTool(call?.name)) { _streamSawMutation = true; return; }
-            if (!isParallelDispatchable(call?.name)) return;
-            if (_streamSawMutation && _isShellTool(call.name)) return;
+            if (_isMutationTool(call?.name)) {
+                _streamSeenMutation = true;
+                return;
+            }
+            // Declared read-only calls always overlap streaming (epoch guard
+            // re-executes them if a later patch lands). Side-effect calls may
+            // stream-start only while NO apply_patch has streamed yet: their
+            // call-order position is already fixed before the first barrier,
+            // matching exactly what startEagerRun would do post-batch. Once a
+            // patch has streamed, later side effects wait for their segment.
+            if (!isEagerDispatchable(call?.name, tools) && _streamSeenMutation) return;
             startEagerTool(call);
         };
     return { pending, epoch, startEagerTool, startEagerRun, onToolCall };

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

@@ -59,6 +59,9 @@ function compactStoredToolArgString(value, key = '', opts = {}) {
     const isLong = isBody || STORED_TOOL_ARG_LONG_KEY_RE.test(key);
     const limit = isLong ? STORED_TOOL_ARG_LIMIT : Infinity;
     if (value.length <= limit) return value;
+    // A marker is about to replace verbatim text — report the mutation so
+    // sweep callers can tag the resulting prefix-cache break.
+    try { opts.onCompacted?.(); } catch { /* observability only */ }
     const hash = createHash('sha256').update(value).digest('hex').slice(0, 16);
     // Body markers carry the recovery instruction inline: the compaction
     // detectors only require the `[mixdog compacted ...]` shape (no ']' or
@@ -115,14 +118,19 @@ export function compactToolCallsForHistory(calls, opts = {}) {
 //     contract as restoreToolCallBodyForId);
 //   - a call with no result row yet (current batch / interrupted turn) is
 //     left untouched.
+// Returns true when at least one body was actually collapsed to a marker
+// (i.e. the transcript prefix changed), so callers can tag the intentional
+// cache break instead of logging an unexplained input_prefix_mismatch.
 export function compactSettledToolCallBodies(messages) {
-    if (!Array.isArray(messages)) return;
+    if (!Array.isArray(messages)) return false;
     const resultKinds = new Map();
     for (const message of messages) {
         if (message?.role === 'tool' && message.toolCallId) {
             resultKinds.set(message.toolCallId, message.toolKind || 'normal');
         }
     }
+    let changed = false;
+    const sweepOpts = { onCompacted: () => { changed = true; } };
     for (const message of messages) {
         if (message?.role !== 'assistant' || !Array.isArray(message.toolCalls)) continue;
         for (const call of message.toolCalls) {
@@ -130,9 +138,10 @@ export function compactSettledToolCallBodies(messages) {
             if (!call.arguments || typeof call.arguments !== 'object') continue;
             const kind = call.id ? resultKinds.get(call.id) : undefined;
             if (kind === undefined || kind === 'error') continue;
-            call.arguments = compactStoredToolArgValue(call.arguments);
+            call.arguments = compactStoredToolArgValue(call.arguments, '', 0, sweepOpts);
         }
     }
+    return changed;
 }
 
 // Restore retry-safe long command/script text for ONE failed tool call inside a

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

@@ -15,12 +15,11 @@ 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.
+// Side-effect-free read-only tools that may eager-start across an upcoming
+// apply_patch barrier and may keep running after an earlier patch fails.
+// Everything NOT in this set waits for its side-effect segment and is skipped
+// after a failed patch. Kept separate from _isMutationTool, which stays
+// apply_patch-only for epoch counting.
 const ORDERED_GATE_SAFE_READONLY_TOOLS = new Set([
     'read',
     'find',

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

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

package/src/runtime/agent/orchestrator/session/manager/compaction-runner.mjs

@@ -25,6 +25,7 @@ import {
     compactTypeForSession,
 } from './context-meta.mjs';
 import { resolveSemanticSummaryModel } from '../loop/compact-policy.mjs';
+import { traceAgentCompact, messagePrefixHash } from '../../agent-trace.mjs';
 import { uncachedInputTokensForProvider } from './usage-metrics.mjs';
 import { pruneOffloadSession } from '../tool-result-offload.mjs';
 import { _getPendingMessagesForSession } from './pending-messages.mjs';
@@ -302,6 +303,7 @@ export async function runSessionCompaction(session, opts = {}) {
         semanticCompact: false,
     };
     const budget = targetBudgetTokens;
+    const compactStartedAt = Date.now();
     try { await opts.onStageChange?.('compacting'); } catch { /* best-effort */ }
     const provider = opts.provider || getProvider(session.provider) || null;
     let compacted;
@@ -486,6 +488,31 @@ export async function runSessionCompaction(session, opts = {}) {
             lastRecallFastTrackError: recallFastTrackError?.message || null,
             lastError: compactError?.message || semanticCompactError?.message || recallFastTrackError?.message || String(compactError || semanticCompactError || recallFastTrackError || 'compact failed'),
         };
+        // compact_meta parity with the loop's pre-send pass: the out-of-loop
+        // (post-turn/manual) compaction failure was previously invisible to
+        // trace analytics.
+        traceAgentCompact({
+            sessionId: opts.sessionId || session.id || null,
+            stage: mode === 'auto' ? 'post_turn' : 'manual',
+            trigger: mode,
+            compact_type: compactType,
+            compact_changed: false,
+            before_count: messages.length,
+            after_count: messages.length,
+            context_window: positiveContextWindow(session.contextWindow) || null,
+            budget_tokens: boundary,
+            boundary_tokens: boundary,
+            target_budget_tokens: budget,
+            reserve_tokens: reserveTokens,
+            pressure_tokens: pressureTokens,
+            trigger_tokens: triggerTokens,
+            message_tokens_est: beforeMessageTokens,
+            duration_ms: Date.now() - compactStartedAt,
+            provider: session.provider || null,
+            model: session.model || null,
+            error: session.compaction.lastError,
+            error_code: 'compact_failed',
+        });
         return {
             changed: false,
             error: session.compaction.lastError,
@@ -574,6 +601,39 @@ export async function runSessionCompaction(session, opts = {}) {
         compactCount: (session.compaction?.compactCount || 0) + (changed ? 1 : 0),
     };
     if (changed) invalidateProviderContextBaseline(session);
+    // Observability parity with the loop's pre-send pass: record the
+    // out-of-loop mutation as compact_meta and park a one-shot intent so the
+    // next turn's first send tags its cache break instead of logging an
+    // unexplained input_prefix_mismatch (observed live: a 403k→10k post-turn
+    // compact traced as intentional_transition: null with no compact_meta).
+    let beforePrefixHash = null;
+    try { beforePrefixHash = messagePrefixHash(messages); } catch { /* best-effort */ }
+    traceAgentCompact({
+        sessionId: pruneSessionId || null,
+        stage: mode === 'auto' ? 'post_turn' : 'manual',
+        trigger: mode,
+        compact_type: compactType,
+        compact_changed: changed,
+        input_prefix_hash: beforePrefixHash,
+        before_count: messages.length,
+        after_count: compacted.length,
+        before_bytes: beforeEncoded ? Buffer.byteLength(beforeEncoded, 'utf8') : null,
+        after_bytes: afterEncoded ? Buffer.byteLength(afterEncoded, 'utf8') : null,
+        context_window: positiveContextWindow(session.contextWindow) || null,
+        budget_tokens: boundary,
+        boundary_tokens: boundary,
+        target_budget_tokens: budget,
+        reserve_tokens: reserveTokens,
+        pressure_tokens: pressureTokens,
+        trigger_tokens: triggerTokens,
+        message_tokens_est: beforeMessageTokens,
+        duration_ms: Date.now() - compactStartedAt,
+        provider: session.provider || null,
+        model: session.model || null,
+    });
+    if (changed) {
+        session.pendingCacheBreakIntent = mode === 'auto' ? 'post_turn_compaction' : 'manual_compaction';
+    }
     return {
         changed,
         reason: unchangedReason,