mixdog 0.7.17 → 0.7.18

package/scripts/lib/gateway-inventory.mjs

@@ -0,0 +1,178 @@
+// Pure gateway model-inventory + target-write helpers shared by
+// scripts/gateway-model.mjs (CLI) and src/agent/index.mjs
+// (gateway_select_model tool). Dependency-injected — the caller passes its
+// already-loaded config object and its own updateSection fn — so this module
+// has ZERO import side effects and one copy of the logic serves both callers
+// regardless of how each resolved the config module.
+
+import {
+  CLAUDE_CURRENT_CHOICE_ID,
+  CLAUDE_CURRENT_MODE,
+  formatClaudeCurrentChoiceLabel,
+  readClaudeCodeCurrentRoute,
+} from '../../src/gateway/claude-current.mjs';
+
+// Enabled providers + their candidate models, from a loaded agent config.
+// (Mirror of the previous inline buildInventory in scripts/gateway-model.mjs.)
+export function buildInventory(config) {
+  const providers = config && typeof config.providers === 'object' ? config.providers : {};
+  const presets = Array.isArray(config && config.presets) ? config.presets : [];
+
+  const byProvider = new Map();
+  const targetsByProvider = new Map();
+  for (const p of presets) {
+    if (!p || typeof p !== 'object') continue;
+    if (!p.provider || !p.model) continue;
+    if (!byProvider.has(p.provider)) byProvider.set(p.provider, new Set());
+    byProvider.get(p.provider).add(p.model);
+    if (!targetsByProvider.has(p.provider)) targetsByProvider.set(p.provider, []);
+    targetsByProvider.get(p.provider).push({
+      id: p.id ? `preset::${p.id}` : `preset-name::${p.name || `${p.provider}/${p.model}`}`,
+      provider: p.provider,
+      model: p.model,
+      presetId: p.id || null,
+      presetName: p.name || null,
+      effort: p.effort || null,
+      fast: p.fast === true,
+    });
+  }
+
+  const out = [];
+  for (const [name, cfg] of Object.entries(providers)) {
+    if (!cfg || typeof cfg !== 'object' || cfg.enabled !== true) continue;
+    const models = new Set();
+    for (const m of byProvider.get(name) || []) models.add(m);
+    if (typeof cfg.model === 'string' && cfg.model) models.add(cfg.model);
+    const targets = [...(targetsByProvider.get(name) || [])];
+    if (typeof cfg.model === 'string' && cfg.model) {
+      const exists = targets.some(t => t.model === cfg.model && !t.effort && t.fast !== true);
+      if (!exists && !targets.some(t => t.model === cfg.model)) {
+        targets.push({ id: `${name}::${cfg.model}`, provider: name, model: cfg.model, presetId: null, presetName: null, effort: null, fast: false });
+      }
+    }
+    out.push({ provider: name, models: [...models], targets });
+  }
+  out.sort((a, b) => a.provider.localeCompare(b.provider));
+  return out;
+}
+
+function targetLabel(target) {
+  const parts = [target.provider, '/', target.model];
+  const suffix = [];
+  if (target.presetName) suffix.push(target.presetName);
+  if (target.effort) suffix.push(String(target.effort).toUpperCase());
+  if (target.fast) suffix.push('fast');
+  return suffix.length ? `${parts.join(' ')} · ${suffix.join(' · ')}` : parts.join(' ');
+}
+
+// Flatten inventory to elicitation enum choices: { id, label, provider, model }.
+// id encodes provider+model ("provider::model") so the accepted value maps back
+// to a concrete target. A provider with no concrete model yields a model:null
+// choice (resolved by the caller later).
+export function claudeCurrentChoice(inventory) {
+  const hasAnthropic = (inventory || []).some(e => e?.provider === 'anthropic-oauth' || e?.provider === 'anthropic');
+  if (!hasAnthropic) return null;
+  const current = readClaudeCodeCurrentRoute();
+  return {
+    id: CLAUDE_CURRENT_CHOICE_ID,
+    label: `${formatClaudeCurrentChoiceLabel(current)} · follows Claude Code /model`,
+    provider: current.provider || 'anthropic-oauth',
+    model: current.model,
+    mode: CLAUDE_CURRENT_MODE,
+    presetId: null,
+    presetName: null,
+    effort: current.effort || null,
+    fast: current.fast === true,
+    modelDisplay: current.modelDisplay || null,
+  };
+}
+
+export function inventoryChoices(inventory, opts = {}) {
+  const choices = [];
+  if (opts.includeClaudeCurrent !== false) {
+    const current = claudeCurrentChoice(inventory);
+    if (current) choices.push(current);
+  }
+  for (const e of inventory) {
+    if (Array.isArray(e.targets) && e.targets.length > 0) {
+      for (const t of e.targets) {
+        choices.push({ ...t, label: targetLabel(t) });
+      }
+      continue;
+    }
+    if (!e.models || e.models.length === 0) {
+      choices.push({ id: e.provider, label: `${e.provider} (default model)`, provider: e.provider, model: null });
+      continue;
+    }
+    for (const m of e.models) {
+      choices.push({ id: `${e.provider}::${m}`, label: `${e.provider} / ${m}`, provider: e.provider, model: m });
+    }
+  }
+  return choices;
+}
+
+// Inverse of inventoryChoices id encoding. Splits on the FIRST "::".
+export function parseChoiceId(id) {
+  if (typeof id !== 'string' || !id) return { provider: null, model: null };
+  if (id === CLAUDE_CURRENT_CHOICE_ID) {
+    const current = readClaudeCodeCurrentRoute();
+    return {
+      provider: current.provider || 'anthropic-oauth',
+      model: current.model,
+      mode: CLAUDE_CURRENT_MODE,
+      effort: current.effort || null,
+      fast: current.fast === true,
+      modelDisplay: current.modelDisplay || null,
+    };
+  }
+  if (id.startsWith('preset::') || id.startsWith('preset-name::')) return { provider: null, model: null };
+  const i = id.indexOf('::');
+  if (i === -1) return { provider: id, model: null };
+  return { provider: id.slice(0, i), model: id.slice(i + 2) };
+}
+
+export function resolveTargetChoice(inventory, provider, model, explicitModel = false) {
+  if (provider === CLAUDE_CURRENT_CHOICE_ID || provider === CLAUDE_CURRENT_MODE) {
+    const current = readClaudeCodeCurrentRoute();
+    return {
+      id: CLAUDE_CURRENT_CHOICE_ID,
+      provider: current.provider || 'anthropic-oauth',
+      model: current.model || model || null,
+      mode: CLAUDE_CURRENT_MODE,
+      effort: current.effort || null,
+      fast: current.fast === true,
+      modelDisplay: current.modelDisplay || null,
+    };
+  }
+  const entry = (inventory || []).find(e => e.provider === provider);
+  if (!entry) return { provider, model: model || null };
+  const matches = (entry.targets || []).filter(t => t.model === model);
+  if (matches.length === 1) return matches[0];
+  if (!explicitModel && Array.isArray(entry.targets) && entry.targets.length > 0) return entry.targets[0];
+  return { provider, model: model || null };
+}
+
+// Write the gateway routing target via the injected updateSection (config RMW
+// under lock). Identical to setTarget in scripts/gateway-model.mjs so the CLI
+// --set/--enable and the elicitation tool persist through one code path.
+export function writeGatewayTarget(updateSection, provider, model, meta = {}) {
+  updateSection('gateway', (current) => {
+    const cur = current && typeof current === 'object' ? current : {};
+    const inherit = meta?.mode === CLAUDE_CURRENT_MODE || provider === CLAUDE_CURRENT_CHOICE_ID || provider === CLAUDE_CURRENT_MODE;
+    const next = inherit
+      ? { ...cur, mode: CLAUDE_CURRENT_MODE, defaultProvider: meta?.provider || 'anthropic-oauth', defaultModel: meta?.model || model || null }
+      : { ...cur, mode: 'fixed', defaultProvider: provider, defaultModel: model };
+    for (const key of ['presetId', 'presetName', 'effort', 'displayEffort', 'fast']) delete next[key];
+    if (!inherit) {
+      if (meta?.presetId) next.presetId = meta.presetId;
+      if (meta?.presetName) next.presetName = meta.presetName;
+      if (meta?.effort) next.effort = meta.effort;
+      if (meta?.fast === true) next.fast = true;
+    }
+    return next;
+  });
+  updateSection('modules', (current) => {
+    const cur = current && typeof current === 'object' ? current : {};
+    return { ...cur, gateway: { ...(cur.gateway || {}), enabled: true } };
+  });
+}

package/scripts/lib/gateway-settings.mjs

@@ -0,0 +1,78 @@
+// Shared Claude Code settings.json env writer — the SINGLE source of truth for
+// reading/mutating ~/.claude/settings.json `env.ANTHROPIC_BASE_URL`, used by
+// BOTH scripts/gateway-model.mjs (--enable / --disable) AND scripts/uninstall.mjs
+// (restoreGateway). One helper guarantees enable, disable, and uninstall never
+// diverge on path resolution or write mechanics.
+//
+// Node-only (node:fs / node:os / node:path) — no plugin deps — so uninstall.mjs
+// keeps its zero-dependency restore contract.
+//
+// Reuses the exact safe read-merge-write injectStatusLine() uses in
+// hooks/session-start.cjs:485-532: read settings.json -> JSON.parse -> mutate
+// the object -> write a .mixdog-tmp sibling -> atomic rename. Touches ONLY
+// settings.env.ANTHROPIC_BASE_URL — never any other key.
+import { readFileSync, writeFileSync, renameSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+
+// Location: CLAUDE_CONFIG_DIR || ~/.claude (the doctor.mjs claudeConfigBase
+// pattern). SSOT so enable / disable / uninstall all target the same file even
+// when CLAUDE_CONFIG_DIR is set.
+export function resolveSettingsPath() {
+  const base = process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
+  return join(base, 'settings.json');
+}
+
+// Set (string url) or remove (url === null) settings.env.ANTHROPIC_BASE_URL.
+// Returns { ok, changed?, path, error?, missing?, dryRun? }. `dryRun` previews
+// without writing. A no-op (already matching / already absent) → ok:true,
+// changed:false. Missing settings.json on remove → ok:true (treated clean);
+// on add → ok:false (cannot create the file from scratch here).
+export function setAnthropicBaseUrl(url, { dryRun = false } = {}) {
+  const p = resolveSettingsPath();
+  let raw;
+  try {
+    raw = readFileSync(p, 'utf8');
+  } catch (e) {
+    if (e && e.code === 'ENOENT') {
+      return url === null
+        ? { ok: true, changed: false, path: p, missing: true }
+        : { ok: false, error: `cannot read ${p}: ${e.message}`, path: p };
+    }
+    return { ok: false, error: `cannot read ${p}: ${e.message}`, path: p };
+  }
+  let settings;
+  try {
+    settings = JSON.parse(raw);
+  } catch (e) {
+    return { ok: false, error: `cannot parse ${p}: ${e.message}`, path: p };
+  }
+  if (typeof settings !== 'object' || settings === null || Array.isArray(settings)) {
+    return { ok: false, error: `${p} is not a JSON object`, path: p };
+  }
+  const envIsObj = settings.env && typeof settings.env === 'object' && !Array.isArray(settings.env);
+  if (url === null) {
+    // REMOVE: only our key; leave the rest of env untouched. No-op if absent.
+    if (!envIsObj || !('ANTHROPIC_BASE_URL' in settings.env)) {
+      return { ok: true, changed: false, path: p };
+    }
+    if (dryRun) return { ok: true, changed: true, path: p, dryRun: true };
+    delete settings.env.ANTHROPIC_BASE_URL;
+  } else {
+    if (!envIsObj) settings.env = {};
+    if (settings.env.ANTHROPIC_BASE_URL === url) {
+      return { ok: true, changed: false, path: p };
+    }
+    if (dryRun) return { ok: true, changed: true, path: p, dryRun: true };
+    settings.env.ANTHROPIC_BASE_URL = url;
+  }
+  try {
+    mkdirSync(dirname(p), { recursive: true });
+    const tmp = p + '.mixdog-tmp';
+    writeFileSync(tmp, JSON.stringify(settings, null, 2) + '\n', 'utf8');
+    renameSync(tmp, p);
+  } catch (e) {
+    return { ok: false, error: `cannot write ${p}: ${e.message}`, path: p };
+  }
+  return { ok: true, changed: true, path: p };
+}

package/scripts/run-mcp.mjs

@@ -463,6 +463,7 @@ let cachedInitDone       = false; // initialized notification observed from clie
 let clientInitAnswered   = false;
 let internalIdSeq        = -1;    // negative ids reserved for supervisor-internal requests
 const pendingFromClient  = new Map(); // request id (from client) → { method }
+const pendingFromChild   = new Map(); // request id (from child/server) → { method }
 const pendingInternal    = new Set(); // internal ids (init replay) — drop responses
 let stdinBuf  = '';
 let stdoutBuf = '';
@@ -740,6 +741,11 @@ function handleClientLine(line) {
       }
       if (item.id !== undefined && item.method) {
         pendingFromClient.set(item.id, { method: item.method, ts: Date.now() });
+      } else if (item.id !== undefined && pendingFromChild.has(item.id)) {
+        // Response to a server-initiated request (for example
+        // elicitation/create). Forward below, but release the tracking entry
+        // now so a later stale response with the same id is not treated live.
+        pendingFromChild.delete(item.id);
       }
     }
   }
@@ -784,11 +790,13 @@ function handleClientLine(line) {
             : '[run-mcp] Invalid Request: missing or invalid method';
           sendErrorToClient(id, code, message);
           pendingFromClient.delete(item.id);
+          pendingFromChild.delete(item.id);
         }
       }
     } else if (msg && msg.id !== undefined && msg.method) {
       sendErrorToClient(msg.id, -32603, '[run-mcp] mcp child unavailable; retry');
       pendingFromClient.delete(msg.id);
+      pendingFromChild.delete(msg.id);
     }
   }
 }
@@ -843,6 +851,12 @@ function handleChildLine(line) {
     for (const item of scanned) {
       if (item && item.id !== undefined) {
         if (pendingInternal.has(item.id)) { internalIds.add(item.id); pendingInternal.delete(item.id); _maybeResolveLivenessPong(item.id); }
+        else if (item.method) {
+          // Server-initiated request bound for the MCP client, e.g.
+          // elicitation/create. This is not a response to a client request;
+          // track it so the client's later response can flow back to child.
+          pendingFromChild.set(item.id, { method: item.method, ts: Date.now() });
+        }
         else {
           pendingFromClient.delete(item.id);
           // Same latch as the scalar path below — keep the invariant consistent
@@ -871,6 +885,15 @@ function handleChildLine(line) {
       _maybeResolveLivenessPong(scanned.id);
       return;
     }
+    if (scanned.method) {
+      // Server-initiated JSON-RPC request. MCP features such as elicitation are
+      // bidirectional: the child asks the client to show UI, then the client
+      // replies with the same id. Forward it instead of treating it as an
+      // unknown response.
+      pendingFromChild.set(scanned.id, { method: scanned.method, ts: Date.now() });
+      writeToClient(line);
+      return;
+    }
     if (!pendingFromClient.has(scanned.id)) {
       // Unknown id — neither an internal replay nor an outstanding client
       // request. Forwarding it would let a stale/rogue child line surface
@@ -932,6 +955,7 @@ function handleChildGone(why) {
     supLog(`[child-stderr-tail exitCode=${why.exitCode ?? 'n/a'} signal=${why.signal ?? 'n/a'} bytes=0] (empty)`);
   }
   const _pendingClientAtGone = pendingFromClient.size;
+  const _pendingChildAtGone = pendingFromChild.size;
   const _pendingInternalAtGone = pendingInternal.size;
   // First-boot recovery invariant: the client's initialize must receive exactly
   // one success response, from whichever child completes the handshake. If it
@@ -956,6 +980,7 @@ function handleChildGone(why) {
   if (_preserveInitId !== undefined && _preservedInit !== undefined) {
     pendingFromClient.set(_preserveInitId, _preservedInit);
   }
+  pendingFromChild.clear();
   pendingInternal.clear();
   // Fresh child = fresh response path; discard any in-flight liveness probe.
   _livenessPingId = null;
@@ -986,7 +1011,7 @@ function handleChildGone(why) {
     process.stderr.write(_crashMsg + '\n');
     supLog(_crashMsg);
   } else {
-    const _respawnMsg = `[run-mcp] ${why.log} — respawning (#${recentRestarts.length}); pendingClient=${_pendingClientAtGone} pendingInternal=${_pendingInternalAtGone} shuttingDown=${shuttingDown}`;
+    const _respawnMsg = `[run-mcp] ${why.log} — respawning (#${recentRestarts.length}); pendingClient=${_pendingClientAtGone} pendingChild=${_pendingChildAtGone} pendingInternal=${_pendingInternalAtGone} shuttingDown=${shuttingDown}`;
     process.stderr.write(_respawnMsg + '\n');
     supLog(_respawnMsg);
   }

package/scripts/statusline-launcher-smoke.mjs

@@ -9,9 +9,16 @@ import { fileURLToPath } from 'url';
 const REPO = join(fileURLToPath(import.meta.url), '..', '..');
 const LAUNCHER = join(REPO, 'bin', 'statusline-launcher.mjs');
 const LIB = join(REPO, 'bin', 'statusline-lib.mjs');
+const ROUTE = join(REPO, 'bin', 'statusline-route.mjs');
+const CLAUDE_CURRENT = join(REPO, 'src', 'gateway', 'claude-current.mjs');
 const SAMPLE = JSON.stringify({
   model: { display_name: 'Sonnet 4.5' },
   session_id: 'smoke-session',
+  context_window: { used_percentage: 1 },
+  rate_limits: {
+    five_hour: { used_percentage: 12, resets_at: Math.floor((Date.now() + 60 * 60_000) / 1000) },
+    seven_day: { used_percentage: 34 },
+  },
 });
 
 let failed = 0;
@@ -24,10 +31,18 @@ function assert(label, cond) {
 // The launcher reads ~/.claude/plugins/installed_plugins.json — point HOME at
 // a temp dir so we control the manifest without touching the real one.
 const tmp = mkdtempSync(join(tmpdir(), 'mixdog-sl-launcher-'));
-function run(homeDir) {
+function run(homeDir, extraEnv = {}) {
+  const dataDir = join(homeDir, '.claude', 'plugins', 'data', 'mixdog-trib-plugin');
   return spawnSync(process.execPath, [LAUNCHER], {
     input: SAMPLE,
-    env: { ...process.env, HOME: homeDir, USERPROFILE: homeDir, CLAUDE_CONFIG_DIR: join(homeDir, '.claude') },
+    env: {
+      ...process.env,
+      HOME: homeDir,
+      USERPROFILE: homeDir,
+      CLAUDE_CONFIG_DIR: join(homeDir, '.claude'),
+      CLAUDE_PLUGIN_DATA: dataDir,
+      ...extraEnv,
+    },
     encoding: 'utf8',
   });
 }
@@ -39,8 +54,11 @@ try {
   // path is actually exercised, not the native shim.
   const installDir = join(tmp, 'fake-install');
   mkdirSync(join(installDir, 'bin'), { recursive: true });
+  mkdirSync(join(installDir, 'src', 'gateway'), { recursive: true });
   copyFileSync(LAUNCHER, join(installDir, 'bin', 'statusline-launcher.mjs'));
   copyFileSync(LIB, join(installDir, 'bin', 'statusline-lib.mjs'));
+  copyFileSync(ROUTE, join(installDir, 'bin', 'statusline-route.mjs'));
+  copyFileSync(CLAUDE_CURRENT, join(installDir, 'src', 'gateway', 'claude-current.mjs'));
 
   const manifestDir = join(tmp, '.claude', 'plugins');
   mkdirSync(manifestDir, { recursive: true });
@@ -68,6 +86,141 @@ try {
   assert('non-empty output with lib-only install', (ok.stdout || '').trim().length > 0);
   assert('launcher output matches direct renderStatusLine (lib path exercised)',
     (ok.stdout || '') === direct);
+  assert('rate-limit fallback renders without gateway quota',
+    (ok.stdout || '').includes('5H') && (ok.stdout || '').includes('7D'));
+
+  // (1b) Gateway status overrides the displayed model/context, but when the
+  // gateway advert has no quota windows, native Claude Code OAuth rate limits
+  // from stdin must still render as the fallback.
+  const runtimeRoot = join(tmp, 'runtime');
+  mkdirSync(runtimeRoot, { recursive: true });
+  writeFileSync(join(runtimeRoot, 'active-instance.json'), JSON.stringify({
+    gateway_port: 3468,
+    gateway_server_pid: process.pid,
+    gateway_provider: 'openai-oauth',
+    gateway_model: 'gpt-5.5',
+    gateway_model_display: 'GPT-5.5',
+    gateway_context_window: 272000,
+    gateway_context_used_pct: 3,
+    gateway_updated_at: Date.now(),
+  }));
+  const gatewayFallback = run(tmp, { MIXDOG_RUNTIME_ROOT: runtimeRoot });
+  assert('gateway status keeps native OAuth rate-limit fallback',
+    (gatewayFallback.stdout || '').includes('GPT-5.5')
+    && (gatewayFallback.stdout || '').includes('5H')
+    && (gatewayFallback.stdout || '').includes('7D'));
+
+  writeFileSync(join(runtimeRoot, 'active-instance.json'), JSON.stringify({
+    gateway_port: 3468,
+    gateway_server_pid: process.pid,
+    gateway_provider: 'deepseek',
+    gateway_provider_kind: 'api',
+    gateway_model: 'deepseek-v4-pro',
+    gateway_model_display: 'DeepSeek V4 Pro',
+    gateway_context_window: 128000,
+    gateway_context_used_pct: 2,
+    gateway_route_spend: { label: 'SESS', costUsd: 0.1234, source: 'local-route' },
+    gateway_updated_at: Date.now(),
+  }));
+  const apiSpend = run(tmp, { MIXDOG_RUNTIME_ROOT: runtimeRoot, COLUMNS: '140' });
+  assert('api route shows current-section spend instead of native OAuth fallback',
+    (apiSpend.stdout || '').includes('SESS')
+    && (apiSpend.stdout || '').includes('$0.123')
+    && !(apiSpend.stdout || '').includes('5H 12%'));
+
+  writeFileSync(join(runtimeRoot, 'active-instance.json'), JSON.stringify({
+    gateway_port: 3468,
+    gateway_server_pid: process.pid,
+    gateway_provider: 'opencode-go',
+    gateway_provider_kind: 'quota-api',
+    gateway_model: 'glm-5.2',
+    gateway_model_display: 'GLM-5.2',
+    gateway_context_window: 1000000,
+    gateway_context_used_pct: 4,
+    gateway_quota_windows: [
+      { label: '5H', limitUsd: 12, usedUsd: 1.2, remainingUsd: 10.8, usedPct: 10, resetAt: Date.now() + 30 * 60_000 },
+      { label: '7D', limitUsd: 30, usedUsd: 3, remainingUsd: 27, usedPct: 10, resetAt: Date.now() + 6 * 24 * 60 * 60_000 },
+      { label: 'M', limitUsd: 60, usedUsd: 6, remainingUsd: 54, usedPct: 10, resetAt: Date.now() + 20 * 24 * 60 * 60_000 },
+    ],
+    gateway_route_spend: { label: 'SESS', costUsd: 0.4321, source: 'local-route' },
+    gateway_updated_at: Date.now(),
+  }));
+  const opencodeGoSpend = run(tmp, { MIXDOG_RUNTIME_ROOT: runtimeRoot, COLUMNS: '140' });
+  assert('opencode-go route shows quota windows plus current-section spend',
+    (opencodeGoSpend.stdout || '').includes('GLM-5.2')
+    && (opencodeGoSpend.stdout || '').includes('5H')
+    && (opencodeGoSpend.stdout || '').includes('7D')
+    && (opencodeGoSpend.stdout || '').includes('M')
+    && (opencodeGoSpend.stdout || '').includes('SESS')
+    && (opencodeGoSpend.stdout || '').includes('$0.432')
+    && (opencodeGoSpend.stdout || '').includes('↻'));
+
+  writeFileSync(join(runtimeRoot, 'active-instance.json'), JSON.stringify({
+    gateway_port: 3468,
+    gateway_server_pid: process.pid,
+    gateway_provider: 'grok-oauth',
+    gateway_provider_kind: 'oauth',
+    gateway_model: 'grok-build',
+    gateway_model_display: 'Grok Build',
+    gateway_context_window: 256000,
+    gateway_context_used_pct: 5,
+    gateway_quota_windows: [
+      { label: 'M', source: 'grok-build-billing', usedPct: 46.16, usedCredits: 69245, limitCredits: 150000, remainingCredits: 80755, resetAt: Date.now() + 20 * 24 * 60 * 60_000 },
+    ],
+    gateway_updated_at: Date.now(),
+  }));
+  const grokCredits = run(tmp, { MIXDOG_RUNTIME_ROOT: runtimeRoot, COLUMNS: '140' });
+  assert('grok oauth route shows Grok Build credit quota',
+    (grokCredits.stdout || '').includes('Grok Build')
+    && (grokCredits.stdout || '').includes('M')
+    && (grokCredits.stdout || '').includes('cr left')
+    && (grokCredits.stdout || '').includes('↻'));
+
+  // (1c) On the first statusline tick the gateway advert may not exist yet.
+  // The configured route should still win immediately so Claude Code's native
+  // model display does not flash before the gateway publishes active status.
+  const coldHome = mkdtempSync(join(tmpdir(), 'mixdog-sl-cold-'));
+  const coldData = join(coldHome, '.claude', 'plugins', 'data', 'mixdog-trib-plugin');
+  mkdirSync(coldData, { recursive: true });
+  writeFileSync(join(coldData, 'mixdog-config.json'), JSON.stringify({
+    modules: { gateway: { enabled: true } },
+    gateway: { defaultProvider: 'openai-oauth', defaultModel: 'gpt-5.5' },
+  }));
+  writeFileSync(join(coldData, 'openai-oauth-models.json'), JSON.stringify({
+    models: [{ id: 'gpt-5.5', display: 'GPT-5.5', contextWindow: 272000 }],
+  }));
+  const coldRuntime = join(coldHome, 'runtime');
+  mkdirSync(coldRuntime, { recursive: true });
+  const cold = run(tmp, { CLAUDE_PLUGIN_DATA: coldData, MIXDOG_RUNTIME_ROOT: coldRuntime });
+  assert('configured gateway route renders before active advert',
+    (cold.stdout || '').includes('GPT-5.5')
+    && !(cold.stdout || '').includes('Sonnet'));
+  try { rmSync(coldHome, { recursive: true, force: true }); } catch {}
+
+  const inheritHome = mkdtempSync(join(tmpdir(), 'mixdog-sl-inherit-'));
+  const inheritData = join(inheritHome, '.claude', 'plugins', 'data', 'mixdog-trib-plugin');
+  mkdirSync(inheritData, { recursive: true });
+  mkdirSync(join(inheritHome, '.claude', 'plugins'), { recursive: true });
+  writeFileSync(
+    join(inheritHome, '.claude', 'plugins', 'installed_plugins.json'),
+    JSON.stringify({ plugins: { 'mixdog@trib-plugin': [{ installPath: installDir }] } })
+  );
+  writeFileSync(join(inheritHome, '.claude', 'settings.json'), JSON.stringify({
+    model: 'opus[1m]',
+    effortLevel: 'high',
+    alwaysThinkingEnabled: true,
+  }));
+  writeFileSync(join(inheritData, 'mixdog-config.json'), JSON.stringify({
+    modules: { gateway: { enabled: true } },
+    gateway: { mode: 'claude-current' },
+  }));
+  const inheritRuntime = join(inheritHome, 'runtime');
+  mkdirSync(inheritRuntime, { recursive: true });
+  const inherit = run(inheritHome, { CLAUDE_PLUGIN_DATA: inheritData, MIXDOG_RUNTIME_ROOT: inheritRuntime, COLUMNS: '140' });
+  assert('claude-current route resolves opus[1m] to Opus 4.8 before active advert',
+    (inherit.stdout || '').includes('Opus 4.8')
+    && (inherit.stdout || '').includes('HIGH'));
+  try { rmSync(inheritHome, { recursive: true, force: true }); } catch {}
 
   // (2) Manifest missing → fail-soft: exit 0 + minimal `mixdog` line.
   const empty = mkdtempSync(join(tmpdir(), 'mixdog-sl-empty-'));

package/scripts/uninstall.mjs

@@ -3,10 +3,13 @@
 
 // mixdog uninstall restore helper.
 //
-// Restores the two user-owned surfaces mixdog may have modified at install
-// time — the global ~/.claude/CLAUDE.md and the autoMemoryEnabled /
-// awaySummaryEnabled keys in ~/.claude/settings.json — from the snapshot the
-// install flow captured under the backup root. It deletes NOTHING on its own;
+// Restores the user-owned surfaces mixdog may have modified — the global
+// ~/.claude/CLAUDE.md and the autoMemoryEnabled / awaySummaryEnabled keys in
+// ~/.claude/settings.json — from the snapshot the install flow captured under
+// the backup root. ALSO removes the gateway's env.ANTHROPIC_BASE_URL entry
+// from settings.json (snapshot-free, runtime addition from
+// `/mixdog:model --enable`) so uninstall never leaves Claude Code's main model
+// pointing at a dead local gateway. It deletes NOTHING else on its own;
 // data/plugin/backup removal is printed as manual steps for the user to run.
 //
 // Restore contract (produced in parallel by the install/seed flow):
@@ -24,6 +27,10 @@ import path from 'node:path';
 import os from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { createRequire } from 'node:module';
+// Shared settings.json env writer — SAME helper gateway-model.mjs --enable /
+// --disable use, so gateway cleanup here can never diverge from how the entry
+// was written. Node-only, no plugin deps (keeps the zero-dep restore contract).
+import { resolveSettingsPath, setAnthropicBaseUrl } from './lib/gateway-settings.mjs';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
@@ -67,7 +74,7 @@ function readFileOrNull(p) {
 
 // (a) Restore ~/.claude/CLAUDE.md.
 function restoreClaudeMd() {
-  log('\n[1/2] CLAUDE.md');
+  log('\n[1/3] CLAUDE.md');
   const snapshot = readFileOrNull(CLAUDE_MD_SNAPSHOT);
 
   if (snapshot !== null) {
@@ -102,7 +109,7 @@ function restoreClaudeMd() {
 
 // (b) Restore autoMemoryEnabled / awaySummaryEnabled in settings.json.
 function restoreSettings() {
-  log('\n[2/2] settings.json');
+  log('\n[2/3] settings.json');
   const snapshotRaw = readFileOrNull(SETTINGS_SNAPSHOT);
   if (snapshotRaw === null) {
     log('  nothing to restore (no settings snapshot)');
@@ -165,7 +172,36 @@ function restoreSettings() {
   log(`  updated ${SETTINGS_PATH}: ${changes.join(', ')}`);
 }
 
-// (c) Print remaining manual steps — this script deletes nothing.
+// (c) Gateway cleanup — ALWAYS remove the gateway's ANTHROPIC_BASE_URL env
+// entry from settings.json so an uninstall never leaves Claude Code pointing at
+// a dead local gateway (broken main model). Runs unconditionally — even if the
+// user never called `/mixdog:model --disable` — and is snapshot-free because
+// the key is a runtime addition (only `/mixdog:model --enable` writes it), not
+// a pre-install user value. Delegates to the SHARED setAnthropicBaseUrl(null)
+// helper — the SAME code path --enable / --disable use — so removal can never
+// diverge from how the entry was written (incl. CLAUDE_CONFIG_DIR resolution).
+function restoreGateway() {
+  log('\n[3/3] gateway (settings.json env)');
+  const res = setAnthropicBaseUrl(null, { dryRun: DRY_RUN });
+  const target = res.path || resolveSettingsPath();
+  if (!res.ok) {
+    log(`  skipped: ${res.error}`);
+    return;
+  }
+  if (!res.changed) {
+    log(res.missing
+      ? '  nothing to clean (no settings.json)'
+      : '  nothing to clean (no gateway ANTHROPIC_BASE_URL in settings.json)');
+    return;
+  }
+  if (res.dryRun) {
+    log(`  ${tag()}remove env.ANTHROPIC_BASE_URL from ${target} (gateway restore)`);
+    return;
+  }
+  log(`  removed env.ANTHROPIC_BASE_URL from ${target} — Claude Code reverts to api.anthropic.com`);
+}
+
+// (d) Print remaining manual steps — this script deletes nothing.
 function printManualSteps() {
   const dataDir = path.join(HOME, '.claude', 'plugins', 'data', 'mixdog-trib-plugin');
   log('\nManual steps (not performed by this script):');
@@ -188,6 +224,7 @@ function main() {
 
   restoreClaudeMd();
   restoreSettings();
+  restoreGateway();
   printManualSteps();
 
   log(DRY_RUN ? '\nDry run complete. Nothing was modified.' : '\nRestore complete.');