mixdog 1.0.9 → 1.0.11

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

@@ -16,8 +16,8 @@ import { HANDOFF_TIMEOUT_MAX_MS } from '../compact/constants.mjs';
 import { envFlag, envPositiveInt } from '../../../../shared/env.mjs';
 import { positiveInt } from '../../../../shared/numbers.mjs';
 import { isAgentOwner } from '../../agent-owner.mjs';
-import { providerInputExcludesCache } from '../../providers/registry.mjs';
-import { contentMediaBytes } from '../../providers/media-normalization.mjs';
+import { providerInputExcludesCache, providerNativePdf } from '../../providers/registry.mjs';
+import { contentMediaBytes, contentMediaCount } from '../../providers/media-normalization.mjs';
 
 // Unified context-share rule (compact/constants.mjs CONTEXT_SHARE_RATIO): the
 // post-compaction target is 25% of the boundary/context window. One
@@ -547,6 +547,17 @@ export function resolveGaugeContextTokens(messageTokensEst, policy, { messages,
   return resolveContextTokens(messageTokensEst, policy, { messages, sessionRef });
 }
 
+/**
+ * The "before" number a compaction row shows: the context the provider last
+ * measured, as the gauge displayed it. Falls back to the pass's own value only
+ * when no live reading exists (none yet, or invalidated by a prior compaction).
+ */
+export function compactDisplayBeforeTokens(sessionRef, fallbackTokens) {
+  const lastContextTokens = positiveInt(sessionRef?.lastContextTokens);
+  if (lastContextTokens && sessionRef.lastContextTokensStaleAfterCompact !== true) return lastContextTokens;
+  return fallbackTokens;
+}
+
 export function resolveCompactionPressureTokens(messageTokensEst, policy, { messages, sessionRef } = {}) {
   return resolveContextTokens(messageTokensEst, policy, { messages, sessionRef });
 }
@@ -591,13 +602,20 @@ export function compactTargetBudget(policy) {
 // part compaction drops, so it alone arms this trigger; attachments the user
 // sent survive compaction and would only make it repeat.
 const REQUEST_MEDIA_COMPACT_BYTES = 24_000_000;
+// Providers also cap the number of images plus native documents one request
+// may carry (100 on Anthropic); the same tool-result media arms the trigger.
+const REQUEST_MEDIA_COMPACT_COUNT = 100;
 
-export function shouldCompactForRequestMedia(messages) {
+export function shouldCompactForRequestMedia(messages, provider = '') {
+  // A PDF that lowers to text is neither bytes nor a document on the wire.
+  const nativePdf = providerNativePdf(provider);
   let bytes = 0;
+  let count = 0;
   for (const message of messages) {
     if (message?.role !== 'tool') continue;
-    bytes += contentMediaBytes(message.content);
-    if (bytes >= REQUEST_MEDIA_COMPACT_BYTES) return true;
+    bytes += contentMediaBytes(message.content, { nativePdf });
+    count += contentMediaCount(message.content, { nativePdf });
+    if (bytes >= REQUEST_MEDIA_COMPACT_BYTES || count > REQUEST_MEDIA_COMPACT_COUNT) return true;
   }
   return false;
 }

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

@@ -48,6 +48,7 @@ export async function prepareProviderRequest(state) {
     cwd,
     opts,
     signal,
+    crossTurnCalls,
     loopUsageMetricsTurnId,
     loopUsageMetricsEpoch,
   } = state;
@@ -101,6 +102,7 @@ export async function prepareProviderRequest(state) {
         firstTurnUsage,
         providerState,
         reactiveOverflowRetryPending,
+        crossTurnCalls,
         loopUsageMetricsTurnId,
         loopUsageMetricsEpoch,
         skipProactiveCompact: compactAttempted,

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

@@ -64,6 +64,7 @@ export async function beginIteration(state) {
     providerState: state.providerState,
     reactiveOverflowRetryPending: state.reactiveOverflowRetryPending,
     fixedProviderToolSurface: state.fixedProviderToolSurface,
+    crossTurnCalls: state.crossTurnCalls,
     loopUsageMetricsTurnId: state.usageMetricsTurnId,
     loopUsageMetricsEpoch: state.usageMetricsEpoch,
   });
@@ -234,17 +235,78 @@ function settleImageStrip(state, round, sent) {
   state.imageStrip = null;
 }
 
+const MESSAGES_CACHE_TTL_MS = { '5m': 5 * 60 * 1000, '1h': 60 * 60 * 1000 };
+const MISS_RATIO = 0.5;
+const MISS_MIN_DROP_TOKENS = 4096;
+
+/** Usage-based prompt-cache miss detection for Anthropic sessions. The
+ *  baseline (previous request's cache read + write) lives on the session
+ *  record so it survives a reload, unlike the in-memory prefix guard. */
+function traceActualCacheMiss(state, sent, response, { previousGuardState, previousSendAt, cacheBreakIntent }) {
+  const { sessionRef, sessionId, model } = state;
+  const providerName = sessionRef?.provider || state.provider?.name || null;
+  if (!sessionRef || (providerName !== 'anthropic' && providerName !== 'anthropic-oauth')) return;
+  const usage = response?.usage || {};
+  const cachedTokens = Number(usage.cachedTokens) || 0;
+  const cachePrefixTokens = cachedTokens + (Number(usage.cacheWriteTokens) || 0);
+  const baseline = Number(sessionRef.lastProviderCachedPrefixTokens);
+  const ttlMs = MESSAGES_CACHE_TTL_MS[sessionRef.providerCacheOpts?.cacheStrategy?.messages];
+  const idleMs = sent.sendStartedAt - previousSendAt;
+  const requestPrefixChanged =
+    !!previousGuardState &&
+    previousGuardState.requestPrefixHash !== sent.prefixGuardCandidate?.requestPrefixHash;
+  if (
+    baseline > 0 &&
+    ttlMs &&
+    Number.isFinite(idleMs) &&
+    idleMs >= 0 &&
+    idleMs < ttlMs &&
+    cachedTokens < baseline * MISS_RATIO &&
+    baseline - cachedTokens >= MISS_MIN_DROP_TOKENS &&
+    !cacheBreakIntent &&
+    !requestPrefixChanged
+  ) {
+    traceCacheBreak(
+      {
+        sessionId,
+        iteration: state.iterations + 1,
+        classification: 'unexpected',
+        reason: 'actual_cache_miss',
+        source: 'provider_usage',
+        provider: providerName,
+        model: model || null,
+        actualCacheMiss: true,
+        cachedTokens,
+        promptTokens: Number(usage.promptTokens) || null,
+        previousCachedPrefixTokens: baseline,
+        idleMs,
+        missingPrefixGuardBaseline: !previousGuardState,
+      },
+      state.cacheBreakTraceOptions
+    );
+  }
+  sessionRef.lastProviderCachedPrefixTokens = cachePrefixTokens;
+}
+
 /** Fold a completed send into the state: prefix guard, image-strip
  *  rebaseline, per-request budgets, provider state, usage and diagnostics. */
 export function settleSendResult(state, round, sent) {
   const { opts, sessionRef, sessionId, model, messages } = state;
   const response = sent.result.response;
   state.response = response;
+  const previousGuardState = state.prefixGuardState;
+  const previousSendAt = Number(sessionRef?.lastProviderSendAt);
+  const cacheBreakIntent = opts.cacheBreakIntent;
   state.prefixGuardState = sent.prefixGuardCandidate;
   if (sessionRef) sessionRef._providerPrefixGuardState = state.prefixGuardState;
   // The provider read and refreshed its prompt cache when this request was
   // sent; agent cache-expiry compaction measures idle time from here.
   if (sessionRef) sessionRef.lastProviderSendAt = sent.sendStartedAt;
+  traceActualCacheMiss(state, sent, response, {
+    previousGuardState,
+    previousSendAt,
+    cacheBreakIntent,
+  });
   if (state.imageStrip) settleImageStrip(state, round, sent);
   opts.onToolCall = undefined;
   delete opts.cacheBreakIntent;

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

@@ -0,0 +1,79 @@
+// Auto effort for one user turn. The Auto effort built-in (Extensions →
+// Built-in) turns it `on`: the judged effort applies to this turn. The
+// MIXDOG_AUTO_EFFORT env value (off/observe/on) overrides it for diagnostics;
+// `observe` judges and logs without applying. Applies only to user-written
+// prompts on models whose effort can change mid-conversation without
+// invalidating the prompt cache.
+import { readSection } from '../../../../shared/config.mjs';
+import { effortConfigurationMode } from '../../providers/effort-configuration.mjs';
+import { autoEffortBase, normalizeAutoEffortMode, resolveAutoEffort } from '../../providers/auto-effort.mjs';
+import { builtinFeatureActive } from '../../runtime-core/builtin-features.mjs';
+import { effortOptionsFor } from '../../runtime-core/effort.mjs';
+import { judgeTurn, recordEffortDecision } from '../../../../effort-judge/judge-client.mjs';
+import { promptContentText } from './prompt-utils.mjs';
+
+export function autoEffortMode() {
+  if (process.env.MIXDOG_AUTO_EFFORT) return normalizeAutoEffortMode(process.env.MIXDOG_AUTO_EFFORT);
+  try {
+    return builtinFeatureActive(readSection('agent'), 'autoEffort') ? 'on' : 'off';
+  } catch {
+    return 'off';
+  }
+}
+
+function lastAssistantText(messages) {
+  for (let i = (messages?.length || 0) - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message?.role !== 'assistant') continue;
+    const text = promptContentText(message.content).trim();
+    if (text) return text;
+  }
+  return '';
+}
+
+/**
+ * `{ base, effort, step, level, confidence, applied }` for this turn, or null
+ * when auto effort does not apply. The judge never delays the turn: a missing,
+ * warming, or slow model yields null and the default effort.
+ */
+export async function resolveTurnAutoEffort({ sessionId, session, provider, input }) {
+  const mode = autoEffortMode();
+  // promptSource marks runtime-injected turns (completion notices, queued work);
+  // agent-owned sessions (workers, maintenance) receive runtime-written briefs.
+  if (mode === 'off' || input?.promptSource || session?.owner === 'agent') return null;
+  const request = promptContentText(input?.prompt).trim();
+  // Skill bodies and runtime blocks arrive as tagged text, not as a request.
+  if (!request || request.startsWith('<')) return null;
+  const opts = { ...(provider?.config || {}), modelParameters: session.modelParameters || {} };
+  if (!effortConfigurationMode(session.provider, session.model, opts)) return null;
+  const chosen = String(session.effort || '').toLowerCase();
+  const base = autoEffortBase(chosen);
+  const judged = await judgeTurn({ request, prev: lastAssistantText(session.messages) });
+  const record = {
+    at: new Date().toISOString(),
+    sessionId,
+    provider: session.provider,
+    model: session.model,
+    mode,
+    chosen,
+    base,
+    requestChars: request.length,
+  };
+  if (!judged.probs) {
+    recordEffortDecision({ ...record, skipped: judged.skipped });
+    return null;
+  }
+  const resolved = resolveAutoEffort({
+    base,
+    options: effortOptionsFor(session.provider, { id: session.model }),
+    probs: judged.probs,
+  });
+  recordEffortDecision({
+    ...record,
+    ...(resolved || { skipped: 'default-outside-auto-range' }),
+    ms: judged.ms,
+    probs: judged.probs.map((value) => Number(value.toFixed(3))),
+  });
+  if (!resolved) return null;
+  return { ...resolved, applied: mode === 'on' && resolved.effort !== chosen };
+}

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

@@ -7,6 +7,7 @@
 import { getProvider } from '../../providers/registry.mjs';
 import { prepareExplicitSkills } from '../explicit-skills.mjs';
 import { prepareTurnEffortConfiguration } from '../../providers/effort-configuration.mjs';
+import { resolveTurnAutoEffort } from './ask-turn-auto-effort.mjs';
 import { saveSessionAsync } from '../store.mjs';
 import { hasUserConversationMessage, refreshSessionBp3Environment } from './prompt-utils.mjs';
 import { filterModelVisibleSessionMessages } from './message-sanitize.mjs';
@@ -26,8 +27,13 @@ export async function prepareAskTurn({ sessionId, opened, input, cwdOverride, tr
   // Register the live session object for synchronous close snapshots.
   runtime.session = session;
   if (!provider) throw new Error(`Provider "${session.provider}" not available`);
-  const turnEffort = session.effort || null;
-  const effortConfiguration = prepareTurnEffortConfiguration(session, provider);
+  const autoEffort = await resolveTurnAutoEffort({ sessionId, session, provider, input });
+  const turnEffort = autoEffort?.applied ? autoEffort.effort : session.effort || null;
+  const effortConfiguration = prepareTurnEffortConfiguration(
+    session,
+    provider,
+    autoEffort?.applied ? autoEffort.effort : undefined
+  );
   applyTurnContextMeta(session, provider);
   const effectiveCwd = cwdOverride || session.cwd;
   // A failed-turn retry resubmits the prompt the failure left unanswered;
@@ -113,6 +119,8 @@ export async function prepareAskTurn({ sessionId, opened, input, cwdOverride, tr
     effectiveCwd,
     turnEffort,
     effortConfiguration,
+    // The effort Auto picked for this turn, shown next to the turn's result.
+    autoEffort: autoEffort ? autoEffort.effort : null,
     outgoing,
     beforeCount: historyMessages.length + 1,
     deferredToolDelta: userTurn.deferredToolDelta,

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

@@ -59,7 +59,12 @@ function attachAssistantTranscriptCompletion(messages, completion, turnStartedAt
         ...meta,
         transcript: {
           ...transcript,
-          completion: { status, verb, elapsedMs },
+          completion: {
+            status,
+            verb,
+            elapsedMs,
+            ...(typeof completion.autoEffort === 'string' && completion.autoEffort ? { autoEffort: completion.autoEffort } : {}),
+          },
         },
       },
     };
@@ -122,6 +127,7 @@ export async function commitAskTurn({ sessionId, opened, prepared, result, rawTr
     ...result,
     trimmed: messagesDropped > 0,
     messagesDropped,
+    ...(prepared.autoEffort ? { autoEffort: prepared.autoEffort } : {}),
   };
 }
 
@@ -144,6 +150,7 @@ export function publishAskTurn({ sessionId, opened, terminalResultPreview, askOp
         status: 'done',
         verb: rawTranscriptMeta?.completionVerb,
         elapsedMs: Date.now() - turnStartedAt,
+        autoEffort: terminalResultPreview?.autoEffort,
       },
       turnStartedAt
     );

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

@@ -23,6 +23,7 @@ import { isSessionCompactionBlocked } from './runtime-liveness.mjs';
 import { resetReadStateAfterCompaction } from '../read-dedup.mjs';
 import {
   compactTargetBudget as compactTargetBudgetForPolicy,
+  compactDisplayBeforeTokens,
   currentContextEstimateTokens,
   invalidateProviderContextBaseline,
   recordContextUsageSnapshot,
@@ -233,10 +234,12 @@ function compactionPlanNumbers({ session, messages, boundary, alignedPolicy, for
     (boundary ? bufferTokens / boundary : resolveCompactBufferRatio(session.compaction || {}));
   const budget = alignedPolicy ? compactTargetBudgetForPolicy({ ...alignedPolicy, force }) || boundary : boundary;
   const pressureTokens = estimateTranscriptContextUsage(messages, session.tools || [], { provider: session.provider });
-  const beforeTokens =
+  const beforeTokens = compactDisplayBeforeTokens(
+    session,
     (alignedPolicy
       ? resolveGaugeContextTokens(beforeMessageTokens, alignedPolicy, { messages, sessionRef: session })
-      : 0) || pressureTokens;
+      : 0) || pressureTokens
+  );
   return { beforeMessageTokens, triggerTokens, bufferTokens, bufferRatio, budget, pressureTokens, beforeTokens };
 }
 
@@ -689,7 +692,7 @@ export async function runSessionCompaction(session, opts = {}) {
     });
   }
   plan.requireReduction =
-    (plan.mode === 'auto' || opts.requireReduction === true) && !shouldCompactForRequestMedia(plan.messages);
+    (plan.mode === 'auto' || opts.requireReduction === true) && !shouldCompactForRequestMedia(plan.messages, session.provider);
   const skipped = () =>
     compactionResult(plan, { changed: false, skipped: true, reason: 'no_token_reduction' }, unchangedAfter(plan), {
       freshContext: false,

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

@@ -9,7 +9,11 @@ import { _isActivelyOwnedElsewhere, _recoverTurnCheckpointDurably } from './sess
 import { isAgentOwner } from '../../agent-owner.mjs';
 import { getHiddenAgent } from '../../internal-agents.mjs';
 import { loadConfig } from '../../config.mjs';
-import { buildProviderCacheOpts, cacheCapabilityForProvider } from '../../agent-runtime/cache-strategy.mjs';
+import {
+  buildProviderCacheOpts,
+  cacheCapabilityForProvider,
+  roleProviderCacheOpts,
+} from '../../agent-runtime/cache-strategy.mjs';
 import { normalizeAutoClearConfig, resolveAutoClearIdleMs } from '../../runtime-core/config-helpers.mjs';
 import { _buildBaseRules } from './rules-cache.mjs';
 import { composeSessionSystem, seedSessionMessages } from './session-prompt-composition.mjs';
@@ -43,8 +47,11 @@ export { prefetchSession, prepareSessionProjection } from './prepared-resume-cac
 function buildSessionProviderCacheOpts(providerName, sessionId, agent = null) {
   // Keep this in sync with createSession's provider-cache policy: only
   // explicit-breakpoint providers get BP cache opts here; OpenAI/key-prefix
-  // providers use promptCacheKey and request-time strategy instead.
-  if (cacheCapabilityForProvider(providerName) !== 'explicit-breakpoint') return null;
+  // providers use promptCacheKey and request-time strategy instead, plus the
+  // shared prompt-cache scope of a one-shot role.
+  if (cacheCapabilityForProvider(providerName) !== 'explicit-breakpoint') {
+    return roleProviderCacheOpts(providerName, agent);
+  }
   try {
     let autoClear = null;
     if (!agent || agent === 'lead') {

package/src/runtime/agent/orchestrator/session/manager/session-prompt-composition.mjs

@@ -88,7 +88,11 @@ export function composeSessionSystem(opts, { profile, providerName, modelName, s
   // Lead-only response language; closes the environment block so no English
   // system text (session/shell/git lines) follows it.
   const languageContext = leadOnly ? _buildLeadLanguageContext() : '';
-  const shellEnvironmentContext = buildShellEnvironmentContext(opts, ownerIsAgent, surface.toolsForRouting);
+  // Cwd, shell and repository facts only serve tool calls; a tool-free role
+  // gets none, which also keeps its prompt identical across projects.
+  const shellEnvironmentContext = toolFreeRole
+    ? ''
+    : buildShellEnvironmentContext(opts, ownerIsAgent, surface.toolsForRouting);
   // Persisted env tail: refreshSessionBp3Environment rebuilds the env block
   // as [session, bp3EnvironmentContext], so the language block must
   // already sit at the end of this string to stay last after a refresh.

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

@@ -5,6 +5,7 @@
 import {
   resolveWorkerCompactPolicy,
   compactionTelemetryPressureTokens,
+  compactDisplayBeforeTokens,
   currentContextEstimateTokens,
   compactTargetBudget,
   shouldCompactForRequestMedia,
@@ -17,6 +18,8 @@ import {
 } from './loop/compact-policy.mjs';
 import { previewFreshContextCompaction, runFreshContextCompact } from './loop/fresh-context.mjs';
 import { estimateMessagesTokensSafe } from './loop/compact-debug.mjs';
+import { textPdfAllowanceDiscount } from './context-utils.mjs';
+import { providerNativePdf } from '../providers/registry.mjs';
 import { messagesArrayChanged } from './loop/tool-helpers.mjs';
 import { normalizeUsage, addUsage } from './loop/usage.mjs';
 import { reasoningUsage } from '../../../shared/llm/reasoning-usage.mjs';
@@ -66,6 +69,13 @@ function transcriptPrefixHash(messages) {
   }
 }
 
+// The transcript estimate prices every PDF as a native document; a provider
+// that takes PDFs as text sends at most the extraction budget instead.
+function providerAwareTokens(tokens, messages, sessionRef) {
+  if (tokens == null || providerNativePdf(sessionRef?.provider)) return tokens;
+  return Math.max(0, tokens - textPdfAllowanceDiscount(messages));
+}
+
 // The compaction decision for this send. `pressureTokens` is the exact
 // canonical value the decision uses; reactive overflow recovery floors it at
 // the trigger so the gauge, telemetry, and forced compact still describe the
@@ -76,7 +86,7 @@ function transcriptPrefixHash(messages) {
 // proactive triggers still need a smaller predicted transcript.
 function preSendCompactDecision(state, compactPolicy) {
   const { messages, sessionRef } = state;
-  const messageTokensEst = estimateMessagesTokensSafe(messages);
+  const messageTokensEst = providerAwareTokens(estimateMessagesTokensSafe(messages), messages, sessionRef);
   const reactivePending = state.reactiveOverflowRetryPending === true;
   const pressureTokens = compactionTelemetryPressureTokens(messageTokensEst, compactPolicy, {
     reactivePending,
@@ -84,7 +94,7 @@ function preSendCompactDecision(state, compactPolicy) {
     sessionRef,
   });
   const cacheExpired = shouldCompactForExpiredAgentCache(sessionRef, state.opts);
-  const mediaPressure = shouldCompactForRequestMedia(messages);
+  const mediaPressure = shouldCompactForRequestMedia(messages, sessionRef?.provider);
   const requireReduction = !reactivePending && !mediaPressure;
   let shouldCompact =
     state.skipProactiveCompact !== true &&
@@ -209,7 +219,7 @@ function emitCompact(ctx, extra) {
     sessionId: state.sessionId,
     stage: 'pre_send',
     trigger: decision.compactTrigger,
-    beforeTokens: decision.pressureTokens,
+    beforeTokens: compactDisplayBeforeTokens(state.sessionRef, decision.pressureTokens),
     beforeMessages: before.count,
     afterMessages: state.messages.length,
     pressureTokens: decision.pressureTokens,
@@ -369,11 +379,17 @@ function throwCompactFailure(ctx, run, compactErr) {
 // Replaces the live transcript with the compacted one and resets everything
 // keyed to the old transcript shape.
 function adoptCompactedTranscript(ctx, run) {
-  const { messages, sessionRef, sessionId, opts } = ctx.state;
+  const { state } = ctx;
+  const { messages, sessionRef, sessionId, opts } = state;
   messages.length = 0;
   messages.push(...run.compacted);
   acknowledgeGoalReminder(sessionRef, run);
   resetReadStateAfterCompaction(sessionId);
+  // Cross-turn receipts reference tool results that compaction just removed
+  // from context; a stub for them would point at nothing. Clear in place so
+  // the eager dispatcher sharing this map observes it. Cached bodies stay
+  // reusable and are re-delivered (and re-recorded) on the next identical call.
+  state.crossTurnCalls?.clear();
   // This attempt's provider-tool scope was keyed to the old transcript
   // shape. Invalidate it synchronously before any post-compact callback or
   // subsequent async continuation.
@@ -402,7 +418,7 @@ function reportCompactOutcome(ctx, run) {
   const { messages, sessionRef } = state;
   const changed = ctx.compactChanged || run.summaryChanged;
   const { freshContextResult } = run;
-  const afterMessageTokensEst = estimateMessagesTokensSafe(messages);
+  const afterMessageTokensEst = providerAwareTokens(estimateMessagesTokensSafe(messages), messages, sessionRef);
   // Same scale as the pre-compact gauge: compaction invalidated the provider
   // baseline, so the post-compact gauge number is the calibrated transcript
   // estimate plus the request reserve.

package/src/runtime/agent/orchestrator/session/send-with-recovery.mjs

@@ -25,6 +25,8 @@ import {
   persistsConfirmedImageRejection,
   promptHasInlineImages,
   shouldStripImagesForRetry,
+  isImagePreparationFailed,
+  stripFailingImage,
   stripInlineImagesFromLatestTurn,
 } from './image-strip-recovery.mjs';
 import {
@@ -375,7 +377,13 @@ async function recoverFromSendError(sendErr, state) {
   // only when no tool was dispatched. Text exposure must be retracted first;
   // reasoning-only high-effort streams can retry without a text reset.
   if (
-    imageStripEligible(sendErr, outcome, { recoveryMessages, imageStripUsed, transportRetriesUsed, relayWitness }) &&
+    imageStripEligible(sendErr, outcome, {
+      recoveryMessages,
+      imageStripUsed,
+      transportRetriesUsed,
+      relayWitness,
+      isGrok: (sessionRef?.provider || state.provider?.name) === 'grok-oauth',
+    }) &&
     (outcome.replaySafe === true || (await retract()))
   ) {
     const stripped = retryWithImageStrip(sendErr, recoveryMessages, state);
@@ -684,7 +692,7 @@ function repairThinkingReplay(recoveryMessages, state) {
 function imageStripEligible(
   sendErr,
   outcome,
-  { recoveryMessages, imageStripUsed, transportRetriesUsed, relayWitness }
+  { recoveryMessages, imageStripUsed, transportRetriesUsed, relayWitness, isGrok }
 ) {
   return (
     transportRetriesUsed < TRANSPORT_RETRY_MAX &&
@@ -692,7 +700,13 @@ function imageStripEligible(
       hasImages: promptHasInlineImages(recoveryMessages),
       alreadyStripped: imageStripUsed === true,
     }) ||
-      (imageStripUsed !== true && promptHasInlineImages(recoveryMessages) && isRetryableStreamErrorEvent(sendErr))) &&
+      // Grok Build RetryWithImageStrip only: a bare stream error on a Grok
+      // upload may be the image body being rejected. Other providers' transient
+      // stream errors are not evidence about images and use normal transport retry.
+      (isGrok &&
+        imageStripUsed !== true &&
+        promptHasInlineImages(recoveryMessages) &&
+        isRetryableStreamErrorEvent(sendErr))) &&
     outcome.sideEffectDispatched !== true &&
     Number(outcome.toolCallsDispatched) === 0 &&
     Number(outcome.toolCallsComplete) === 0 &&
@@ -702,7 +716,9 @@ function imageStripEligible(
 
 function retryWithImageStrip(sendErr, recoveryMessages, state) {
   const { opts, transportRetriesUsed = 0 } = state;
-  const stripped = stripInlineImagesFromLatestTurn(recoveryMessages);
+  const stripped = isImagePreparationFailed(sendErr)
+    ? stripFailingImage(recoveryMessages, sendErr)
+    : stripInlineImagesFromLatestTurn(recoveryMessages);
   if (!(stripped.stripped > 0)) return null;
   const attempt = transportRetriesUsed + 1;
   logLoop(

package/src/runtime/agent/orchestrator/session/store/live-state.mjs

@@ -1,4 +1,4 @@
-import { sanitizeContentForStoredHistory } from '../../providers/media-normalization.mjs';
+import { contentCarriesLiveMedia } from '../../providers/media-normalization.mjs';
 
 const _lastSaveError = new Map(); // id -> { message, at }
 
@@ -153,10 +153,11 @@ export function _clearLiveSession(id) {
   if (id) _liveSessions.delete(id);
 }
 
-// Live snapshots that still carry raw media bytes (images are placeholder'd
-// in the persisted JSON) stay resident for this long after their last use so
-// multi-turn image recognition keeps working across an idle gap. Beyond the
-// TTL the memory cost wins and the snapshot is reclaimed like any other.
+// Live snapshots that still carry inline media bytes (the persisted JSON holds
+// content-addressed refs, or a placeholder for media the store refused) stay
+// resident for this long after their last use so multi-turn image recognition
+// keeps working across an idle gap. Beyond the TTL the memory cost wins and the
+// snapshot is reclaimed like any other.
 export const LIVE_MEDIA_RETENTION_MS = Math.max(
   60_000,
   Number(process.env.MIXDOG_LIVE_MEDIA_RETENTION_MS) || 10 * 60 * 1000
@@ -166,7 +167,7 @@ export function _messagesCarryLiveMedia(messages) {
   if (!Array.isArray(messages)) return false;
   for (const m of messages) {
     if (!m || typeof m !== 'object') continue;
-    if (sanitizeContentForStoredHistory(m.content) !== m.content) return true;
+    if (contentCarriesLiveMedia(m.content)) return true;
   }
   return false;
 }

package/src/runtime/agent/orchestrator/session/store/serialize.mjs

@@ -4,9 +4,12 @@ import { renameWithRetrySync } from '../../../../shared/atomic-file.mjs';
 import { sanitizeContentForStoredHistory } from '../../providers/media-normalization.mjs';
 import { readTopLevelLifecycleRecord, isLifecycleUnreadable } from '../lifecycle-scan.mjs';
 
-// Inline legacy media is replaced with placeholders on disk. New prompt media
-// already arrives as durable content-addressed refs, so session JSON stays small
-// while provider lowering can still resolve it across turns.
+// Inline base64 images (tool screenshots included) are written as
+// content-addressed refs, like prompt media, so session JSON stays small while
+// provider lowering resolves them to the same bytes across turns and reloads.
+// Inline documents (PDF, Office, text) are stored the same way as `file` refs.
+// Only media the store refuses (over the size cap, disk error) or that has no
+// inline bytes (URL/file-id images) is replaced with a placeholder on disk.
 // Per-message disk projection shared by _sessionForDisk and the save-worker
 // delta path (tail-only projection). Returns the SAME array reference when no
 // message changed. Idempotent: already-sanitized content passes through

package/src/runtime/agent/orchestrator/session/task-wait-control.mjs

@@ -5,6 +5,14 @@
 // and then flow through the normal post-tool steering boundary. The background
 // task itself keeps running.
 const waitersBySession = new Map();
+const steeringChecks = new Set();
+
+// Scoped to an active turn. Read the live queue at wait entry rather than
+// retaining a wake signal that could outlive a consumed or reclaimed prompt.
+export function registerTaskWaitSteeringCheck(check) {
+  steeringChecks.add(check);
+  return () => steeringChecks.delete(check);
+}
 
 function sessionKey(sessionId) {
   return String(sessionId || '').trim();
@@ -45,6 +53,11 @@ export function beginInterruptibleTaskWait(sessionId, parentSignal = null) {
     }
   }
 
+  if (!controller.signal.aborted && [...steeringChecks].some((check) => check(key))) {
+    waiter.interruptedByUser = true;
+    controller.abort('user-message');
+  }
+
   return {
     signal: controller.signal,
     get interruptedByUser() {

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

@@ -4,9 +4,10 @@
 import { markSessionToolCall } from '../manager/runtime-liveness.mjs';
 import { classifyResultKind } from '../result-classification.mjs';
 import { normalizeToolEnvelope } from '../tool-envelope.mjs';
-import { captureReadCacheState, tryReadCached, tryScopedToolCached } from '../read-dedup.mjs';
+import { captureReadCacheState } from '../read-dedup.mjs';
+import { lookupToolResultReuse } from '../cache/tool-result-reuse.mjs';
 import { isInvalidToolArgsMarker, formatInvalidToolArgsResult } from '../../providers/openai-compat-stream.mjs';
-import { _stripMcpPrefix, _isReadTool, _isScopedCacheableTool } from '../loop/tool-classify.mjs';
+import { _isReadTool } from '../loop/tool-classify.mjs';
 import { preDispatchDenyForSession } from '../loop/pre-dispatch-deny.mjs';
 import { getToolKind, isEagerDispatchable, isParallelDispatchable } from '../loop/tool-helpers.mjs';
 import { scopedCacheGeneration } from '../cache/scoped-cache.mjs';
@@ -73,24 +74,13 @@ export async function executeBatchCall(batch, call, callIndex) {
   return exec;
 }
 
-// Cross-turn read dedup: an unchanged stat tuple (mtime/ctime/size/ino/dev)
-// since a prior read in THIS session returns the cached body instead of
-// executing. Scoped-tool cache (grep/glob/list + graph lookups): keyed by
-// (toolName, canonical args) without per-file stat, since these tools scan
-// many files; write-class tools evict entries whose registered dependency
-// root contains the touched path.
+// Use the same freshness policy as eager admission and cross-turn references.
+// Read entries are stat-validated; scoped entries retain dependency
+// invalidation and their bounded TTL. A miss proceeds to execution.
 function lookupCaches(batch, call, exec) {
-  const { sessionId, cwd } = batch;
-  if (sessionId && _isReadTool(call.name)) {
-    exec.readCacheHit = tryReadCached({ sessionId, args: call.arguments, cwd });
-  } else if (sessionId && _isScopedCacheableTool(call.name)) {
-    exec.scopedCacheHit = tryScopedToolCached({
-      sessionId,
-      toolName: _stripMcpPrefix(call.name),
-      args: call.arguments,
-      cwd,
-    });
-  }
+  const cached = lookupToolResultReuse({ sessionId: batch.sessionId, call, cwd: batch.cwd });
+  if (cached?.kind === 'read') exec.readCacheHit = cached.entry;
+  else if (cached?.kind === 'scoped') exec.scopedCacheHit = cached.entry;
 }
 
 function markInstant(exec) {