mixdog 1.0.8 → 1.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "private": false,
   "type": "module",
   "description": "Open-source coding agent that matches Codex on Terminal-Bench 2.1 with 63% fewer tokens.",
@@ -106,6 +106,7 @@
     "bench:office:quality:live": "node src/runtime/office/bench/quality-live-benchmark.mjs",
     "diag:sessions": "node scripts/session-diag.mjs",
     "diag:tools": "node scripts/tool-efficiency-diag.mjs",
+    "diag:efficiency": "node scripts/session-efficiency-diag.mjs",
     "diag:sweep": "node scripts/session-sweep.mjs",
     "bench:session": "node scripts/session-bench.mjs",
     "bench:task": "node scripts/task-bench.mjs",

package/scripts/lib/run-node-tests.mjs

@@ -13,6 +13,8 @@ const SUMMARY_REPORTER = new URL('./test-summary-reporter.mjs', import.meta.url)
 // instead of dying with spawn ENAMETOOLONG before any test runs.
 export const ARG_BUDGET = process.platform === 'win32' ? 30_000 : 1_000_000;
 
+const HEAP_FLAG = /^--(?:max-old-space-size|max-semi-space-size)=\d+$/;
+
 // An argument costs its own characters plus the separator and its quotes.
 const argCost = (arg) => arg.length + 3;
 
@@ -145,6 +147,12 @@ export async function runNodeTests(
     argCost('.999'); // the per-batch log suffix
   const batches = chunkFileArgs(fileArgs, Math.max(argBudget - fixedCost, 1));
   const coverageDir = coverage ? await mkdtemp(join(tmpdir(), 'mixdog-v8-coverage-')) : '';
+  // Node 24's test runner rebuilds each test process's execArgv from its option
+  // table and drops V8 flags on the way, so a heap cap passed to the runner no
+  // longer reached a test (a 128 MB cap ran with the default 4 GB). The
+  // environment still reaches every test process.
+  const heapOptions = nodeArgs.filter((arg) => HEAP_FLAG.test(arg));
+  const nodeOptions = [process.env.NODE_OPTIONS, ...heapOptions].filter(Boolean).join(' ');
   // Failure records travel by environment, not argv: the command line is
   // already budgeted, and a third reporter would warn about listeners.
   const childEnv = (recordsPath) => ({
@@ -152,11 +160,16 @@ export async function runNodeTests(
     TEMP: scratchDir,
     TMP: scratchDir,
     TMPDIR: scratchDir,
+    // A fixture must never write into the signed-in app's data (~/.mixdog):
+    // schedule/webhook logs, design-library bindings and the like resolve the
+    // default data dir. The desktop preload already does this per process.
+    MIXDOG_DATA_DIR: join(scratchDir, 'data'),
     // Only the immutable validator binary is shared; fixture data stays private.
     // A gate supplies one directory across lanes; a standalone run owns its own.
     MIXDOG_TEST_OOXML_CACHE_DIR: process.env.MIXDOG_TEST_OOXML_CACHE_DIR || join(scratchDir, 'ooxml-cache'),
     [FAILURE_RECORDS_ENV]: recordsPath,
     ...(coverageDir ? { NODE_V8_COVERAGE: coverageDir } : {}),
+    ...(nodeOptions ? { NODE_OPTIONS: nodeOptions } : {}),
   });
   let status = 0;
   const failures = [];

package/scripts/session-efficiency-diag.mjs

@@ -0,0 +1,283 @@
+#!/usr/bin/env node
+// Token-efficiency diag over the stored session transcripts. The trace-based
+// diags (session-diag, tool-efficiency-diag) need agent-trace.jsonl, which a
+// shipped build does not write; the session store is always there.
+// Usage: node scripts/session-efficiency-diag.mjs [--since 5d] [--data-dir <dir>] [--agent lead] [--json]
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { argValue, hasFlag } from './lib/cli-args.mjs';
+import { parseSince } from './lib/parse-since.mjs';
+import { DEFAULT_SHELL_AUTO_BACKGROUND_MS } from '../src/runtime/agent/orchestrator/tools/builtin/bash-tool/deadline-plan.mjs';
+
+const CONTEXT_BUCKETS = [50_000, 100_000, 200_000, 300_000, 500_000, Infinity];
+// Fallback for a session that never recorded a provider context size.
+const FALLBACK_TOKENS_PER_BYTE = 0.3;
+
+const size = (value) => {
+  if (value == null) return 0;
+  return typeof value === 'string' ? value.length : JSON.stringify(value).length;
+};
+
+function replayBytes(message) {
+  let bytes = 0;
+  for (const item of message.providerReplay?.items || []) {
+    if (item?.type !== 'thinking' && item?.type !== 'redacted_thinking' && item?.type !== 'reasoning') continue;
+    bytes += size(item.thinking) + size(item.signature) + size(item.data) + size(item.encrypted_content);
+  }
+  return bytes;
+}
+
+function userCategory(message) {
+  return message.meta === 'skill' ? 'skills' : 'user';
+}
+
+function add(map, key, fields) {
+  const row = map.get(key) || {};
+  for (const [name, value] of Object.entries(fields)) row[name] = (row[name] || 0) + value;
+  map.set(key, row);
+  return row;
+}
+
+export function createSummary() {
+  return {
+    sessions: 0,
+    requests: 0,
+    groups: new Map(),
+    carry: new Map(),
+    tools: new Map(),
+    buckets: new Map(),
+    shell: {},
+  };
+}
+
+// Folds one stored session into the summary. A message's carry is its size
+// times the requests sent after it: every later request re-sends it.
+export function addSession(summary, session) {
+  const messages = Array.isArray(session?.messages) ? session.messages : [];
+  const requests = messages.filter((message) => message.role === 'assistant').length;
+  if (!requests) return;
+  summary.sessions++;
+  summary.requests += requests;
+  const group = add(summary.groups, `${session.agent || '-'} @${session.model || '-'}`, { sessions: 1, requests });
+  const shell = summary.shell;
+  const callsById = new Map();
+  const promoted = new Map();
+  const prefixes = [];
+  let prefix = size(session.tools);
+  let later = requests;
+  for (const message of messages) {
+    if (message.role === 'assistant') {
+      later--;
+      prefixes.push(prefix);
+      const calls = Array.isArray(message.toolCalls) ? message.toolCalls : [];
+      let argBytes = 0;
+      for (const call of calls) {
+        argBytes += size(call.arguments) + size(call.name);
+        callsById.set(call.id, { ...call, alone: calls.length === 1 });
+      }
+      const thinking = replayBytes(message);
+      const text = size(message.content);
+      add(summary.carry, 'tool args', { bytes: argBytes * later });
+      add(summary.carry, 'thinking', { bytes: thinking * later });
+      add(summary.carry, 'assistant text', { bytes: text * later });
+      group.calls = (group.calls || 0) + calls.length;
+      if (calls.length) group.toolRequests = (group.toolRequests || 0) + 1;
+      if (calls.length === 1) group.singleCall = (group.singleCall || 0) + 1;
+      if (calls.length && calls.every((call) => call.name === 'task' && call.arguments?.action === 'wait')) {
+        shell.taskWaitOnlyRequests = (shell.taskWaitOnlyRequests || 0) + 1;
+      }
+      prefix += argBytes + thinking + text;
+      continue;
+    }
+    const bytes = size(message.content);
+    prefix += bytes;
+    if (message.role === 'system') add(summary.carry, 'system', { bytes: bytes * later });
+    else if (message.role === 'user') add(summary.carry, userCategory(message), { bytes: bytes * later });
+    else if (message.role === 'tool') {
+      add(summary.carry, 'tool results', { bytes: bytes * later });
+      const call = callsById.get(message.toolCallId);
+      if (!call) continue;
+      add(summary.tools, call.name, { calls: 1, bytes, carry: bytes * later });
+      const text = typeof message.content === 'string' ? message.content : '';
+      if (call.name === 'shell') recordShellCall(shell, promoted, call, text);
+      else if (call.name === 'task') recordTaskResult(shell, promoted, call, text);
+    }
+  }
+  const lastContext = Number(session.lastContextTokens) || 0;
+  const tokensPerByte = lastContext > 0 && prefix > 0 ? lastContext / prefix : FALLBACK_TOKENS_PER_BYTE;
+  for (const bytes of prefixes) {
+    const context = bytes * tokensPerByte;
+    group.tokenRequests = (group.tokenRequests || 0) + context;
+    add(
+      summary.buckets,
+      CONTEXT_BUCKETS.find((limit) => context < limit),
+      { requests: 1, tokenRequests: context }
+    );
+  }
+}
+
+function recordShellCall(shell, promoted, call, text) {
+  shell.calls = (shell.calls || 0) + 1;
+  const waitMs = call.arguments?.wait_ms;
+  const shortWait = Number.isFinite(waitMs) && waitMs < DEFAULT_SHELL_AUTO_BACKGROUND_MS;
+  if (shortWait) shell.shortWait = (shell.shortWait || 0) + 1;
+  if (!text.startsWith('background task')) return;
+  shell.promoted = (shell.promoted || 0) + 1;
+  if (shortWait) shell.shortWaitPromoted = (shell.shortWaitPromoted || 0) + 1;
+  const taskId = /^task_id: (\S+)/m.exec(text)?.[1];
+  if (taskId) promoted.set(taskId, { shortWait, durationKnown: false });
+}
+
+// The first task result that reports both timestamps settles how long the
+// promoted command really ran.
+function recordTaskResult(shell, promoted, call, text) {
+  const job = promoted.get(call.arguments?.task_id);
+  if (!job || job.durationKnown) return;
+  const started = Date.parse(/^started: (\S+)/m.exec(text)?.[1] || '');
+  const finished = Date.parse(/^finished: (\S+)/m.exec(text)?.[1] || '');
+  if (!Number.isFinite(started) || !Number.isFinite(finished)) return;
+  job.durationKnown = true;
+  if (!job.shortWait) return;
+  shell.shortWaitTimed = (shell.shortWaitTimed || 0) + 1;
+  if (finished - started <= DEFAULT_SHELL_AUTO_BACKGROUND_MS) {
+    shell.shortWaitInsideDefault = (shell.shortWaitInsideDefault || 0) + 1;
+  }
+}
+
+const share = (part, whole) => (whole > 0 ? Math.round((part / whole) * 1000) / 10 : 0);
+
+export function buildReport(summary) {
+  const carryTotal = [...summary.carry.values()].reduce((sum, row) => sum + row.bytes, 0);
+  const toolCarryTotal = [...summary.tools.values()].reduce((sum, row) => sum + row.carry, 0);
+  const tokenRequestTotal = [...summary.buckets.values()].reduce((sum, row) => sum + row.tokenRequests, 0);
+  return {
+    sessions: summary.sessions,
+    requests: summary.requests,
+    groups: [...summary.groups.entries()]
+      .map(([name, row]) => ({
+        name,
+        sessions: row.sessions,
+        requests: row.requests,
+        callsPerToolRequest: row.toolRequests ? Math.round((row.calls / row.toolRequests) * 100) / 100 : 0,
+        singleCallPct: share(row.singleCall || 0, row.toolRequests || 0),
+        avgContextTokens: Math.round((row.tokenRequests || 0) / row.requests),
+        tokenRequests: Math.round(row.tokenRequests || 0),
+      }))
+      .sort((a, b) => b.tokenRequests - a.tokenRequests),
+    carry: [...summary.carry.entries()]
+      .map(([name, row]) => ({ name, pct: share(row.bytes, carryTotal) }))
+      .sort((a, b) => b.pct - a.pct),
+    tools: [...summary.tools.entries()]
+      .map(([name, row]) => ({
+        name,
+        calls: row.calls,
+        avgResultBytes: Math.round(row.bytes / row.calls),
+        carryPct: share(row.carry, toolCarryTotal),
+      }))
+      .sort((a, b) => b.carryPct - a.carryPct),
+    requestContext: CONTEXT_BUCKETS.map((limit) => {
+      const row = summary.buckets.get(limit) || { requests: 0, tokenRequests: 0 };
+      return {
+        under: Number.isFinite(limit) ? limit : null,
+        requestPct: share(row.requests, summary.requests),
+        tokenRequestPct: share(row.tokenRequests, tokenRequestTotal),
+      };
+    }),
+    shell: {
+      calls: summary.shell.calls || 0,
+      promoted: summary.shell.promoted || 0,
+      waitUnderDefault: summary.shell.shortWait || 0,
+      waitUnderDefaultPromoted: summary.shell.shortWaitPromoted || 0,
+      waitUnderDefaultTimed: summary.shell.shortWaitTimed || 0,
+      waitUnderDefaultFinishedInsideDefault: summary.shell.shortWaitInsideDefault || 0,
+      taskWaitOnlyRequests: summary.shell.taskWaitOnlyRequests || 0,
+      taskWaitOnlyPct: share(summary.shell.taskWaitOnlyRequests || 0, summary.requests),
+    },
+  };
+}
+
+const compact = (value) => {
+  if (value >= 1e6) return `${(value / 1e6).toFixed(1)}M`;
+  return value >= 1e3 ? `${(value / 1e3).toFixed(1)}k` : String(Math.round(value));
+};
+
+function table(rows) {
+  const widths = rows[0].map((_, column) => Math.max(...rows.map((row) => String(row[column]).length)));
+  return rows.map((row) =>
+    row
+      .map((cell, column) => String(cell).padEnd(widths[column]))
+      .join('  ')
+      .trimEnd()
+  );
+}
+
+function renderReport(report, sinceTs) {
+  const lines = [
+    `session efficiency: ${report.sessions} sessions, ${report.requests} requests${sinceTs ? ` since ${new Date(sinceTs).toISOString()}` : ''}`,
+    '',
+    ...table([
+      ['agent @model', 'sessions', 'requests', 'calls/req', 'single-call%', 'avgContext', 'tokenRequests'],
+      ...report.groups
+        .slice(0, 12)
+        .map((row) => [
+          row.name,
+          row.sessions,
+          row.requests,
+          row.callsPerToolRequest,
+          row.singleCallPct,
+          compact(row.avgContextTokens),
+          compact(row.tokenRequests),
+        ]),
+    ]),
+    '',
+    `carried context (size x later requests): ${report.carry.map((row) => `${row.name} ${row.pct}%`).join(', ')}`,
+    `tool results by carry: ${report.tools
+      .slice(0, 10)
+      .map((row) => `${row.name} ${row.carryPct}% (${row.calls} calls, avg ${compact(row.avgResultBytes)}B)`)
+      .join(', ')}`,
+    `request context: ${report.requestContext
+      .map(
+        (row) =>
+          `${row.under ? `<${compact(row.under)}` : 'larger'} ${row.requestPct}% of requests / ${row.tokenRequestPct}% of token-requests`
+      )
+      .join(', ')}`,
+    `shell foreground window: ${report.shell.calls} calls, ${report.shell.promoted} promoted to background; wait_ms under the ${DEFAULT_SHELL_AUTO_BACKGROUND_MS}ms default on ${report.shell.waitUnderDefault} calls (${report.shell.waitUnderDefaultPromoted} promoted, ${report.shell.waitUnderDefaultFinishedInsideDefault} of ${report.shell.waitUnderDefaultTimed} timed ones finished inside the default); task-wait-only requests: ${report.shell.taskWaitOnlyRequests} (${report.shell.taskWaitOnlyPct}%)`,
+  ];
+  return `${lines.join('\n')}\n`;
+}
+
+function main() {
+  const mixdogHome = process.env.MIXDOG_HOME || resolve(homedir(), '.mixdog');
+  const dataDir = resolve(argValue('--data-dir', process.env.MIXDOG_DATA_DIR || join(mixdogHome, 'data')));
+  const sinceTs = parseSince(argValue('--since', '5d'));
+  const agentFilter = argValue('--agent', null);
+  const sessionsDir = join(dataDir, 'sessions');
+  const summary = createSummary();
+  let names;
+  try {
+    names = readdirSync(sessionsDir).filter((name) => name.endsWith('.json'));
+  } catch {
+    process.stderr.write(`no sessions directory at ${sessionsDir}\n`);
+    return 1;
+  }
+  for (const name of names) {
+    const file = join(sessionsDir, name);
+    try {
+      if (sinceTs != null && statSync(file).mtimeMs < sinceTs) continue;
+      const session = JSON.parse(readFileSync(file, 'utf8'));
+      if (agentFilter && String(session.agent || '') !== agentFilter) continue;
+      addSession(summary, session);
+    } catch {
+      /* a session mid-write or unreadable: skip it */
+    }
+  }
+  const report = buildReport(summary);
+  process.stdout.write(hasFlag('--json') ? `${JSON.stringify(report, null, 2)}\n` : renderReport(report, sinceTs));
+  return 0;
+}
+
+if (resolve(process.argv[1] || '') === fileURLToPath(import.meta.url)) {
+  process.exitCode = main();
+}

package/src/defaults/skills/computer-use/SKILL.md

@@ -166,9 +166,9 @@ GNOME with the Window Calls extension); prefer accessibility refs there.
    `mouse_down` holds a button past the end of its command and is
    background-only; pair it with `mouse_up` on a fresh observation.
    `key_down` holds a key the same way and is foreground-only, because no window
-   message can leave a key physically down; pair it with `key_up`. Any session
-   exit releases what the session pressed, and a failed release is reported
-   rather than assumed.
+   message can leave a key physically down; pair it with `key_up`. The end of
+   the turn, like any session exit, releases what the session pressed, and a
+   failed release is reported rather than assumed.
    Execution stops at the first failure or when the target transitions
    (popup, dialog, window change) and returns one fresh observation. An act
    whose first action uses a `ref` returns accessibility only (`ax`) unless

package/src/defaults/skills/local-provider/SKILL.md

@@ -87,7 +87,8 @@ available before Local Provider is installed or enabled.
 - For startup failure, use `starting`, `lastError`, and `lastExit` diagnostics.
   Do not print authentication keys or attempt unmanaged server commands.
 - Hardware status may initially be `checking`; inspect again after detection
-  completes. All NVIDIA GPUs are checked without blocking the app. Loading
+  completes. All NVIDIA GPUs on Windows, or the Apple Silicon GPU on a Mac
+  (Metal, on unified memory), are checked without blocking the app. Loading
   chooses a compatible GPU with enough free memory for the catalog's estimate;
   that estimate is a guard, not a guarantee against driver/runtime allocation
   failure. Never bypass a failed resource check.

package/src/defaults/skills/setup/SKILL.md

@@ -65,13 +65,13 @@ that a call returned without transport error.
   provider restores Main inheritance; omission never resets it. Disabling an
   agent preserves its route for re-enabling.
 - Web Search model selection and Web Search tool exposure are separate.
-- Memory master state controls tools, core injection, and background cycles;
-  `set_recap_enabled` changes only the background cycles. Core Memory entries
+- Memory master state controls tools and background cycles; Core Memory
+  injection stays on regardless. `set_recap_enabled` changes only the
+  background cycles. Core Memory entries
   are read and changed with the `memory` tool, not setup.
 - Built-ins have installation state separate from enabled state. Browser Use,
   Computer Use, and voice actions require this conversation open in the local
-  Desktop window. `set_first_use_approval` controls first-use approval for
-  Browser Use and Computer Use only, not voice.
+  Desktop window.
 - Desktop appearance changes affect the Desktop host, not a paired phone.
   Display language is independent of profile response language. A required
   reload is reported, never performed automatically.

package/src/defaults/skills/setup/references/actions.md

@@ -27,7 +27,6 @@ Read this when choosing a `setup` mutation.
 | Background memory cycles | `set_recap_enabled` |
 | Web Search tool exposure | `set_web_search_enabled` |
 | Git, Office, Code Tidy, Local Provider, Browser, Computer, or voice enabled state | `set_builtin_enabled` |
-| One approval per session before the first Browser Use or Computer Use call (`name`: browser or computer; on by default) | `set_first_use_approval` |
 | Git, Memory, Office, Code Tidy, Local Provider, Browser, Computer, or voice preparation | `install_builtin` |
 | Managed local model installation (use the local-provider skill) | `install_local_model` |
 | Start or resume a background runtime/model download | `start_local_installation` |
@@ -150,8 +149,7 @@ the Browser Use / Computer Use installed and enabled markers are read with
 - Browser Use, Computer Use, and voice installation/toggles use the same
   `install_builtin` and `set_builtin_enabled` actions through a live Desktop
   receipt. Computer Use runs on Windows, macOS, and Linux desktops. These
-  actions do not approve OS permission dialogs or first-use tool approval on
-  the user's behalf.
+  actions do not approve OS permission dialogs on the user's behalf.
 - Environment feature overrides are diagnostics for headless or benchmark
   environments, not ordinary user settings.
 

package/src/defaults/skills/setup/references/surfaces.md

@@ -59,9 +59,8 @@ toggles, Projects, and linked-device revocation through the attached
 Desktop. A receipt identifies `scope:desktop-host`; appearance is not applied
 to the paired browser. No Desktop claimant means no confirmed change.
 
-Computer observe-only, background Memory cycles (`set_recap_enabled`), and
-Browser/Computer first-use approval have no settings control in either app;
-setup is their only supported route. Usage pin is the pin toggle on the activity rail usage card.
+Computer observe-only and background Memory cycles (`set_recap_enabled`)
+have no settings control in either app; setup is their only supported route. Usage pin is the pin toggle on the activity rail usage card.
 
 Schedules/webhooks and workflow/agent/skill definitions use their runtime
 actions directly. These do not require clicking their Desktop rails.

package/src/headless-exec.mjs

@@ -396,6 +396,7 @@ async function createHeadlessSessionRuntime(boundary, { provider, model, cwd, we
   const createRuntime = runtimeFactory || (await import('./mixdog-session-runtime.mjs')).createMixdogSessionRuntime;
   process.env.MIXDOG_FEATURE_WEB_SEARCH = webSearch === true ? '1' : '0';
   process.env.MIXDOG_FEATURE_MEMORY = '0';
+  process.env.MIXDOG_BOOT_CORE_MEMORY = '0';
   return createRuntime({
     provider,
     model,

package/src/rules/shared/70-delivery.md

@@ -5,8 +5,8 @@
   results in the conversation instead.
 - Reference files and folders in inline code by a Project-root-relative or
   absolute path, optionally `:line[:column]` (`deliverables/report.docx`,
-  `src/app.ts:42`); never a bare name, a path relative to another folder, or a
-  `file://` URI.
+  `src/app.ts:42`); files outside the Project always by absolute path; never a
+  bare name, a path relative to another folder, or a `file://` URI.
 - Deliver requested visual artifacts (SVG, diagrams, HTML pages) as saved files
   and give their path; never paste their source as the answer unless the user
   asks for the code.

package/src/runtime/agent/orchestrator/providers/anthropic-fast-mode.mjs

@@ -18,6 +18,10 @@ import { headerValue } from './retry-classification.mjs';
 // Server-declared reason header for a fast-mode rejection caused by missing
 // overage billing (matches the reference client's header name).
 const OVERAGE_DISABLED_HEADER = 'anthropic-ratelimit-unified-overage-disabled-reason';
+// Body-only form of the same rejection ("Usage credits are required for fast
+// mode."), sent as a 429 rate_limit_error without the header above.
+const CREDITS_REQUIRED_PATTERN = /usage credits are required for fast mode/i;
+const CREDITS_REQUIRED_REASON = 'usage_credits_required';
 
 // A Retry-After under this bound is short enough that waiting keeps fast mode
 // (and its cache prefix) worthwhile.
@@ -66,6 +70,12 @@ export function noteFastModeCapacityError(err, { fast = false, now = Date.now()
     _disabledReason = String(overageReason);
     return 'disabled';
   }
+  // Same terminal condition reported only in the error body: the account has
+  // no usage credits for fast mode, so no cooldown can make it succeed.
+  if (CREDITS_REQUIRED_PATTERN.test(String(err?.message || ''))) {
+    _disabledReason = CREDITS_REQUIRED_REASON;
+    return 'disabled';
+  }
 
   const retryAfterMs = Number(err?.retryAfterMs);
   const hasWindow = Number.isFinite(retryAfterMs) && retryAfterMs >= 0;

package/src/runtime/agent/orchestrator/providers/anthropic-max-tokens.mjs

@@ -48,7 +48,7 @@ function fallbackAnthropicMaxTokens(model) {
   if (MAX_TOKENS[model]) return MAX_TOKENS[model];
   const id = String(model || '').toLowerCase();
   if (id.includes('opus')) return 65536;
-  if (id.includes('fable')) return 65536;
+  if (id.includes('fable') || id.includes('mythos')) return 65536;
   const sonnetVersion = id.match(/^claude-sonnet-(\d+)/);
   if (sonnetVersion) return Number(sonnetVersion[1]) >= 5 ? 65536 : 16384;
   if (id.includes('sonnet')) return 16384;

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

@@ -17,7 +17,7 @@ const VERSION_GATE_PATTERN =
   /Claude Code\s+(\d{1,4}\.\d{1,4}\.\d{1,6})\s+does not support this model;\s*version\s+(\d{1,4}\.\d{1,4}\.\d{1,6})\s+or newer is required\b/i;
 
 // Effective version = max(floor, learned minimum, live @anthropic-ai/claude-code).
-const liveCliVersion = createNpmVersionSource('@anthropic-ai/claude-code');
+const liveCliVersion = createNpmVersionSource('@anthropic-ai/claude-code', { persistKey: 'claude-cli' });
 
 let learnedCliVersion = null;
 let learnedCliVersionLoaded = false;

package/src/runtime/agent/orchestrator/providers/anthropic-oauth-request/initial-status.mjs

@@ -51,14 +51,18 @@ export async function judgeInitialStatus(result, requestBody, { provider, cleanu
     release();
     // Initial-response failure: nothing was sampled, so the typed retry
     // rules upstream own the decision. Subscription 429s never retry
-    // in-loop, so the cooldown is what keeps the NEXT turn off the drained
-    // fast pool.
-    noteFastModeCapacityError(
-      { httpStatus: status, headers: result?.response?.headers },
+    // in-loop; a drained or unavailable fast pool says nothing about
+    // standard-speed capacity, so `speed` is dropped and the error is
+    // flagged for a single standard-speed replay by the caller.
+    const fastDecision = noteFastModeCapacityError(
+      { httpStatus: status, headers: result?.response?.headers, message: quotaText },
       { fast: requestBody?.speed === 'fast' }
     );
+    const fastDowngraded = fastDecision === 'downgrade' || fastDecision === 'disabled';
+    if (fastDowngraded) delete requestBody.speed;
     throw Object.assign(anthropicQuotaError(status, result?.response?.headers, provider.scrubTokens(quotaText)), {
       initialResponseError: true,
+      fastDowngraded,
     });
   }
   const err = new Error(`Anthropic OAuth API ${status}`);

package/src/runtime/agent/orchestrator/providers/anthropic-oauth-request.mjs

@@ -97,7 +97,16 @@ export function createAnthropicOAuthRequest({
     withRetry(
       async ({ signal: attemptSignal }) => {
         const result = await doRequestImpl(accessToken, attemptSignal, requestBody);
-        await judgeInitialStatus(result, requestBody, { provider, cleanupCancelHandler });
+        try {
+          await judgeInitialStatus(result, requestBody, { provider, cleanupCancelHandler });
+        } catch (err) {
+          // Fast-pool 429 before any byte was sampled: `speed` is already
+          // dropped, so replay once at standard speed within this attempt.
+          if (err?.fastDowngraded !== true) throw err;
+          const replay = await doRequestImpl(accessToken, attemptSignal, requestBody);
+          await judgeInitialStatus(replay, requestBody, { provider, cleanupCancelHandler });
+          return replay;
+        }
         return result;
       },
       {

package/src/runtime/agent/orchestrator/providers/anthropic-sse.mjs

@@ -77,7 +77,7 @@ const ANTHROPIC_SSE_ERROR_TYPE_STATUS = new Map([
   ['request_too_large', 413],
   ['rate_limit_error', 429],
   ['api_error', 500],
-  ['overloaded_error', 503],
+  ['overloaded_error', 529],
 ]);
 
 function _statusForAnthropicSseError(event, payload) {

package/src/runtime/agent/orchestrator/providers/antigravity-oauth-tokens.mjs

@@ -20,6 +20,8 @@ import { writeJsonAtomicSync } from '../../../shared/atomic-file.mjs';
 import { boundProviderAuthPath } from '../../../shared/provider-auth-binding.mjs';
 import { normalizeExpiresAtMs as _normalizeExpiresAt, scrubOAuthSecrets } from './lib/oauth-token-utils.mjs';
 import { ANTIGRAVITY_MODELS } from '../../../shared/llm/provider-model-identities.mjs';
+import { readLastKnownVersion, rememberLastKnownVersion } from './client-version-store.mjs';
+import { maxSemver } from './npm-cli-version.mjs';
 export { ANTIGRAVITY_MODELS } from '../../../shared/llm/provider-model-identities.mjs';
 
 // The Antigravity IDE's installed-app OAuth client, which every copy of that
@@ -62,7 +64,7 @@ export const PROJECT_ENDPOINT = CONTENT_ENDPOINT;
 
 export const DEFAULT_ANTIGRAVITY_MODEL = ANTIGRAVITY_MODELS[0].id;
 
-const ANTIGRAVITY_VERSION_FALLBACK = '2.8.0';
+const ANTIGRAVITY_VERSION_FALLBACK = '2.19.1';
 export const LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
 export const TOKEN_TIMEOUT_MS = 30_000;
 export const PROJECT_TIMEOUT_MS = 30_000;
@@ -71,21 +73,31 @@ export const TOKEN_REFRESH_SKEW_MS = 5 * 60 * 1000;
 
 // The backend gates models on the client version in the User-Agent, so the
 // version tracks the latest Antigravity release via its update manifest.
-// The pinned value is the offline fallback; the env override always wins.
+// The last discovered version is kept on disk for offline starts; the pinned
+// value is only the first-run fallback. The env override always wins.
 const VERSION_MANIFEST_URL =
   'https://antigravity-hub-auto-updater-974169037036.us-central1.run.app/manifest/latest-arm64-mac.yml';
 const VERSION_FETCH_TIMEOUT_MS = 5_000;
 const VERSION_RETRY_AFTER_MS = 10 * 60 * 1000;
+const VERSION_LAST_KNOWN_KEY = 'antigravity-hub';
 let _discoveredVersion = null;
+let _lastKnownVersion;
 let _versionFetch = null;
 let _versionFailedAt = 0;
 
 function antigravityVersion() {
   return (
-    String(process.env.MIXDOG_ANTIGRAVITY_VERSION || '').trim() || _discoveredVersion || ANTIGRAVITY_VERSION_FALLBACK
+    String(process.env.MIXDOG_ANTIGRAVITY_VERSION || '').trim() ||
+    _discoveredVersion ||
+    maxSemver(lastKnownAntigravityVersion(), ANTIGRAVITY_VERSION_FALLBACK)
   );
 }
 
+function lastKnownAntigravityVersion() {
+  if (_lastKnownVersion === undefined) _lastKnownVersion = readLastKnownVersion(VERSION_LAST_KNOWN_KEY);
+  return _lastKnownVersion;
+}
+
 /** Version from an electron-builder update manifest, or null when absent. */
 export function parseAntigravityManifestVersion(text) {
   for (const line of String(text || '').split(/\r?\n/)) {
@@ -113,6 +125,7 @@ export function ensureAntigravityVersion({ fetchFn = fetch } = {}) {
         signal: AbortSignal.timeout(VERSION_FETCH_TIMEOUT_MS),
       });
       if (res.ok) _discoveredVersion = parseAntigravityManifestVersion(await res.text());
+      if (_discoveredVersion) rememberLastKnownVersion(VERSION_LAST_KNOWN_KEY, _discoveredVersion);
     } catch {
       // The pinned fallback stays valid when discovery fails.
     } finally {
@@ -125,6 +138,8 @@ export function ensureAntigravityVersion({ fetchFn = fetch } = {}) {
 }
 
 export function _resetAntigravityVersionForTest() {
+  rememberLastKnownVersion(VERSION_LAST_KNOWN_KEY, null);
+  _lastKnownVersion = undefined;
   _discoveredVersion = null;
   _versionFetch = null;
   _versionFailedAt = 0;

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

@@ -0,0 +1,50 @@
+// Last live client version each provider saw, kept on disk under one key per
+// client. A new or offline process starts from the newest version this machine
+// has observed instead of a floor that only moves with a release. Skipped
+// entirely when MIXDOG_DISABLE_LIVE_CLI_VERSIONS=1.
+
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { updateJsonAtomicSync } from '../../../shared/atomic-file.mjs';
+import { resolvePluginData } from '../../../shared/plugin-paths.mjs';
+
+const LAST_KNOWN_FILE_NAME = 'client-versions.json';
+const LAST_KNOWN_SCHEMA_VERSION = 1;
+const LAST_KNOWN_VALUE = /^[\w.+-]{1,64}$/;
+
+const liveLookupDisabled = () => process.env.MIXDOG_DISABLE_LIVE_CLI_VERSIONS === '1';
+const lastKnownPath = () => join(resolvePluginData(), LAST_KNOWN_FILE_NAME);
+
+/** The last live version remembered under `key`, or null. */
+export function readLastKnownVersion(key) {
+  if (!key || liveLookupDisabled()) return null;
+  try {
+    const raw = JSON.parse(readFileSync(lastKnownPath(), 'utf-8'));
+    if (raw?.version !== LAST_KNOWN_SCHEMA_VERSION) return null;
+    const value = raw.entries?.[key]?.value;
+    return typeof value === 'string' && LAST_KNOWN_VALUE.test(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Remember a live version; `null` forgets it. Best-effort: never throws. */
+export function rememberLastKnownVersion(key, value) {
+  if (!key || liveLookupDisabled()) return;
+  if (value != null && !LAST_KNOWN_VALUE.test(String(value))) return;
+  try {
+    updateJsonAtomicSync(
+      lastKnownPath(),
+      (current) => {
+        const entries = current?.version === LAST_KNOWN_SCHEMA_VERSION ? { ...current.entries } : {};
+        if ((entries[key]?.value ?? null) === value) return undefined;
+        if (value == null) delete entries[key];
+        else entries[key] = { value, fetchedAt: Date.now() };
+        return { version: LAST_KNOWN_SCHEMA_VERSION, entries };
+      },
+      { lock: true }
+    );
+  } catch {
+    /* a read-only data directory must not break the lookup */
+  }
+}