mixdog 1.2.1 → 1.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "private": false,
   "type": "module",
   "description": "Open-source coding agent that matches Codex on Terminal-Bench 2.1 with 63% fewer tokens.",

package/scripts/gate-local.mjs

@@ -2,10 +2,17 @@
 // Local pre-push check. Mirrors the test legs of .github/workflows/release-gate.yml
 // (jobs: runtime, runtime-slow, desktop, desktop-tests fast/slow). It MUST be
 // updated together with that workflow whenever those commands change.
+// Up front, before any build or leg, it runs two fast source checks and stops
+// if either fails: the gate's shipped-history job (build-shipped-history.mjs
+// --check; needs a full clone, a shallow one keeps the committed file), and the
+// released-section changelog check the desktop fast lane asserts
+// (changelog-locales.test.mjs; Deploy's plan adds the Unreleased section).
 // Not covered locally: runtime-macos, computer-backend (cargo + Linux X11),
 // desktop-tests `computer` lane (windows-latest, src/main/computer/ only),
-// relay (apps/relay tests), graph (cargo test). The gate's path filtering is
-// not applied: every leg always runs. Run `npm ci` (root and apps/desktop) first.
+// relay (apps/relay tests), graph (cargo test), patch (cargo test of the
+// checked-out engine), mobile-scripts (Python unittest). The gate's path
+// filtering is not applied: every check and leg always runs. Run `npm ci`
+// (root and apps/desktop) first.
 import { spawn, spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
@@ -16,6 +23,15 @@ import { gateTestBudget, runGateLegs } from './lib/gate-scheduler.mjs';
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const started = Date.now();
 
+const preChecks = ['node scripts/build-shipped-history.mjs --check', 'node scripts/check-changelog-locales.mjs'];
+const failedPreChecks = preChecks.filter(
+  (cmd) => spawnSync(cmd, { cwd: root, stdio: 'inherit', shell: true }).status !== 0
+);
+if (failedPreChecks.length) {
+  console.error(`[gate:local] pre-check failed: ${failedPreChecks.join('; ')}`);
+  process.exit(1);
+}
+
 const build = spawnSync('npm run build:spawn:test', { cwd: root, stdio: 'inherit', shell: true });
 if (build.status !== 0) {
   console.error('[gate:local] build:spawn:test failed');
@@ -87,7 +103,7 @@ for (const leg of legs) {
   }
 }
 console.log(
-  'Not covered locally: runtime-macos, computer-backend, desktop-tests computer lane (Windows-only), relay, graph'
+  'Not covered locally: runtime-macos, computer-backend, desktop-tests computer lane (Windows-only), relay, graph, patch, mobile-scripts'
 );
 console.log(`Total: ${((Date.now() - started) / 1000).toFixed(1)}s`);
 process.exit(legs.every((l) => l.ok) ? 0 : 1);

package/scripts/model-catalog-audit.mjs

@@ -6,7 +6,6 @@ import {
   warmModelMetadataCatalogs,
   auditModelPricing,
 } from '../src/runtime/agent/orchestrator/providers/model-catalog.mjs';
-import { QUICK_WEB_SEARCH_MODELS } from '../src/session-runtime/quick-web-search-models.mjs';
 
 const args = new Set(process.argv.slice(2));
 const json = args.has('--json');
@@ -154,21 +153,8 @@ for (const [name, provider] of getAllProviders()) {
   });
 }
 
+// Quick web-search rows carry no static windows any more (they come from the catalogs).
 const quickRows = [];
-for (const [provider, models] of Object.entries(QUICK_WEB_SEARCH_MODELS)) {
-  for (const model of models) {
-    if (model?.contextWindow == null) continue;
-    const external = externalMeta(modelsDev, litellm, provider, model.id);
-    const externalContext = external.modelsDevContext ?? external.litellmContext;
-    quickRows.push({
-      provider,
-      id: model.id,
-      staticContext: n(model.contextWindow),
-      externalContext,
-      mismatch: n(model.contextWindow) != null && externalContext != null && n(model.contextWindow) !== externalContext,
-    });
-  }
-}
 
 const mismatches = providerResults.flatMap((p) => p.rows.filter((r) => r.contextMismatch || r.outputMismatch));
 const exactOneM = providerResults.flatMap((p) => p.rows.filter((r) => r.liveContext === 1_000_000));

package/src/agents/reviewer/AGENT.md

@@ -1,12 +1,12 @@
 ---
 name: Reviewer
-description: Use once at the final check of non-trivial work: after the implementation is written and verified, before reporting completion, to independently verify correctness, regressions, risks, and acceptance criteria. Skip for low-difficulty work.
+description: Use only at the end, as the final check of non-trivial work: after the implementation is written and verified, before reporting completion, to independently verify correctness, regressions, risks, and acceptance criteria. Skip for low-difficulty work.
 ---
 
 Independent final-check review agent.
 
-You are called once, after the deliverable is written and the Lead's own
-verification has run, before completion is reported.
+You are called only at the end, after the deliverable is written and the
+Lead's own verification has run, before completion is reported.
 
 Inspect the diff, affected boundaries, existing tests, and stated acceptance
 criteria with independent judgment. Run the necessary builds, tests, lint, or

package/src/agents/reviewer/agent.json

@@ -1,6 +1,6 @@
 {
   "id": "reviewer",
   "name": "Reviewer",
-  "description": "Use once at the final check of non-trivial work: after the implementation is written and verified, before reporting completion, to independently verify correctness, regressions, risks, and acceptance criteria. Skip for low-difficulty work.",
+  "description": "Use only at the end, as the final check of non-trivial work: after the implementation is written and verified, before reporting completion, to independently verify correctness, regressions, risks, and acceptance criteria. Skip for low-difficulty work.",
   "entry": "AGENT.md"
 }

package/src/defaults/shipped-history.json

@@ -26,6 +26,7 @@
     "reviewer": [
       "07643b62440d3eba29b7360b8a33f09f",
       "25b44b46269490e26ca31c1852925171",
+      "a60ea68f9287d55489e92e5450432f62",
       "a61cb4557def4e7ed647d4bdacbb72e4",
       "de860d4111b61985f3b59eb1011fa421"
     ],

package/src/repl/slash-commands.mjs

@@ -3,6 +3,7 @@
  * to `ctx.out`; only `/exit` and `/quit` return 'exit'.
  */
 import { dim, green, red, yellow, colorEnabled } from '../runtime/shared/statusline/ansi.mjs';
+import { switchesSessionModel } from '../session-runtime/model-route/model-switch-target.mjs';
 import { createSessionStats } from '../ui/session-stats.mjs';
 import { statuslineFor } from './turn-output.mjs';
 
@@ -65,7 +66,21 @@ async function setModel(ctx, arg) {
     return;
   }
   const runtime = await ctx.ensureRuntime();
-  await runtime.setRoute({ model: arg });
+  const request = { model: arg };
+  // The user's model choice switches this conversation in place; with
+  // auto-compact on model change (default on) the history is compacted on the
+  // current model first. A failed compaction never blocks the switch.
+  if (switchesSessionModel(runtime, request) && runtime.getCompactionSettings?.()?.onModelChange !== false) {
+    // An invalid or unavailable selector is rejected before anything compacts.
+    await runtime.setRoute(request, { validateOnly: true });
+    out.write(`${dim('compacting conversation before the model change…')}\n`);
+    try {
+      await runtime.compact();
+    } catch {
+      /* next-turn auto-compaction fits the new window */
+    }
+  }
+  await runtime.setRoute(request, { switchEstablished: true });
   out.write(`${green(`✓ model → ${runtime.provider}/${runtime.model}`)}\n`);
 }
 

package/src/runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs

@@ -59,6 +59,25 @@ function assistantMessageText(content) {
     .join('\n');
 }
 
+// Visible assistant text inside a providerReplay envelope. Item shapes by
+// provider: anthropic `{type:'text',text}`; openai/xai responses
+// `{type:'message',content:[{type:'output_text',text}]}`; gemini/antigravity
+// parts `{text}` (reasoning is `{thought:true,text}`). Reasoning/thinking and
+// tool items are skipped.
+function replayItemText(item) {
+  if (!item || typeof item !== 'object') return '';
+  if (item.type === 'message') return assistantMessageText(item.content);
+  if (item.type === 'text' || item.type === 'output_text' || (item.type === undefined && item.thought !== true)) {
+    return typeof item.text === 'string' ? item.text : '';
+  }
+  return '';
+}
+
+function providerReplayText(replay) {
+  const items = Array.isArray(replay?.items) ? replay.items : [];
+  return items.map(replayItemText).filter(Boolean).join('\n');
+}
+
 /** Message index at askSession start — salvage only assistant rows appended this run. */
 export function resolveHandoffMessageStartIndex(session) {
   const messages = Array.isArray(session?.messages) ? session.messages : [];
@@ -72,7 +91,8 @@ function collectSessionAssistantHandoffText(session, messageStartIndex = 0) {
   for (let i = start; i < messages.length; i += 1) {
     const m = messages[i];
     if (m?.role !== 'assistant') continue;
-    const t = assistantMessageText(m.content).trim();
+    const contentText = assistantMessageText(m.content).trim();
+    const t = contentText || providerReplayText(m.providerReplay).trim();
     if (t && t !== '.') parts.push(t);
   }
   return parts.length ? parts.join('\n\n') : '';
@@ -80,9 +100,14 @@ function collectSessionAssistantHandoffText(session, messageStartIndex = 0) {
 
 export function watchdogPartialHandoffFromError(error, session, messageStartIndex = 0) {
   if (!isAgentProgressWatchdogAbortError(error)) return null;
-  // A canonical agent turn cannot expose its live transcript here, so it
-  // reads the text itself and carries it on the stall error.
-  if (typeof error.partialHandoff === 'string') return error.partialHandoff;
+  return turnPartialHandoff(error, session, messageStartIndex);
+}
+
+/** Assistant text a stopped turn produced before it stopped. A canonical agent
+ *  turn cannot expose its live transcript here, so it reads the text itself
+ *  and carries it on the turn's error. */
+export function turnPartialHandoff(error, session, messageStartIndex = 0) {
+  if (typeof error?.partialHandoff === 'string') return error.partialHandoff;
   return partialHandoffTextFromSession(session, messageStartIndex);
 }
 

package/src/runtime/agent/orchestrator/agent-runtime/cache-strategy.mjs

@@ -210,6 +210,16 @@ export function resolveProviderCacheKey(opts, provider) {
   );
 }
 
+/** A cache identity as a prompt_cache_key: kept as is up to the 64-char wire
+ *  limit, a bounded hash identity beyond it, '' when empty. */
+export function normalizeCacheKey(value) {
+  const text = String(value ?? '').trim();
+  if (!text) return '';
+  const wellFormed = text.toWellFormed();
+  if (wellFormed.length <= 64) return wellFormed;
+  return `pc_${createHash('sha256').update(wellFormed).digest('hex').slice(0, 32)}`;
+}
+
 function shortHash(value, chars = 18) {
   return createHash('sha256').update(stableHashStringify(value)).digest('hex').slice(0, chars);
 }

package/src/runtime/agent/orchestrator/mcp/client-config.mjs

@@ -79,20 +79,41 @@ export function mcpUrlForLog(raw) {
 
 function replaceSecret(text, value) {
   const secret = String(value || '');
-  return secret.length >= 4 ? text.split(secret).join('[redacted]') : text;
+  return secret ? text.split(secret).join('[redacted]') : text;
 }
 
-export function scrubMcpConnectionMessage(value, cfg = {}) {
-  let text = String(value || '');
+// Configured URL parts and header values shorter than 4 characters are left
+// alone: redacting e.g. the `1` of `?v=1` would mangle every message. Known
+// connection secrets (OAuth tokens) are redacted at any length.
+function replaceConfiguredSecret(text, value) {
+  return String(value || '').length >= 4 ? replaceSecret(text, value) : text;
+}
+
+/** `value` with every one of `secrets` redacted from its strings, recursing
+ *  into arrays and plain objects (tool results, JSON-RPC error data). */
+export function scrubMcpSecrets(value, secrets) {
+  if (secrets.length === 0) return value;
+  if (typeof value === 'string') return secrets.reduce(replaceSecret, value);
+  if (Array.isArray(value)) return value.map((item) => scrubMcpSecrets(item, secrets));
+  const proto = value && typeof value === 'object' ? Object.getPrototypeOf(value) : undefined;
+  if (proto !== Object.prototype && proto !== null) return value;
+  return Object.fromEntries(
+    Object.entries(value).map(([key, item]) => [scrubMcpSecrets(key, secrets), scrubMcpSecrets(item, secrets)])
+  );
+}
+
+/** `secrets` are values known only to the live connection (its OAuth tokens). */
+export function scrubMcpConnectionMessage(value, cfg = {}, secrets = []) {
+  let text = scrubMcpSecrets(String(value || ''), secrets);
   const rawUrl = expandEnvVars(String(cfg?.url || ''));
   if (rawUrl) {
     text = text.split(rawUrl).join(mcpUrlForLog(rawUrl));
     try {
       const parsed = new URL(rawUrl);
-      text = replaceSecret(text, parsed.username);
-      text = replaceSecret(text, parsed.password);
+      text = replaceConfiguredSecret(text, parsed.username);
+      text = replaceConfiguredSecret(text, parsed.password);
       for (const paramValue of parsed.searchParams.values()) {
-        text = replaceSecret(text, paramValue);
+        text = replaceConfiguredSecret(text, paramValue);
       }
     } catch {
       /* invalid URL is reported without echoing it */
@@ -101,7 +122,7 @@ export function scrubMcpConnectionMessage(value, cfg = {}) {
   const headers = resolveMcpHttpHeaders(cfg);
   for (const [name, headerValue] of Object.entries(headers)) {
     if (/authorization|cookie|token|secret|api[-_]?key|signature/i.test(name)) {
-      text = replaceSecret(text, headerValue);
+      text = replaceConfiguredSecret(text, headerValue);
     }
   }
   return text
@@ -286,6 +307,14 @@ export function resolveMcpTransportKind(cfg) {
   throw new Error(`Invalid config: need autoDetect, type (stdio/http/sse/ws), url (http), or command (stdio)`);
 }
 
+/** The exact URL OAuth credentials of an HTTP/SSE server config are stored
+ *  under; null for other transports. */
+export function resolveMcpOAuthUrl(cfg) {
+  const kind = resolveMcpTransportKind(cfg);
+  if (kind !== 'http' && kind !== 'sse') return null;
+  return normalizeMcpTransportUrl(expandEnvVars(String(cfg.url ?? '')), kind);
+}
+
 // MCP per-tool-call timeout. Default 2min: a hung/unresponsive MCP server
 // (e.g. a busy editor) must not stall a tool call indefinitely. Genuinely
 // long-running tools can raise/disable it via MIXDOG_MCP_CALL_TIMEOUT_MS or a

package/src/runtime/agent/orchestrator/mcp/client-handshake.mjs

@@ -6,6 +6,7 @@
 import { markServiceUnreachable, isConnRefuseError } from '../../../shared/service-discovery.mjs';
 import { MCP_MAX_TIMER_MS, resolveMcpStartupTimeoutMs } from './client-config.mjs';
 import { appendMcpStderrTail } from './client-transport.mjs';
+import { MCP_OAUTH_TIMEOUT_MS } from './oauth.mjs';
 
 // tools/list pagination bounds: a server that never stops handing out cursors
 // (or repeats one) cannot loop the client forever.
@@ -53,6 +54,15 @@ function startupTimeoutError(name, startupTimeoutMs) {
   return err;
 }
 
+const oauthLoginError = () => new Error('MCP OAuth login failed, cancelled, or timed out');
+
+/** Code of a connect cancelled (login cancel, disconnect, shutdown) before any
+ *  interactive login started. */
+export const MCP_CONNECT_CANCELLED = 'EMCPCONNECTCANCELLED';
+function connectCancelledError(name) {
+  return Object.assign(new Error(`MCP server "${name}" connect cancelled`), { code: MCP_CONNECT_CANCELLED });
+}
+
 /**
  * Bound the connect + listTools handshake so a slow/hung server can't stall
  * boot or the first turn. On expiry the pending transport/child is torn down
@@ -73,17 +83,43 @@ export async function runBoundedHandshake({
 }) {
   const startupTimeoutMs = resolveMcpStartupTimeoutMs(cfg);
   const guard = { timer: null, timedOut: false };
+  let rejectDeadline;
+  // True once an interactive login actually started (the server challenged
+  // and a browser sign-in was allowed).
+  let loginStarted = false;
+  const armDeadline = (ms, error = () => startupTimeoutError(name, ms)) => {
+    if (guard.timer) clearTimeout(guard.timer);
+    guard.timer = setTimeout(() => {
+      guard.timedOut = true;
+      rejectDeadline(error());
+    }, ms);
+  };
+  const deadline = new Promise((_, reject) => {
+    rejectDeadline = reject;
+  });
+  // A closed OAuth connection (login cancel, disconnect, shutdown) settles a
+  // handshake that would otherwise wait forever (an SSE stream closed while
+  // starting never settles). The SDK also closes the transport — and with it
+  // the OAuth connection — right before rethrowing a connect failure of its
+  // own (e.g. connection refused): deferring past the pending microtasks lets
+  // that real failure settle the race first.
+  const cancelOAuth = () =>
+    setImmediate(() => rejectDeadline(loginStarted ? oauthLoginError() : connectCancelledError(name)));
+  transport.oauth?.signal.addEventListener('abort', cancelOAuth, { once: true });
+  if (transport.oauth?.signal.aborted) cancelOAuth();
+  if (startupTimeoutMs > 0) armDeadline(startupTimeoutMs);
+  // Human authorization gets a separate, finite budget. The ordinary startup
+  // budget still applies until the server actually challenges authentication.
+  if (transport.oauth) {
+    transport.oauth.onStart = () => {
+      loginStarted = true;
+      armDeadline(MCP_OAUTH_TIMEOUT_MS, oauthLoginError);
+    };
+  }
   const handshake = performHandshake(client, transport, {
-    timeout: startupTimeoutMs > 0 ? startupTimeoutMs : MCP_MAX_TIMER_MS,
+    timeout: !transport.oauth && startupTimeoutMs > 0 ? startupTimeoutMs : MCP_MAX_TIMER_MS,
   });
   try {
-    if (startupTimeoutMs <= 0) return await handshake;
-    const deadline = new Promise((_, rej) => {
-      guard.timer = setTimeout(() => {
-        guard.timedOut = true;
-        rej(startupTimeoutError(name, startupTimeoutMs));
-      }, startupTimeoutMs);
-    });
     return await Promise.race([handshake, deadline]);
   } catch (err) {
     // A discovery-advert port that fails to connect is a corpse (recycled
@@ -92,7 +128,7 @@ export async function runBoundedHandshake({
     // ONLY — a startup/handshake timeout is a slow-but-alive server.
     if (autoDetectAdvert && isConnRefuseError(err))
       markServiceUnreachable(autoDetectAdvert.service, autoDetectAdvert.port);
-    if (guard.timedOut) {
+    if (guard.timedOut || transport.oauth?.signal.aborted) {
       // Tear down the pending transport/child so a hung handshake never
       // leaks a stdio process or socket — fire-and-forget (like the
       // tool-call timeout path) so a slow tree-kill never delays this
@@ -100,7 +136,7 @@ export async function runBoundedHandshake({
       try {
         closeServer({ client, transport }).catch(() => {});
       } catch {
-        /* ignore */
+        // Teardown is best effort: the handshake failure below is what gets reported.
       }
       // Never let the late handshake settle into an unhandled rejection.
       handshake.catch(() => {});
@@ -112,6 +148,9 @@ export async function runBoundedHandshake({
     }
     throw tail ? new Error(appendMcpStderrTail(String(err), tail)) : err;
   } finally {
+    transport.oauth?.finishConnect();
     if (guard.timer) clearTimeout(guard.timer);
+    transport.oauth?.signal.removeEventListener('abort', cancelOAuth);
+    if (transport.oauth) transport.oauth.onStart = () => {};
   }
 }

package/src/runtime/agent/orchestrator/mcp/client-transport.mjs

@@ -4,6 +4,7 @@
  * WebSocket, or a stdio child.
  */
 import { readServicePort } from '../../../shared/service-discovery.mjs';
+import { createMcpOAuth } from './oauth.mjs';
 import {
   AUTO_DETECT_PORTS,
   expandEnvVars,
@@ -11,6 +12,7 @@ import {
   mcpUrlForLog,
   normalizeMcpTransportUrl,
   resolveMcpHttpHeaders,
+  resolveMcpOAuthUrl,
   resolveMcpStdioEnvironment,
   resolveMcpTransportKind,
   scrubMcpConnectionMessage,
@@ -49,6 +51,19 @@ function requestInitFor(cfg) {
   return headers && Object.keys(headers).length > 0 ? { requestInit: { headers } } : undefined;
 }
 
+// Configured authentication stays authoritative even when its variables are
+// unset or resolve empty: the server then fails as configured instead of
+// turning into an OAuth login.
+export function hasConfiguredMcpAuth(cfg) {
+  const configured = (value) =>
+    value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length > 0;
+  return (
+    Boolean(String(cfg.bearer_token_env_var || '').trim()) ||
+    configured(cfg.headers) ||
+    configured(cfg.env_http_headers)
+  );
+}
+
 // The SDK's WebSocket transport opens its socket without a way to set request
 // headers. This subclass changes only socket creation: Node's WebSocket takes
 // `{ protocols, headers }`; the guard and event wiring match the stock start().
@@ -88,7 +103,7 @@ function createHeaderWebSocketTransport(Base, messageSchema, url, headers) {
  *  transports. `strictEnv` (the caller passes it for plugin-declared servers)
  *  makes unset variables without a default fail the server; otherwise they
  *  expand to empty and are reported in `warnings` (names only). */
-export function createMcpTransport({ name, cfg, sdk, log, strictEnv }) {
+export function createMcpTransport({ name, cfg, sdk, log, strictEnv, oauthOptions }) {
   const { StdioClientTransport, StreamableHTTPClientTransport, SSEClientTransport, WebSocketClientTransport } = sdk;
   const kind = resolveMcpTransportKind(cfg);
   const warnings = [];
@@ -113,11 +128,33 @@ export function createMcpTransport({ name, cfg, sdk, log, strictEnv }) {
   }
   if (kind === 'http' || kind === 'sse') {
     const Transport = kind === 'http' ? StreamableHTTPClientTransport : SSEClientTransport;
-    const url = normalizeMcpTransportUrl(expandEnvVars(String(cfg.url ?? '')), kind);
+    const url = resolveMcpOAuthUrl(cfg);
     const opts = requestInitFor(cfg);
+    // Explicit authentication remains authoritative (including custom API-key
+    // headers). Never forward those credentials to OAuth discovery endpoints.
+    let transport;
+    const oauth = hasConfiguredMcpAuth(cfg)
+      ? null
+      : createMcpOAuth({
+          url,
+          serverName: name,
+          ...oauthOptions,
+          // SSE advertises its POST endpoint on the authenticated event stream.
+          // No other path on the origin is allowed to receive this server's token.
+          isTransportEndpoint: (input) => kind === 'sse' && transport?._endpoint?.href === new URL(input).href,
+        });
+    transport = new Transport(new URL(url), oauth ? { fetch: oauth.fetch } : opts);
+    if (oauth) {
+      transport.oauth = oauth;
+      const close = transport.close.bind(transport);
+      transport.close = async () => {
+        oauth.close();
+        await close();
+      };
+    }
     log(`[mcp-client] Connecting "${name}" via ${kind.toUpperCase()}: ${mcpUrlForLog(url)}\n`);
     return {
-      transport: opts ? new Transport(new URL(url), opts) : new Transport(new URL(url)),
+      transport,
       autoDetectAdvert: null,
       stderrTail: noStderrTail,
       warnings,