mixdog 1.0.8 → 1.0.9

package/src/runtime/agent/orchestrator/providers/codex-client-meta.mjs

@@ -12,13 +12,16 @@
  * cache-node routing, so mixdog mirrors both.
  */
 import os from 'node:os';
+import { readLastKnownVersion, rememberLastKnownVersion } from './client-version-store.mjs';
 
-// Offline fallback only; live value refreshes from npm (24h TTL, in-process).
+// Offline fallback only; live value refreshes from npm (24h TTL) and the last
+// live answer is kept on disk, so the floor is only a first-run default.
 // The backend gates model exposure AND per-request model access on the client
 // version (gpt-6-sol/luna require >= 0.155.0 per the published model catalog,
 // verified 2026-09-22), so keep this at the current release when bumping.
 const CODEX_CLIENT_VERSION_FLOOR = '0.155.1';
 const VERSION_TTL_MS = 24 * 60 * 60_000;
+const LAST_KNOWN_KEY = 'codex-cli';
 let _cache = { value: null, fetchedAt: 0 };
 let _refreshInFlight = null;
 
@@ -32,14 +35,16 @@ async function _refresh() {
       const v = String(j?.version || '').trim();
       if (/^\d+\.\d+\.\d+/.test(v)) {
         _cache = { value: v, fetchedAt: Date.now() };
+        rememberLastKnownVersion(LAST_KNOWN_KEY, v);
         return v;
       }
     }
   } catch {
     /* offline — keep floor */
   }
-  _cache = { value: CODEX_CLIENT_VERSION_FLOOR, fetchedAt: Date.now() };
-  return CODEX_CLIENT_VERSION_FLOOR;
+  const fallback = _offlineVersion();
+  _cache = { value: fallback, fetchedAt: Date.now() };
+  return fallback;
 }
 
 /**
@@ -50,7 +55,25 @@ async function _refresh() {
 function codexClientVersionSync() {
   if (_cacheFresh()) return _cache.value;
   _ensureRefresh();
-  return _cache.value || CODEX_CLIENT_VERSION_FLOOR;
+  return _cache.value || _offlineVersion();
+}
+
+// The newest version this machine has seen, never below the shipped floor.
+function _offlineVersion() {
+  const lastKnown = readLastKnownVersion(LAST_KNOWN_KEY);
+  const newer = lastKnown && _compareVersion(lastKnown, CODEX_CLIENT_VERSION_FLOOR) > 0;
+  return newer ? lastKnown : CODEX_CLIENT_VERSION_FLOOR;
+}
+
+// Numeric x.y.z order; a pre-release suffix on the patch part is ignored.
+function _compareVersion(a, b) {
+  const parts = (version) => String(version).split('.').map((part) => Number.parseInt(part, 10) || 0);
+  const [pa, pb] = [parts(a), parts(b)];
+  for (let i = 0; i < 3; i += 1) {
+    const delta = (pa[i] || 0) - (pb[i] || 0);
+    if (delta) return delta;
+  }
+  return 0;
 }
 
 function _cacheFresh() {

package/src/runtime/agent/orchestrator/providers/cursor-client-version.mjs

@@ -4,13 +4,17 @@ import { createRemoteVersionSource } from './npm-cli-version.mjs';
 // documented version endpoint; the official installer script embeds the
 // current build (…/lab/<build>/…), parsed best-effort. Any format change or
 // failure falls back to the floor.
-export const CURSOR_CLIENT_VERSION_FLOOR = 'cli-2026.08.11-e8db854';
+export const CURSOR_CLIENT_VERSION_FLOOR = 'cli-2026.10.01-e373342';
 const BUILD_PATTERN = /downloads\.cursor\.com\/lab\/(\d{4}\.\d{2}\.\d{2}-[0-9a-f]{6,40})\//;
 
-const live = createRemoteVersionSource('https://cursor.com/install', async (res) => {
-  const match = (await res.text()).match(BUILD_PATTERN);
-  return match ? `cli-${match[1]}` : null;
-});
+const live = createRemoteVersionSource(
+  'https://cursor.com/install',
+  async (res) => {
+    const match = (await res.text()).match(BUILD_PATTERN);
+    return match ? `cli-${match[1]}` : null;
+  },
+  { persistKey: 'cursor-cli' }
+);
 let envVersion;
 
 function envOverride() {

package/src/runtime/agent/orchestrator/providers/effort-configuration.mjs

@@ -1,10 +1,19 @@
 import { normalizeAnthropicEffortInput } from './anthropic-effort.mjs';
+import { codexModelSupportsEffortUpdates } from './openai-oauth-catalog.mjs';
 
 export const EFFORT_CONFIGURATION_BETA = 'mid-conversation-output-config-2026-07-01';
-const ANTHROPIC_MODELS = new Set(['claude-fable-5-1', 'claude-mythos-5-1', 'claude-opus-5', 'claude-opus-5-5']);
+const ANTHROPIC_MODELS = new Set([
+  'claude-fable-5-1',
+  'claude-mythos-5-1',
+  'claude-opus-5',
+  'claude-opus-5-5',
+  'claude-sonnet-5-5',
+]);
 // https://developers.openai.com/api/docs/guides/reasoning#change-reasoning-mid-conversation
-// — the GPT-6 model family, standard single-agent mode.
-const OPENAI_MODELS = new Set(['gpt-6-astra', 'gpt-6-sol', 'gpt-6-luna']);
+// — the GPT-6 model family, standard single-agent mode. The public API
+// publishes no per-model flag, so this list is its whole answer; the OAuth
+// backend's catalog carries one and only falls back here without it.
+const OPENAI_MODELS = new Set(['gpt-6-astra', 'gpt-6-sol', 'gpt-6-luna', 'gpt-6-1-sol']);
 const OPENAI_PROVIDERS = new Set(['openai', 'openai-oauth']);
 const ANTHROPIC_PROVIDERS = new Set(['anthropic', 'anthropic-oauth']);
 const EFFORTS = new Set(['minimal', 'low', 'medium', 'high', 'xhigh', 'max']);
@@ -35,11 +44,16 @@ function modelKey(model) {
     .replace(/\./g, '-');
 }
 
+function openAiSupportsEffortUpdates(provider, model, id) {
+  const declared = provider === 'openai-oauth' ? codexModelSupportsEffortUpdates(String(model || '').trim()) : null;
+  return declared ?? OPENAI_MODELS.has(id);
+}
+
 // Explicit protocol capabilities, not a prediction about future model families.
 export function effortConfigurationMode(provider, model, opts = {}) {
   const id = modelKey(model);
   if (opts.effortConfigurationEnabled === false || Number(opts.thinkingBudgetTokens) > 0) return null;
-  if (OPENAI_PROVIDERS.has(provider) && OPENAI_MODELS.has(id)) {
+  if (OPENAI_PROVIDERS.has(provider) && openAiSupportsEffortUpdates(provider, model, id)) {
     const parameters = opts.modelParameters || {};
     const mode = opts.reasoning?.mode ?? parameters.reasoning_mode ?? parameters.mode ?? 'standard';
     if (mode !== 'standard' || opts.multiAgent === true || parameters.multi_agent === true) return null;

package/src/runtime/agent/orchestrator/providers/grok-client-version.mjs

@@ -3,9 +3,9 @@ import { createNpmVersionSource, maxSemver } from './npm-cli-version.mjs';
 // Grok CLI client version for the cli-chat-proxy version gate (HTTP 426).
 // Effective = env override, else max(floor, learned-from-426, live npm latest
 // of the official @xai-official/grok CLI).
-export const GROK_CLI_VERSION_FLOOR = '0.2.87';
+export const GROK_CLI_VERSION_FLOOR = '1.0.46';
 
-const live = createNpmVersionSource('@xai-official/grok');
+const live = createNpmVersionSource('@xai-official/grok', { persistKey: 'grok-cli' });
 let envVersion;
 let learned = null;
 

package/src/runtime/agent/orchestrator/providers/lib/anthropic-models.mjs

@@ -3,6 +3,12 @@
 export const MODELS = [
   { id: 'claude-opus-5-5', name: 'Claude Opus 5.5', provider: 'anthropic', family: 'opus', contextWindow: 1000000 },
   { id: 'claude-fable-5-1', name: 'Claude Fable 5.1', provider: 'anthropic', family: 'fable', contextWindow: 1000000 },
-  { id: 'claude-sonnet-5', name: 'Claude Sonnet 5', provider: 'anthropic', family: 'sonnet', contextWindow: 1000000 },
+  {
+    id: 'claude-sonnet-5-5',
+    name: 'Claude Sonnet 5.5',
+    provider: 'anthropic',
+    family: 'sonnet',
+    contextWindow: 1000000,
+  },
 ];
 export const ANTHROPIC_VERSION = '2023-06-01';

package/src/runtime/agent/orchestrator/providers/npm-cli-version.mjs

@@ -3,6 +3,12 @@
 // Sync accessor never blocks (kicks a background refresh); warm() is the
 // awaitable cold-start path. Failures resolve to null so callers fall back to
 // their floor. MIXDOG_DISABLE_LIVE_CLI_VERSIONS=1 turns the lookup off.
+//
+// A source given a `persistKey` also remembers its last live answer on disk,
+// so a new process (or an offline one) starts from the newest version this
+// machine has seen rather than from a floor that only moves with a release.
+
+import { readLastKnownVersion, rememberLastKnownVersion } from './client-version-store.mjs';
 
 const SEMVER = /^\d+\.\d+\.\d+$/;
 const DEFAULT_TTL_MS = 24 * 60 * 60_000;
@@ -43,10 +49,22 @@ export function createNpmVersionSource(pkg, options) {
  * Generic source: GET `url`, `parse(res)` returns the version string or null
  * (unrecognised format). Same TTL/in-flight/timeout/disable rules as npm.
  */
-export function createRemoteVersionSource(url, parse, { ttlMs = DEFAULT_TTL_MS, timeoutMs = TIMEOUT_MS } = {}) {
+export function createRemoteVersionSource(
+  url,
+  parse,
+  { ttlMs = DEFAULT_TTL_MS, timeoutMs = TIMEOUT_MS, persistKey = null } = {}
+) {
   let value = null;
   let expiresAt = 0;
   let inFlight = null;
+  let lastKnownLoaded = false;
+
+  // Stale on purpose: it answers until the refresh lands, never instead of it.
+  function loadLastKnown() {
+    if (lastKnownLoaded) return;
+    lastKnownLoaded = true;
+    if (!value) value = readLastKnownVersion(persistKey);
+  }
 
   async function refresh() {
     let next = null;
@@ -56,7 +74,10 @@ export function createRemoteVersionSource(url, parse, { ttlMs = DEFAULT_TTL_MS,
     } catch {
       /* offline or slow — keep previous/floor */
     }
-    if (next) value = next;
+    if (next) {
+      value = next;
+      rememberLastKnownVersion(persistKey, next);
+    }
     expiresAt = Date.now() + (next ? ttlMs : FAILURE_TTL_MS);
     return value;
   }
@@ -76,11 +97,13 @@ export function createRemoteVersionSource(url, parse, { ttlMs = DEFAULT_TTL_MS,
   return {
     /** Cached live version or null; refreshes in the background when stale. */
     sync() {
+      loadLastKnown();
       if (!fresh()) ensureRefresh();
       return value;
     },
     /** Awaitable, never rejects; bounded by the fetch timeout. */
     warm() {
+      loadLastKnown();
       return fresh() ? Promise.resolve(value) : ensureRefresh();
     },
   };

package/src/runtime/agent/orchestrator/providers/oauth-credential-probes.mjs

@@ -154,7 +154,13 @@ function openAIOAuthState() {
 }
 
 function grokOAuthState() {
-  const paths = [process.env.GROK_OAUTH_CREDENTIALS_PATH, join(resolvePluginData(), 'grok-oauth.json')];
+  // Same account/path precedence as the token store (getOwnTokenPath): a login
+  // lands in the selected account's pool file, never the legacy root file.
+  const paths = [
+    boundProviderAuthPath('grok-oauth') ||
+      process.env.GROK_OAUTH_CREDENTIALS_PATH ||
+      join(resolvePluginData(), 'grok-oauth.json'),
+  ];
   return memoProbe('grok-oauth', paths, () =>
     resolveProbeState(paths, (docs) => docs.some((own) => !!(own?.access_token && own?.refresh_token)))
   );

package/src/runtime/agent/orchestrator/providers/openai-codex-model.mjs

@@ -86,6 +86,10 @@ export function _normalizeCodexModel(m) {
     supportVerbosity: m?.support_verbosity === true,
     defaultVerbosity: m?.default_verbosity || null,
     supportsReasoningSummaries: m?.supports_reasoning_summaries === true,
+    // Absent on an older catalog: the caller then falls back to its own list.
+    ...(typeof m?.supports_reasoning_effort_updates === 'boolean'
+      ? { supportsReasoningEffortUpdates: m.supports_reasoning_effort_updates }
+      : {}),
     ...(typeof m?.supports_image_generation === 'boolean'
       ? { supportsImageGeneration: m.supports_image_generation }
       : {}),

package/src/runtime/agent/orchestrator/providers/openai-compat-xai.mjs

@@ -14,6 +14,7 @@ import { appendAgentTrace } from '../agent-trace.mjs';
 import { resolveProviderCacheKey, resolveProviderPromptCacheLane } from '../agent-runtime/cache-strategy.mjs';
 import { shouldFallbackTransport } from './retry-classifier.mjs';
 import { envFlag as _envFlag } from '../../../shared/env.mjs';
+import { getModelsDevRowSync } from '../../../shared/llm/model-catalog.mjs';
 import {
   traceHash,
   stableTraceStringify,
@@ -161,6 +162,13 @@ export function xaiModelSupportsReasoningEffort(model) {
     .toLowerCase();
   if (!id) return true;
   if (!id.startsWith('grok')) return true;
+  // The catalog answers first: a listed model takes the parameter exactly
+  // when it publishes effort values (grok-4.3 does, grok-4.20-*-reasoning
+  // does not), so a new release needs no edit here.
+  const listed = getModelsDevRowSync(id, 'xai');
+  if (listed) {
+    return (listed.reasoning_options || []).some((option) => option?.type === 'effort' && option.values?.length > 0);
+  }
   // grok-4.5 / grok-4.6 and anything newer in that line.
   return /grok[-_]?4\.(?:[5-9]|\d{2,})/.test(id);
 }

package/src/runtime/agent/orchestrator/providers/openai-direct-request.mjs

@@ -1,13 +1,27 @@
+import { getModelMetadataSync } from '../../../shared/llm/model-catalog.mjs';
+
 // Public Responses contracts are independent of the OAuth backend.
 // Match documented model IDs and dated snapshots, not unknown future families.
 // GPT-5.6 and later: prompt_cache_options caching and Fast mode.
-const GPT_56_PLUS_MODELS = /^(?:gpt-6-(?:astra|sol|luna)|gpt-5\.6-(?:sol|terra|luna))(?:-\d{4}-\d{2}-\d{2})?$/;
+const GPT_56_PLUS_MODELS =
+  /^(?:gpt-6-(?:astra|sol|luna)|gpt-6\.1-sol|gpt-5\.6-(?:sol|terra|luna))(?:-\d{4}-\d{2}-\d{2})?$/;
+
+// OpenAI bills prompt-cache writes from GPT-5.6 on, and exactly those models
+// take prompt_cache_options and Fast mode. The id pattern is the offline
+// floor; a published cache-write price admits a later model without an edit
+// here, and a family no catalog lists yet stays out.
+// https://developers.openai.com/api/docs/guides/prompt-caching
+function isGpt56PlusModel(model) {
+  const id = String(model || '').trim();
+  if (!id) return false;
+  return GPT_56_PLUS_MODELS.test(id) || getModelMetadataSync(id, 'openai')?.cacheWriteCostPerM > 0;
+}
 // Earlier models documented for Priority processing (now Fast mode).
 const EARLIER_FAST_MODELS = /^gpt-5\.(?:5|4|4-mini)(?:-\d{4}|$)/;
 
 export function openAiDirectSupportsFast(model) {
   const id = String(model?.id || model || '').trim();
-  return GPT_56_PLUS_MODELS.test(id) || EARLIER_FAST_MODELS.test(id);
+  return isGpt56PlusModel(id) || EARLIER_FAST_MODELS.test(id);
 }
 
 export function applyOpenAIDirectCachePolicy(body, model, storeResponses) {
@@ -17,7 +31,7 @@ export function applyOpenAIDirectCachePolicy(body, model, storeResponses) {
   // Preserve the existing opt-out: no explicit cache-retention hint when
   // response storage is disabled. The provider's default cache still applies.
   if (!storeResponses) return body;
-  if (GPT_56_PLUS_MODELS.test(String(model || '').trim())) {
+  if (isGpt56PlusModel(model)) {
     body.prompt_cache_options = { ttl: '30m' };
   } else {
     body.prompt_cache_retention = '24h';

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

@@ -21,7 +21,7 @@ import { CODEX_OAUTH_ORIGINATOR, codexModelsUrl } from './openai-codex-endpoints
 import { _normalizeCodexModel, _markLatestCodex } from './openai-codex-model.mjs';
 
 const CODEX_MODEL_CACHE_TTL_MS = 24 * 60 * 60_000;
-const CODEX_MODEL_CACHE_SCHEMA_VERSION = 5;
+const CODEX_MODEL_CACHE_SCHEMA_VERSION = 6;
 const CATALOG_FETCH_TIMEOUT_MS = 10_000;
 
 // In-memory mirror of the on-disk catalog, same pattern as anthropic-oauth.
@@ -59,6 +59,12 @@ export function codexCatalogHas(id) {
   return _mirror.some((m) => m.id === id);
 }
 
+/** The catalog's own answer, or null when it has none for this model. */
+export function codexModelSupportsEffortUpdates(id) {
+  const supported = findCachedCodexModel(id)?.supportsReasoningEffortUpdates;
+  return typeof supported === 'boolean' ? supported : null;
+}
+
 export function codexModelSupportsServiceTier(id, serviceTier) {
   return modelSupportsServiceTier(findCachedCodexModel(id), serviceTier);
 }

package/src/runtime/agent/orchestrator/providers/retry-classification.mjs

@@ -469,6 +469,22 @@ const CONTEXT_OVERFLOW_PATTERNS = [
   /context[_ ]length[_ ]exceeded/i,
   /prompt is too long/i,
   /reduce the length of (?:the )?(?:messages|input|prompt)/i,
+  // Wordings other backends use for the same refusal, each tied to a context
+  // or input-length noun so a tokens-per-minute rate limit never matches.
+  /prompt too long/i, // z.ai, Ollama
+  /prompt exceeds max length/i, // z.ai CN endpoint
+  /input is too long for requested model/i, // Amazon Bedrock
+  /input token count.*exceeds the maximum/i, // Google
+  /maximum prompt length is \d+/i, // xAI
+  /exceeds (?:the )?maximum allowed input length/i, // OpenRouter relays
+  /is longer than the model'?s context length/i, // Together AI
+  /exceeds the available context size/i, // llama.cpp server
+  /greater than the context length/i, // LM Studio
+  /context window exceeds limit/i, // MiniMax
+  /exceeded model token limit/i, // Kimi
+  /too large for model with \d+ maximum context length/i, // Mistral
+  /range of input length should be/i, // DashScope / Qwen
+  /model_context_window_exceeded/i, // z.ai finish reason surfaced as text
 ];
 
 /**

package/src/runtime/agent/orchestrator/runtime-core/builtin-features.mjs

@@ -148,26 +148,6 @@ export function localGitToolsActive(configLike, { gitAvailable } = {}) {
   );
 }
 
-/** Capabilities that ask the user once per session before their first live
- *  call: the desktop and the browser are the user's, and one approval at the
- *  moment of first use is how the user learns the model reached for them. */
-export const BRIDGE_FIRST_USE_IDS = Object.freeze(['browser', 'computer']);
-
-/** On unless the profile turns it off for that capability;
- *  MIXDOG_BRIDGE_FIRST_USE_APPROVAL overrides per process (headless, bench). */
-export function builtinFirstUseApproval(configLike, id) {
-  return (
-    featureEnvOverride('MIXDOG_BRIDGE_FIRST_USE_APPROVAL') ?? configLike?.builtins?.[id]?.firstUseApproval !== false
-  );
-}
-
-export function setBuiltinFirstUseApprovalInConfig(configLike, id, enabled) {
-  const next = { ...(configLike || {}) };
-  next.builtins = { ...(next.builtins || {}) };
-  next.builtins[id] = { ...(next.builtins[id] || {}), firstUseApproval: enabled !== false };
-  return next;
-}
-
 export function setBuiltinInstalledInConfig(configLike, id, installed = true) {
   const next = { ...(configLike || {}) };
   next.builtins = { ...(next.builtins || {}) };

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

@@ -5,6 +5,7 @@
 import { clean, hasOwn } from './session-text.mjs';
 import { modelSupportsServiceTier } from '../providers/model-service-tiers.mjs';
 import { openAiDirectSupportsFast } from '../providers/openai-direct-request.mjs';
+import { supportsAnthropicFastMode } from '../../../shared/llm/anthropic-betas.mjs';
 
 const FAST_CAPABLE_PROVIDERS = new Set([
   'anthropic',
@@ -52,16 +53,11 @@ function geminiModelSupportsHostedWebSearch(model) {
 function anthropicModelSupportsHostedWebSearch(model) {
   const id = clean(model?.id || model).toLowerCase();
   if (!id) return false;
-  const match = id.match(/^claude-(opus|sonnet|haiku)-(\d+)(?:[-.](\d+))?/);
+  const match = id.match(/^claude-(opus|sonnet|haiku|fable|mythos)-(\d+)(?:[-.](\d+))?/);
   if (!match) return false;
   return (Number(match[2]) || 0) >= 4;
 }
 
-function anthropicModelMetaSupportsFast(model) {
-  const id = clean(model?.id || model).toLowerCase();
-  return /^claude-(opus|sonnet)/.test(id);
-}
-
 export function fastCapableFor(provider, model, effort = null, modelParameters = {}) {
   const p = clean(provider);
   if (!FAST_CAPABLE_PROVIDERS.has(p)) return false;
@@ -82,7 +78,7 @@ export function fastCapableFor(provider, model, effort = null, modelParameters =
   }
   if (p === 'openai') return openAiDirectSupportsFast(model);
   if (p === 'openai-oauth') return modelSupportsServiceTier(model, 'priority');
-  if (p === 'anthropic' || p === 'anthropic-oauth') return anthropicModelMetaSupportsFast(model);
+  if (p === 'anthropic' || p === 'anthropic-oauth') return supportsAnthropicFastMode(clean(model?.id || model));
   return false;
 }
 
@@ -127,9 +123,15 @@ export function saveModelSettings(cfgMod, route, { fastCapable = true, baseConfi
   } else {
     delete nextSetting.modelParameters;
   }
-  const contextPercent = Number(route.contextPercent);
-  if (Number.isFinite(contextPercent) && contextPercent >= 10 && contextPercent <= 100) {
-    nextSetting.contextPercent = Math.round(contextPercent / 10) * 10;
+  // Only a window the user moved off the model's default is a setting. The
+  // 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.
+  const requestedPercent = Number(route.contextPercent);
+  const contextPercent = Math.round(requestedPercent / 10) * 10;
+  const isDefault = contextPercent === Number(route.contextDefaultPercent);
+  if (requestedPercent >= 10 && requestedPercent <= 100 && !isDefault) {
+    nextSetting.contextPercent = contextPercent;
   } else {
     delete nextSetting.contextPercent;
   }

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

@@ -119,7 +119,9 @@ function summarySendOpts(opts) {
     effort: 'low',
     effortConfiguration: undefined,
     effortConfigurationEnabled: false,
-    fast: opts.fast ?? opts.sendOpts?.fast ?? true,
+    // Fast mode is opt-in (it needs separate account credits); the summary
+    // follows the route/session choice and never enables it on its own.
+    fast: opts.fast ?? opts.sendOpts?.fast ?? false,
     maxOutputTokens: opts.maxOutputTokens || SUMMARY_OUTPUT_TOKENS,
     providerState: undefined,
     onToolCall: undefined,

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

@@ -54,7 +54,7 @@ export async function resolveCompactionRoute({
   const contextWindow =
     sameModel && positiveInt(sessionRef?.contextWindow)
       ? positiveInt(sessionRef.contextWindow)
-      : resolveSessionContextMeta(selectedProvider, selectedModel).contextWindow;
+      : resolveSessionContextMeta(selectedProvider, selectedModel, {}, { wholeWindow: true }).contextWindow;
   return {
     provider: selectedProvider,
     providerName,

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

@@ -2,6 +2,7 @@
 // resolution.
 
 import { getModelMetadataSync } from '../../providers/model-catalog.mjs';
+import { contextWindowRange } from '../../../../shared/llm/default-context-window.mjs';
 import { positiveInt } from '../../../../shared/numbers.mjs';
 
 // Family-pattern fallback used only when the provider and external catalogs
@@ -96,11 +97,12 @@ function providerRawContextWindow(info, catalogInfo) {
   if (catalogWindow && fromCache !== catalogWindow) return catalogWindow;
   return fromCache || null;
 }
-export function resolveSessionContextMeta(provider, model, seed = {}) {
+// `wholeWindow` asks for everything the model can take in (the summary route
+// budgets its own input that way) instead of the window a session starts with.
+export function resolveSessionContextMeta(provider, model, seed = {}, { wholeWindow = false } = {}) {
   const info = typeof provider?.getCachedModelInfo === 'function' ? provider.getCachedModelInfo(model) : null;
   const catalogInfo = getModelMetadataSync(model, providerNameOf(provider));
-  const requestedContextWindow =
-    positiveInt(seed.selectedContextWindow) ||
+  const servedContextWindow =
     providerRawContextWindow(info, catalogInfo) ||
     positiveInt(catalogInfo?.contextWindow) ||
     positiveInt(catalogInfo?.maxContextWindow) ||
@@ -110,6 +112,16 @@ export function resolveSessionContextMeta(provider, model, seed = {}) {
     positiveInt(seed.raw_context_window) ||
     positiveInt(seed.contextWindow) ||
     guessContextWindow(model, providerNameOf(provider));
+  // A session that records no selection starts from the model's default
+  // window, the one the picker shows. A recorded percentage without its window
+  // (a session older than selectedContextWindow, a route saved before the
+  // catalog warmed) is still the user's choice and keeps the served window.
+  const recordsSelection = wholeWindow || boundedPercent(seed.contextPercent) !== null;
+  const requestedContextWindow =
+    positiveInt(seed.selectedContextWindow) ||
+    (recordsSelection
+      ? servedContextWindow
+      : contextWindowRange({ provider: providerNameOf(provider), contextWindow: servedContextWindow }).defaultWindow);
   // A managed runtime's allocated capacity also bounds restored selections
   // and catalog metadata; raising a slider cannot allocate server memory.
   const runtimeContextWindow = positiveInt(info?.runtimeContextWindow);

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

@@ -13,7 +13,12 @@ import { buildProviderCacheOpts, cacheCapabilityForProvider } from '../../agent-
 import { normalizeAutoClearConfig, resolveAutoClearIdleMs } from '../../runtime-core/config-helpers.mjs';
 import { _buildBaseRules } from './rules-cache.mjs';
 import { composeSessionSystem, seedSessionMessages } from './session-prompt-composition.mjs';
-import { _prepareResumeTools, delegationDisabled, resolveSessionToolSurface } from './session-tool-surface.mjs';
+import {
+  _prepareResumeTools,
+  delegationDisabled,
+  honoredSchemaAllowlist,
+  resolveSessionToolSurface,
+} from './session-tool-surface.mjs';
 import { _forgetPreparedResume, _preparedResumeMatches, _readPreparedResume } from './prepared-resume-cache.mjs';
 import {
   filterModelEditToolNames,
@@ -175,6 +180,7 @@ export function createSession(opts) {
   logSessionSurface(surface);
   const contextMeta = resolveSessionContextMeta(provider, modelName, {
     selectedContextWindow: opts.selectedContextWindow,
+    contextPercent: route.contextPercent,
   });
   const session = buildSessionRecord({
     opts,
@@ -215,7 +221,10 @@ export function _refreshSessionRuleVariantsForModel(session, previousModel, prev
     ...(getHiddenAgent(session?.agent || null) ? ['Skill'] : []),
     ...(delegationDisabled(session, isAgentOwner(session)) ? ['agent'] : []),
   ];
-  const allowTools = isAgentOwner(session) ? null : session?.schemaAllowedTools;
+  const allowTools = honoredSchemaAllowlist(session?.schemaAllowedTools, {
+    ownerIsAgent: isAgentOwner(session),
+    agent: session?.agent || null,
+  });
   const previousRules = _buildBaseRules({
     omitTools: [...deny, unusedModelEditToolName(previousModel)],
     allowTools,

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

@@ -63,7 +63,11 @@ function buildShellEnvironmentContext(opts, ownerIsAgent, toolsForRouting) {
 // four system blocks; environmentTailContext is the persisted env tail.
 export function composeSessionSystem(opts, { profile, providerName, modelName, surface }) {
   const { ownerIsAgent, resolvedAgent, skills } = surface;
-  const skipAgentRules = opts.skipAgentRules === true;
+  // A tool-free hidden role (a one-shot classifier or title writer) carries
+  // only its own role rules: the shared tool policy and the worker conduct
+  // rules describe work it is offered no tool for.
+  const toolFreeRole = ownerIsAgent && surface.schemaAllowedTools?.length === 0;
+  const skipAgentRules = opts.skipAgentRules === true || toolFreeRole;
   const injectedRules = skipAgentRules
     ? ''
     : _buildBaseRules({

package/src/runtime/agent/orchestrator/session/manager/session-tool-surface.mjs

@@ -29,6 +29,19 @@ function resolveToolSpec(toolPreset, profile, ownerIsAgent) {
   return Array.isArray(profile?.tools) ? profile.tools : toolPreset;
 }
 
+// The schema allowlist a session honours. Agent-owned sessions share one
+// schema, so an allowlist handed down by a caller never narrows them — except
+// the profile the session's own hidden role declares (agents.json
+// toolSchemaProfile). Without that exception a tool-free maintenance role was
+// sent the whole Agent schema on every one-shot call while the dispatch gate
+// refused each of those tools (usage ledger 2026-09-30..10-05: 4104 cycle1
+// calls at ~8.5K prompt tokens, about two thirds of it the 12-tool schema).
+export function honoredSchemaAllowlist(schemaAllowedTools, { ownerIsAgent = false, agent = null } = {}) {
+  if (!Array.isArray(schemaAllowedTools)) return null;
+  if (ownerIsAgent && !getHiddenAgent(agent)) return null;
+  return schemaAllowedTools;
+}
+
 // Every tool omitted by a caller schema allowlist is omitted from BP1 too.
 // The model never receives guidance for a tool it cannot call, and a new
 // process-wide built-in cannot leak into a narrow profile's prompt.
@@ -48,13 +61,17 @@ export function resolveSessionToolSurface(opts, { profile, toolPreset, modelName
   const resolvedAgent = opts.agent || opts.role || profile?.taskType || null;
   const hiddenAgent = getHiddenAgent(resolvedAgent);
   const isRetrievalAgent = hiddenAgent?.kind === 'retrieval';
-  // Lead and Agent share the same cwd-scoped Skill inventory.
-  const skills = opts.skipSkills ? [] : collectPromptSkillsCached(opts.cwd);
-  // BP1 shared tool policy ships to EVERY role (Lead, workers, retrieval,
-  // maintenance): its anti-spiral clauses (one anchor is enough, never
+  const hasCallerAllow = Array.isArray(opts.schemaAllowedTools);
+  const schemaAllowedTools = honoredSchemaAllowlist(opts.schemaAllowedTools, { ownerIsAgent, agent: resolvedAgent });
+  // Lead and Agent share the same cwd-scoped Skill inventory. A session that
+  // is offered no tool cannot load a skill, so it is not sent the manifest.
+  const skills = opts.skipSkills || schemaAllowedTools?.length === 0 ? [] : collectPromptSkillsCached(opts.cwd);
+  // BP1 shared tool policy ships to every role that is offered tools (Lead,
+  // workers, retrieval): its anti-spiral clauses (one anchor is enough, never
   // repeat equivalent patterns/scopes, plausible hit → stop) are exactly
   // what narrow retrieval roles need. Role docs
-  // override role-inapplicable entries.
+  // override role-inapplicable entries. A tool-free role is sent none of it
+  // (session-prompt-composition.mjs).
   const sessionDeny = [
     ...(Array.isArray(opts.disallowedTools) ? opts.disallowedTools : []),
     ...(delegationDisabled(opts, ownerIsAgent) ? ['agent'] : []),
@@ -70,8 +87,6 @@ export function resolveSessionToolSurface(opts, { profile, toolPreset, modelName
     cwd: opts.cwd || null,
   });
 
-  const hasCallerAllow = Array.isArray(opts.schemaAllowedTools);
-  const schemaAllowedTools = ownerIsAgent || !hasCallerAllow ? null : opts.schemaAllowedTools;
   const tools = finalizeSessionToolList(toolsForRouting, {
     schemaAllowedTools,
     disallowedTools: sessionDeny,
@@ -121,8 +136,7 @@ export function _prepareResumeTools(session, preset) {
     toolSpec,
     ownerIsAgent,
     tools: finalizeSessionToolList(toolsForRouting, {
-      schemaAllowedTools:
-        !ownerIsAgent && Array.isArray(session.schemaAllowedTools) ? session.schemaAllowedTools : null,
+      schemaAllowedTools: honoredSchemaAllowlist(session.schemaAllowedTools, { ownerIsAgent, agent: session.agent }),
       disallowedTools: [
         ...(Array.isArray(session.disallowedTools) ? session.disallowedTools : []),
         ...(delegationDisabled(session, ownerIsAgent) ? ['agent'] : []),