mixdog 1.1.1 → 1.2.0

package/src/runtime/agent/orchestrator/runtime-core/config-helpers.mjs

@@ -3,6 +3,7 @@
 import { clean, hasOwn } from './session-text.mjs';
 import { normalizeEffortInput, normalizeSavedEffort } from './effort.mjs';
 import { routeFastKey, fastPreferenceFor } from './model-capabilities.mjs';
+import { normalizeContextTokens } from '../../../shared/llm/default-context-window.mjs';
 
 const DEFAULT_PROVIDER = 'anthropic-oauth';
 export const DEFAULT_MODEL = '';
@@ -53,6 +54,14 @@ function cleanContextPercent(value) {
   return Math.max(10, Math.min(100, Math.round(percent / 10) * 10));
 }
 
+/** The route's exact window in tokens: an explicit request, else none when a
+ *  percent is chosen instead, else the saved or preset selection. */
+function resolveContextTokens({ contextTokens, hasExplicitContextPercent, saved, preset = null }) {
+  if (contextTokens !== undefined) return normalizeContextTokens(contextTokens);
+  if (hasExplicitContextPercent) return undefined;
+  return normalizeContextTokens(saved.contextTokens ?? preset?.contextTokens);
+}
+
 /** The route's fast flag: an explicit request, else the saved choice, else the preset or the provider preference. */
 function resolveFast({ hasExplicitFast, explicitFast, saved, presetFast = false, preference }) {
   if (hasExplicitFast) return explicitFast;
@@ -60,8 +69,19 @@ function resolveFast({ hasExplicitFast, explicitFast, saved, presetFast = false,
   return presetFast || preference();
 }
 
+/** The route's Auto effort flag: an explicit request, else the saved choice,
+ *  else the preset. Absent means on; only `false` turns it off. */
+function resolveAutoEffort({ autoEffort, saved, preset = null }) {
+  if (autoEffort !== undefined) return autoEffort !== false;
+  if (hasOwn(saved, 'autoEffort')) return saved.autoEffort !== false;
+  return preset?.autoEffort !== false;
+}
+
 export function makeResolveRoute(resolveDefaultProvider) {
-  return function resolveRoute(config, { provider, model, effort, fast, modelParameters, contextPercent } = {}) {
+  return function resolveRoute(
+    config,
+    { provider, model, effort, fast, autoEffort, modelParameters, contextPercent, contextTokens } = {}
+  ) {
     const explicitProvider = clean(provider);
     const explicitModel = clean(model);
     const hasExplicitEffort = effort !== undefined;
@@ -70,6 +90,9 @@ export function makeResolveRoute(resolveDefaultProvider) {
     const explicitFast = fast === true;
     const hasExplicitModelParameters = modelParameters !== undefined;
     const hasExplicitContextPercent = contextPercent !== undefined;
+    // An exact token selection replaces a saved percent unless a percent is
+    // requested alongside it.
+    const keepsSavedPercent = contextTokens === undefined;
 
     if (!explicitProvider) {
       const preset = findPreset(config, explicitModel || config?.default);
@@ -78,6 +101,7 @@ export function makeResolveRoute(resolveDefaultProvider) {
         const m = clean(preset.model) || DEFAULT_MODEL;
         if (p && m) {
           const saved = modelSettingsFor(config, p, m);
+          const tokens = resolveContextTokens({ contextTokens, hasExplicitContextPercent, saved, preset });
           return {
             provider: p,
             model: m,
@@ -90,12 +114,16 @@ export function makeResolveRoute(resolveDefaultProvider) {
               presetFast: preset.fast === true,
               preference: () => fastPreferenceFor(config, p, m),
             }),
+            autoEffort: resolveAutoEffort({ autoEffort, saved, preset }),
             modelParameters: hasExplicitModelParameters
               ? cleanModelParameters(modelParameters)
               : cleanModelParameters(saved.modelParameters ?? preset.modelParameters),
             contextPercent: hasExplicitContextPercent
               ? cleanContextPercent(contextPercent)
-              : cleanContextPercent(saved.contextPercent ?? preset.contextPercent),
+              : keepsSavedPercent
+                ? cleanContextPercent(saved.contextPercent ?? preset.contextPercent)
+                : undefined,
+            ...(tokens ? { contextTokens: tokens } : {}),
           };
         }
       }
@@ -104,18 +132,23 @@ export function makeResolveRoute(resolveDefaultProvider) {
     const p = explicitProvider || resolveDefaultProvider(config);
     const m = explicitModel || DEFAULT_MODEL;
     const saved = modelSettingsFor(config, p, m);
+    const tokens = resolveContextTokens({ contextTokens, hasExplicitContextPercent, saved });
     return {
       provider: p,
       model: m,
       preset: null,
       effort: hasExplicitEffort ? explicitEffort : normalizeSavedEffort(saved.effort),
       fast: resolveFast({ hasExplicitFast, explicitFast, saved, preference: () => fastPreferenceFor(config, p, m) }),
+      autoEffort: resolveAutoEffort({ autoEffort, saved }),
       modelParameters: hasExplicitModelParameters
         ? cleanModelParameters(modelParameters)
         : cleanModelParameters(saved.modelParameters),
       contextPercent: hasExplicitContextPercent
         ? cleanContextPercent(contextPercent)
-        : cleanContextPercent(saved.contextPercent),
+        : keepsSavedPercent
+          ? cleanContextPercent(saved.contextPercent)
+          : undefined,
+      ...(tokens ? { contextTokens: tokens } : {}),
     };
   };
 }

package/src/runtime/agent/orchestrator/runtime-core/effort.mjs

@@ -1,6 +1,7 @@
 // Reasoning-effort catalogs and coercion. Pure helpers.
 import { clean } from './session-text.mjs';
 import { customEffortLevels, snapCustomEffort } from '../providers/custom-reasoning.mjs';
+import { rejectedEffortLevelsSync } from '../providers/effort-rejection.mjs';
 
 const TOOL_MODES = new Set(['full', 'readonly', 'lead']);
 const ALL_EFFORT_LEVELS = new Set(['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra']);
@@ -15,22 +16,15 @@ const EFFORT_LABELS = {
   ultra: 'Ultra',
 };
 
+// Last-resort ladders for routes whose endpoints publish no effort metadata
+// (no per-model levels on /models, no same-endpoint catalog row). Every other
+// provider's ladder comes from its own catalog rows (live roster, models.dev
+// via provider-catalog-registry, seeds); a route with none offers no effort.
 const EFFORT_OPTIONS_BY_PROVIDER = {
   openai: ['none', 'low', 'medium', 'high', 'xhigh'],
-  // gpt-5.6+ catalogs declare max/ultra; the openai-oauth transport folds
-  // ultra -> max on the wire (openai-oauth.mjs _normalizeReasoningEffort).
-  'openai-oauth': ['none', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra'],
-  anthropic: ['low', 'medium', 'high', 'xhigh', 'max'],
-  'anthropic-oauth': ['low', 'medium', 'high', 'xhigh', 'max'],
   // xAI Grok 4.6+: low/medium/high/xhigh. Reasoning cannot be disabled.
   xai: ['low', 'medium', 'high', 'xhigh'],
-  'grok-oauth': ['low', 'medium', 'high', 'xhigh'],
-  'muse-code-oauth': ['minimal', 'low', 'medium', 'high', 'xhigh'],
   'mimo-oauth': ['minimal', 'low', 'medium', 'high'],
-  // Antigravity carries the effort tier inside the wire model id
-  // (gemini-3-pro-high / -low, claude-*-thinking), so the route exposes none.
-  'antigravity-oauth': [],
-  'opencode-go': ['high', 'max'],
 };
 const EFFORT_BY_FAMILY = {
   opus: ['low', 'medium', 'high', 'xhigh', 'max'],
@@ -73,7 +67,14 @@ export function normalizeEffortInput(value) {
   return v;
 }
 
+// Levels the endpoint has rejected for this route stop being offered.
 export function effortOptionsFor(provider, model) {
+  const options = catalogEffortOptions(provider, model);
+  const rejected = model?.id ? rejectedEffortLevelsSync(provider, model.id) : null;
+  return rejected?.size ? options.filter((level) => !rejected.has(level)) : options;
+}
+
+function catalogEffortOptions(provider, model) {
   // Custom-provider rows declare their levels authoritatively: an explicit []
   // (or no declaration) means none, with no family/provider fallback.
   if (model?.customReasoning) return customEffortLevels(model) || [];

package/src/runtime/agent/orchestrator/runtime-core/model-capabilities.mjs

@@ -6,6 +6,7 @@ import { clean, hasOwn } from './session-text.mjs';
 import { modelSupportsServiceTier } from '../providers/model-service-tiers.mjs';
 import { openAiDirectSupportsFast, openAiDirectSupportsUltrafast } from '../providers/openai-direct-request.mjs';
 import { supportsAnthropicFastMode } from '../../../shared/llm/anthropic-betas.mjs';
+import { normalizeContextTokens } from '../../../shared/llm/default-context-window.mjs';
 
 const FAST_CAPABLE_PROVIDERS = new Set([
   'anthropic',
@@ -123,6 +124,11 @@ export function saveModelSettings(cfgMod, route, { fastCapable = true, baseConfi
   else delete nextSetting.effort;
   if (fastCapable) nextSetting.fast = route.fast === true;
   else nextSetting.fast = false;
+  // Auto effort is on unless turned off: only the off state is stored.
+  if (hasOwn(route, 'autoEffort')) {
+    if (route.autoEffort === false) nextSetting.autoEffort = false;
+    else delete nextSetting.autoEffort;
+  }
   if (route.modelParameters && typeof route.modelParameters === 'object') {
     nextSetting.modelParameters = Object.fromEntries(
       Object.entries(route.modelParameters)
@@ -136,13 +142,22 @@ export function saveModelSettings(cfgMod, route, { fastCapable = true, baseConfi
   // pickers send the default stop with every selection; storing it froze each
   // model at whatever its default was that day, so a later default never
   // reached anyone who had already selected the model.
+  // An exact window in tokens replaces the percentage, and a percentage
+  // replaces it. A token selection at the default window reaches here already
+  // dropped (resolveRouteContextState answers no contextTokens for it).
+  const contextTokens = normalizeContextTokens(route.contextTokens);
   const requestedPercent = Number(route.contextPercent);
   const contextPercent = Math.round(requestedPercent / 10) * 10;
   const isDefault = contextPercent === Number(route.contextDefaultPercent);
-  if (requestedPercent >= 10 && requestedPercent <= 100 && !isDefault) {
+  if (contextTokens) {
+    nextSetting.contextTokens = contextTokens;
+    delete nextSetting.contextPercent;
+  } else if (requestedPercent >= 10 && requestedPercent <= 100 && !isDefault) {
     nextSetting.contextPercent = contextPercent;
+    delete nextSetting.contextTokens;
   } else {
     delete nextSetting.contextPercent;
+    delete nextSetting.contextTokens;
   }
   modelSettings[key] = nextSetting;
 

package/src/runtime/agent/orchestrator/runtime-core/plugin-mcp.mjs

@@ -33,9 +33,20 @@ const MCP_TRANSPORT_FIELDS = new Set([
   'autoDetect',
 ]);
 
+// Every spelling resolveMcpStartupTimeoutMs / resolveMcpCallTimeoutMs reads.
+// A newly supplied value must replace the whole group, or a stale alias that
+// the resolver prefers would keep winning.
+export const MCP_TIMEOUT_FIELD_GROUPS = [
+  ['startupTimeoutMs', 'startup_timeout_ms', 'startupTimeoutSec', 'startup_timeout_sec'],
+  ['timeoutMs', 'timeout_ms', 'callTimeoutMs', 'call_timeout_ms'],
+];
+
 export function mergeMcpServerConfig(existing, next) {
   const merged = isPlainObject(existing) ? { ...existing } : {};
   for (const field of MCP_TRANSPORT_FIELDS) delete merged[field];
+  for (const group of MCP_TIMEOUT_FIELD_GROUPS) {
+    if (group.some((field) => Object.hasOwn(next, field))) for (const field of group) delete merged[field];
+  }
   return { ...merged, ...next };
 }
 

package/src/runtime/agent/orchestrator/runtime-core/tool-defs.mjs

@@ -40,17 +40,21 @@ export const CWD_TOOL = {
   },
   trigger: 'Show or switch the active Project; not a shell-local cd.',
   description:
-    'Show or switch the active Project. list returns the registered projects (name, path); a project name instead of a path → list first, then set the matching path, ask only if several match. path must be an existing directory. A shell-local cd does not change the Project.',
+    'Show or switch the active Project. list returns the registered projects (name, path); a project name instead of a path → list first, then set the matching path, ask only if several match. path must be an existing directory. A shell-local cd does not change the Project. merge-worktree / remove-worktree act on this session’s git worktree only when the user explicitly asks.',
   inputSchema: {
     type: 'object',
     properties: {
       action: {
         type: 'string',
-        enum: ['get', 'set', 'list'],
+        enum: ['get', 'set', 'list', 'merge-worktree', 'remove-worktree', 'list-worktrees', 'prune-worktrees'],
         description:
-          'get shows the active Project (default without path), set switches to path, list returns registered projects.',
+          'get shows the active Project (default without path), set switches to path, list returns registered projects; merge-worktree merges this session’s worktree into the project folder’s checked-out branch, remove-worktree deletes it (returning to the project folder; call again if it reports WORKTREE_REMOVAL_INCOMPLETE); list-worktrees lists every managed worktree and who retains it; prune-worktrees removes clean, merged ones no session retains.',
       },
       path: { type: 'string', description: 'Existing directory to switch to (implies action=set).' },
+      force: {
+        type: 'boolean',
+        description: 'remove-worktree: delete even with uncommitted or unmerged work (only when the user says so).',
+      },
     },
     additionalProperties: false,
   },
@@ -93,13 +97,13 @@ const TERMINAL_RUNTIME_TOOLS = ['terminal'];
 const OFFICE_RUNTIME_TOOLS = ['office'];
 const MEDIA_RUNTIME_TOOLS = ['media'];
 const TIDY_RUNTIME_TOOLS = ['tidy'];
+const VISUALIZE_RUNTIME_TOOLS = ['visualize'];
 
 const admitted = (tools, names) => (tools || []).filter((tool) => names.includes(tool?.name));
 
 /**
  * Assemble this runtime's tool definitions from the loaded tool-def modules.
- * Pure: callers resolve their own availability flags (skills env gate, channel
- * ownership) and pass the already-built goal/agent tool arrays.
+ * Pure: callers resolve their own availability flags (skills env gate) and pass the already-built goal/agent tool arrays.
  *
  * - `standaloneTools` is the model-facing set (also the deferred catalog base).
  * - `internalToolDefs` adds the `public: false` web-search tools: reachable
@@ -108,7 +112,6 @@ const admitted = (tools, names) => (tools || []).filter((tool) => names.includes
 export function collectStandaloneToolDefs({
   webSearchToolDefs,
   memoryToolDefs,
-  channelToolDefs,
   codeGraphToolDefs,
   browserToolDefs = [],
   computerToolDefs = [],
@@ -116,10 +119,10 @@ export function collectStandaloneToolDefs({
   officeToolDefs = [],
   mediaToolDefs = [],
   tidyToolDefs = [],
+  visualizeToolDefs = [],
   setupToolDefs = [],
   goalTools = [],
   agentTools = [],
-  isChannelTool = () => false,
   skillToolEnabled = true,
 }) {
   const webSearchRuntimeTools = admitted(webSearchToolDefs?.TOOL_DEFS, WEB_SEARCH_RUNTIME_TOOLS);
@@ -129,7 +132,6 @@ export function collectStandaloneToolDefs({
     CWD_TOOL,
     ...webSearchRuntimeTools.filter((tool) => tool?.public !== false),
     ...admitted(memoryToolDefs?.TOOL_DEFS, MEMORY_RUNTIME_TOOLS),
-    ...(channelToolDefs?.TOOL_DEFS || []).filter((tool) => isChannelTool(tool?.name)),
     ...admitted(codeGraphToolDefs?.CODE_GRAPH_TOOL_DEFS, CODE_GRAPH_RUNTIME_TOOLS),
     ...admitted(browserToolDefs, BROWSER_RUNTIME_TOOLS),
     ...admitted(computerToolDefs, COMPUTER_RUNTIME_TOOLS),
@@ -137,6 +139,7 @@ export function collectStandaloneToolDefs({
     ...admitted(officeToolDefs, OFFICE_RUNTIME_TOOLS),
     ...admitted(mediaToolDefs, MEDIA_RUNTIME_TOOLS),
     ...admitted(tidyToolDefs, TIDY_RUNTIME_TOOLS),
+    ...admitted(visualizeToolDefs, VISUALIZE_RUNTIME_TOOLS),
     ...setupToolDefs,
     ...goalTools,
     ...agentTools,

package/src/runtime/agent/orchestrator/runtime-core/workflow.mjs

@@ -6,6 +6,7 @@ import { clean } from './session-text.mjs';
 import { normalizeEffortInput } from './effort.mjs';
 import { isLikelyRawModelId } from './config-helpers.mjs';
 import { configuredAgentRouteCandidates } from '../../../shared/agent-route-config.mjs';
+import { normalizeContextTokens } from '../../../shared/llm/default-context-window.mjs';
 import { normalizeAgentId, normalizeWorkflowId } from './workflow-ids.mjs';
 import { createWorkflowPacks } from './workflow/packs.mjs';
 import { createWorkflowAgents } from './workflow/agents.mjs';
@@ -186,19 +187,27 @@ export function normalizeWorkflowRoute(routeLike, fallback = {}) {
   if (!isLikelyRawModelId(model)) return null;
   const effort = normalizeEffortInput(routeLike?.effort ?? fallback.effort);
   const fast = routeLike?.fast ?? fallback.fast;
+  // Absent means Auto effort is on; only the off state is carried.
+  const autoEffort = routeLike?.autoEffort ?? fallback.autoEffort;
   const modelParameters = routeLike?.modelParameters ?? fallback.modelParameters;
   const requestedPercent = Number(routeLike?.contextPercent ?? fallback.contextPercent);
   const contextPercent =
     Number.isFinite(requestedPercent) && requestedPercent >= 10 && requestedPercent <= 100
       ? Math.round(requestedPercent / 10) * 10
       : null;
+  // A percent on the route replaces the fallback's exact window.
+  const contextTokens = normalizeContextTokens(
+    routeLike?.contextTokens ?? (routeLike?.contextPercent == null ? fallback.contextTokens : undefined)
+  );
   return {
     provider,
     model,
     ...(effort ? { effort } : {}),
     ...(typeof fast === 'boolean' ? { fast } : {}),
+    ...(autoEffort === false ? { autoEffort: false } : {}),
     ...(modelParameters && typeof modelParameters === 'object' ? { modelParameters: { ...modelParameters } } : {}),
     ...(contextPercent ? { contextPercent } : {}),
+    ...(contextTokens ? { contextTokens } : {}),
   };
 }
 
@@ -214,6 +223,7 @@ export function upsertWorkflowPreset(presets, slot, routeLike) {
     model: route.model,
     ...(route.effort ? { effort: route.effort } : {}),
     ...(route.fast === true ? { fast: true } : {}),
+    ...(route.autoEffort === false ? { autoEffort: false } : {}),
     ...(route.modelParameters ? { modelParameters: route.modelParameters } : {}),
     tools: 'full',
   };

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

@@ -13,6 +13,7 @@ import { createHash } from 'node:crypto';
 import { writeJsonAtomicSync } from '../../../../shared/atomic-file.mjs';
 import { resolvePluginData } from '../../../../shared/plugin-paths.mjs';
 import { setBoundedTextCacheEntry } from './text-cache-budget.mjs';
+import { canCacheReadFile } from '../../tools/builtin/read-cache-policy.mjs';
 
 // Entry cap: MIXDOG_PREFETCH_CACHE_MAX env var, default 200.
 const _envCap = Number(process.env.MIXDOG_PREFETCH_CACHE_MAX);
@@ -110,12 +111,14 @@ function rememberPrefetch(absPath, entry) {
 }
 
 export function capturePrefetchCacheState(absPath) {
-  return _statTuple(_normalizeCacheKey(absPath));
+  const stat = _statTuple(_normalizeCacheKey(absPath));
+  return canCacheReadFile(stat) ? stat : null;
 }
 
 /**
  * Look up a cached prefetch result for `absPath`. Stat-validates the file on
- * every hit. Returns null on miss, TTL expiry, or stat mismatch. Returns
+ * every hit. Returns null on miss, TTL expiry, stat mismatch, or a file
+ * outside the prefix budget, including a persisted legacy row. Returns
  * `{ content, ts }` on a fresh hit.
  */
 export function tryPrefetchCached(absPath) {
@@ -135,7 +138,7 @@ export function tryPrefetchCached(absPath) {
     return null;
   }
   const fresh = _statTuple(absPath);
-  if (!_statEqual(entry.stat, fresh)) {
+  if (!_statEqual(entry.stat, fresh) || !canCacheReadFile(fresh)) {
     _prefetchCache.delete(absPath);
     _deleteDiskEntry(absPath);
     return null;
@@ -152,7 +155,8 @@ export function tryPrefetchCached(absPath) {
 
 /**
  * Store a per-file prefetch result. Silently skips empty or error-prefixed
- * content so only clean read output enters the cache.
+ * content, and files outside the prefix budget, so only clean bounded read
+ * output enters the cache.
  * Async callers must pass the state captured before reading; null disables
  * insertion. Omission is reserved for synchronous current-body insertion.
  */
@@ -162,7 +166,7 @@ export function setPrefetchCached(absPath, content, readState) {
   if (classifyResultKind(content) === 'error') return;
   absPath = _normalizeCacheKey(absPath);
   const stat = _statTuple(absPath);
-  if (!stat) return;
+  if (!stat || !canCacheReadFile(stat)) return;
   // Async readers supply the version observed before execution. Never label
   // an older body with the version that happens to exist at insertion time.
   if (readState !== undefined && !_statEqual(readState, stat)) return;

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

@@ -5,6 +5,7 @@ import { clearScopedToolsForSession } from './scoped-cache.mjs';
 import { registerSessionPurgeHook } from '../store.mjs';
 import { releaseReadSnapshotScope } from '../../tools/builtin/snapshot-store.mjs';
 import { setBoundedTextCacheEntry } from './text-cache-budget.mjs';
+import { canCacheReadFile } from '../../tools/builtin/read-cache-policy.mjs';
 
 const MAX_PER_SESSION = 100;
 
@@ -114,6 +115,12 @@ function _arrayStatsValid(statsByAbs) {
   return true;
 }
 
+// Equal stat tuples do not prove bytes past the hashed prefix. Files outside
+// that budget must not be captured, reused, or inserted.
+function _cacheableStats(statsByAbs) {
+  return !!statsByAbs && Object.values(statsByAbs).every((stat) => canCacheReadFile(stat));
+}
+
 function _getOrCreate(sessionId) {
   let m = _bySession.get(sessionId);
   if (!m) {
@@ -157,20 +164,22 @@ export function captureReadCacheState({ args, cwd }) {
   const key = _keyFor(args, cwd);
   if (key === null && Array.isArray(args?.path ?? args?.file_path)) {
     const parsed = _arrayKeyAndStats(args, cwd);
-    if (!parsed || Object.values(parsed.statsByAbs).some((stat) => !stat)) return null;
+    if (!parsed || !_cacheableStats(parsed.statsByAbs)) return null;
     return { ...parsed, kind: 'array' };
   }
   if (!key) return null;
   const abs = _absFromKey(key);
   const stat = _statTuple(abs);
-  return stat ? { key, statsByAbs: { [abs]: stat }, kind: 'scalar' } : null;
+  if (!canCacheReadFile(stat)) return null;
+  return { key, statsByAbs: { [abs]: stat }, kind: 'scalar' };
 }
 
 /**
  * Look up a cached read result for this session+args. Stats the file at
  * lookup time and only returns when the stat tuple still matches. Returns
- * null on miss, on path-form mismatch, or on stat failure. On hit returns
- * the full entry { content, firstToolUseId, ts }.
+ * null on miss, on path-form mismatch, on stat failure, or when any file
+ * exceeds the prefix budget. On hit returns the full entry
+ * { content, firstToolUseId, ts }.
  */
 export function tryReadCached({ sessionId, args, cwd }) {
   if (!sessionId) return null;
@@ -182,7 +191,7 @@ export function tryReadCached({ sessionId, args, cwd }) {
     if (!map) return null;
     const entry = map.get(parsed.key);
     if (entry?.kind !== 'array') return null;
-    if (!_arrayStatsValid(entry.statsByAbs)) {
+    if (!_arrayStatsValid(entry.statsByAbs) || !_cacheableStats(entry.statsByAbs)) {
       map.delete(parsed.key);
       _ridxPruneKey(sessionId, parsed.key);
       return null;
@@ -197,7 +206,7 @@ export function tryReadCached({ sessionId, args, cwd }) {
   const entry = map.get(key);
   if (!entry) return null;
   const fresh = _statTuple(_absFromKey(key));
-  if (!_statEqual(entry.stat, fresh)) {
+  if (!_statEqual(entry.stat, fresh) || !canCacheReadFile(fresh)) {
     map.delete(key);
     _ridxPruneKey(sessionId, key);
     return null;
@@ -208,7 +217,8 @@ export function tryReadCached({ sessionId, args, cwd }) {
 }
 
 /**
- * Cache a successful read result. Skip caching if the file no longer exists.
+ * Cache a successful read result. Skip caching if a file is missing or
+ * outside the prefix budget.
  * `toolUseId` is the tool_use id of the FIRST call that populated the entry.
  * Async executors pass their pre-execution `readState`; null disables caching
  * when the source version could not be established. Omission retains direct
@@ -218,7 +228,7 @@ export function setReadCached({ sessionId, args, cwd, content, toolUseId, readSt
   if (!sessionId) return;
   if (typeof content !== 'string' || content.length === 0) return;
   const parsed = captureReadCacheState({ args, cwd });
-  if (!parsed) return;
+  if (!parsed || !_cacheableStats(parsed.statsByAbs)) return;
   if (
     readState !== undefined &&
     (!readState ||

package/src/runtime/agent/orchestrator/session/compact/execution-tail.mjs

@@ -7,6 +7,7 @@ import {
   latestActualUserInstructionIndex,
 } from './messages.mjs';
 import { staleObservations, supersedeObservation } from './observation-supersession.mjs';
+import { carryMessageId, withoutMessageIdsReplacer } from '../message-ids.mjs';
 
 export const EXECUTION_RECOVERY_SOURCE = 'compact-execution-recovery';
 const TOOL_HISTORY_CONTEXT_RATIO = 0.05;
@@ -34,7 +35,11 @@ export function executionTokens(messages) {
     const { uiDiff: _uiDiff, ...rest } = message;
     return rest;
   });
-  return Math.max(estimateMessagesTokens(budgetMessages), estimateTokens(JSON.stringify(budgetMessages)));
+  // Display ids never reach the model either.
+  return Math.max(
+    estimateMessagesTokens(budgetMessages),
+    estimateTokens(JSON.stringify(budgetMessages, withoutMessageIdsReplacer))
+  );
 }
 
 function requestStart(messages, index) {
@@ -123,7 +128,8 @@ function assembleTail(messages, kept, { anchor, firstKept, preserveConversation
       // Omitted execution stays in the archive; its conversational text
       // remains verbatim without replaying an orphaned call or reasoning.
       if (message.toolCalls?.length) {
-        if (message.content) tail.push({ role: 'assistant', content: message.content });
+        // The text-only copy is this message's rewrite: it keeps its id.
+        if (message.content) tail.push(carryMessageId({ role: 'assistant', content: message.content }, message));
       } else {
         tail.push(message);
       }
@@ -158,7 +164,8 @@ export function buildExecutionTail(
       sessionId,
       toolCallId: 'compact-execution',
       channel: 'compact-execution',
-      content: JSON.stringify({ version: 1, messages: transcript }, null, 2),
+      // Model-readable evidence: display ids stay out of it.
+      content: JSON.stringify({ version: 1, messages: transcript }, withoutMessageIdsReplacer, 2),
     });
     if (!archive) throw new Error('compact: execution history could not be archived; original context preserved');
     recovery = [

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

@@ -2,13 +2,16 @@
 // construction helpers.
 import { SUMMARY_PREFIX, SUMMARY_PREFIX_ANCHOR } from './constants.mjs';
 import { sha16, roleCounts } from './text-utils.mjs';
+import { carryMessageId, withoutMessageIdsReplacer } from '../message-ids.mjs';
 import {
   isInternalRuntimeNotificationText,
   isModelVisibleToolCompletionWrapper,
 } from '../../../../shared/tool-execution-contract.mjs';
 
 export function compactHeader(oldHistory) {
-  const encoded = JSON.stringify(oldHistory ?? []);
+  // Stable display ids are bookkeeping, not conversation: the header names
+  // the same history whether or not its messages were stamped.
+  const encoded = JSON.stringify(oldHistory ?? [], withoutMessageIdsReplacer);
   return [
     SUMMARY_PREFIX,
     `messages=${oldHistory.length} sha256=${sha16(encoded)} roles=${roleCounts(oldHistory) || 'none'}`,
@@ -130,16 +133,20 @@ function referenceFilesManifestMessage(message) {
   const paths = [...text.matchAll(/^###\s+(.+?)\s*$/gm)].map((match) => String(match[1] || '').trim()).filter(Boolean);
   if (paths.length === 0) return null;
   const uniquePaths = [...new Set(paths)];
-  return {
-    role: 'user',
-    content: [
-      '<system-reminder>',
-      '# Reference files',
-      'These files were attached when the session started. Re-read a path when its current contents are needed; the original bodies are not re-injected after Compact.',
-      ...uniquePaths.map((path) => `- ${path}`),
-      '</system-reminder>',
-    ].join('\n'),
-  };
+  // The manifest rewrites the reference-files message: it keeps that id.
+  return carryMessageId(
+    {
+      role: 'user',
+      content: [
+        '<system-reminder>',
+        '# Reference files',
+        'These files were attached when the session started. Re-read a path when its current contents are needed; the original bodies are not re-injected after Compact.',
+        ...uniquePaths.map((path) => `- ${path}`),
+        '</system-reminder>',
+      ].join('\n'),
+    },
+    message
+  );
 }
 
 export function splitProtectedContext(messages) {

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

@@ -20,6 +20,7 @@ import { buildExecutionTail } from './execution-tail.mjs';
 import { latestSkillBodies } from '../../context/skill-state.mjs';
 import { effectiveBudget } from './budget.mjs';
 import { stripRuntimeUserContext, withRuntimeUserContext } from '../runtime-user-context.mjs';
+import { carryMessageId } from '../message-ids.mjs';
 import { normalizeIngestRole, shouldExcludeIngestMessage } from '../../../../memory/lib/session-ingest.mjs';
 import { codexWireSendOpts } from '../manager/session-id.mjs';
 import { rebaseCompactedEffortConfiguration } from '../../providers/effort-configuration.mjs';
@@ -380,7 +381,8 @@ function skillLoaderPair(live, bodyIndex, name, retainedCallIds) {
     const call = owner?.toolCalls.find((entry) => entry.id === result.toolCallId);
     if (call?.name !== 'Skill' || call.arguments?.name !== name) continue;
     if (!result.nativeToolSearch || retainedCallIds.has(result.toolCallId)) return [];
-    return [{ role: 'assistant', content: '', toolCalls: [call] }, result];
+    // The re-attached call is part of its owner message: it keeps that id.
+    return [carryMessageId({ role: 'assistant', content: '', toolCalls: [call] }, owner), result];
   }
   return [];
 }
@@ -549,11 +551,17 @@ function assertHandoffFits(summaryMessage, room) {
 export function freshContextCompactMessages(messages, budgetTokens, opts = {}) {
   const startedAt = Date.now();
   const targetBudget = effectiveBudget(budgetTokens, opts);
-  let budget = targetBudget;
   const baseSanitized = reconcileDedupStubs(sanitizeToolPairs(messages));
   const baseTokens = safeEstimateMessagesTokens(baseSanitized);
-  if (baseTokens != null && baseTokens <= budget && opts.force !== true) {
-    return fitsBudgetResult({ startedAt, messages, baseSanitized, baseTokens, budget, query: opts.query || '' });
+  if (baseTokens != null && baseTokens <= targetBudget && opts.force !== true) {
+    return fitsBudgetResult({
+      startedAt,
+      messages,
+      baseSanitized,
+      baseTokens,
+      budget: targetBudget,
+      query: opts.query || '',
+    });
   }
 
   const source = splitFreshSource(baseSanitized);
@@ -562,7 +570,7 @@ export function freshContextCompactMessages(messages, budgetTokens, opts = {}) {
     budgetTokens,
     opts
   );
-  budget = freshContextBudget({ targetBudget, budgetTokens, mandatoryCost, summaryMessage, opts });
+  const budget = freshContextBudget({ targetBudget, budgetTokens, mandatoryCost, summaryMessage, opts });
   assertMandatoryFits(budget, mandatoryCost, summaryMessage, opts.contextWindow);
   const handoff = handoffRoomFor(budget, mandatoryCost, opts);
   const summaryContent = String(summaryMessage?.content || '');