mixdog 0.7.7 → 0.7.11

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

@@ -3,10 +3,16 @@ import { createHash } from 'crypto';
 import { loadConfig } from '../config.mjs';
 import { withRetry } from './retry-classifier.mjs';
 import { sendViaWebSocket } from './openai-oauth-ws.mjs';
+import {
+    consumeCompatChatCompletionStream,
+    consumeCompatResponsesStream,
+    parseCompletedToolCallArgumentsJson,
+} from './openai-compat-stream.mjs';
 import { appendBridgeTrace, traceBridgeUsage } from '../bridge-trace.mjs';
 import { resolveProviderCacheKey } from '../smart-bridge/cache-strategy.mjs';
 import {
     PROVIDER_FIRST_BYTE_TIMEOUT_MS,
+    PROVIDER_NONSTREAM_TOTAL_TIMEOUT_MS,
     PROVIDER_GENERATE_TOTAL_TIMEOUT_MS,
     createTimeoutSignal,
     resolveTimeoutMs,
@@ -23,9 +29,16 @@ export const OPENAI_COMPAT_PRESETS = {
         baseURL: 'https://api.x.ai/v1',
         defaultModel: 'grok-4.3',
     },
-    nvidia: {
-        baseURL: 'https://integrate.api.nvidia.com/v1',
-        defaultModel: 'meta/llama-3.3-70b-instruct',
+    // OpenCode Go — low-cost coding-model subscription gateway. The Go
+    // gateway exposes a unified OpenAI-compatible /chat/completions surface
+    // that transparently fronts every Go model (GLM / Kimi / DeepSeek / MiMo
+    // and the anthropic-native MiniMax / Qwen), including tool-calling and
+    // server-side prefix caching (cached_tokens), so no separate Anthropic
+    // transport is needed. Auth is a single OPENCODE_API_KEY (Bearer).
+    // listModels() pulls the live roster from {baseURL}/models.
+    'opencode-go': {
+        baseURL: 'https://opencode.ai/zen/go/v1',
+        defaultModel: 'glm-5.2',
     },
     ollama: {
         baseURL: 'http://localhost:11434/v1',
@@ -841,7 +854,7 @@ function toResponsesTools(tools) {
         parameters: t.inputSchema,
     }));
 }
-function parseToolCalls(choice) {
+function parseToolCalls(choice, label) {
     const calls = choice.message?.tool_calls;
     if (!calls?.length)
         return undefined;
@@ -850,7 +863,7 @@ function parseToolCalls(choice) {
         .map((tc) => ({
         id: tc.id,
         name: tc.function.name,
-        arguments: JSON.parse(tc.function.arguments || '{}'),
+        arguments: parseCompletedToolCallArgumentsJson(tc.function.arguments, label),
     }));
 }
 function parseJsonObject(value) {
@@ -861,14 +874,14 @@ function parseJsonObject(value) {
         return {};
     }
 }
-function parseResponsesToolCalls(response) {
+function parseResponsesToolCalls(response, label) {
     const out = [];
     for (const item of response?.output || []) {
         if (item?.type !== 'function_call') continue;
         out.push({
             id: item.call_id || item.id,
             name: item.name,
-            arguments: parseJsonObject(item.arguments),
+            arguments: parseCompletedToolCallArgumentsJson(item.arguments, label),
         });
     }
     return out.length ? out : undefined;
@@ -1025,7 +1038,7 @@ export class OpenAICompatProvider {
                 ?? process.env.MIXDOG_XAI_REASONING_EFFORT);
             if (reasoningEffort) params.reasoning_effort = reasoningEffort;
         }
-        const totalSignal = createTimeoutSignal(signal, PROVIDER_GENERATE_TOTAL_TIMEOUT_MS, `${this.name} total`);
+        const totalSignal = createTimeoutSignal(signal, PROVIDER_NONSTREAM_TOTAL_TIMEOUT_MS, `${this.name} total`);
         const cacheRouting = this.name === 'xai'
             ? xaiCacheRouting(opts, params, tools || [], useModel)
             : null;
@@ -1040,14 +1053,31 @@ export class OpenAICompatProvider {
         // their own load balancers and emit 5xx / "overloaded" under burst
         // traffic. The withRetry wrapper preserves abort behavior via
         // mergedSignal and only retries when classifyError() says transient.
-        let response;
+        params.stream = true;
+        params.stream_options = { include_usage: true };
+        let assembled;
         try {
-            response = await withRetry(
-                ({ signal: attemptSignal }) => this.client.chat.completions.create(params, { signal: attemptSignal }),
+            assembled = await withRetry(
+                async ({ signal: attemptSignal }) => {
+                    try { opts.onStageChange?.('requesting'); } catch { /* heartbeat best-effort */ }
+                    const stream = await withRetry(
+                        ({ signal: openSignal }) => this.client.chat.completions.create(params, { signal: openSignal }),
+                        {
+                            signal: attemptSignal,
+                            perAttemptTimeoutMs: PROVIDER_FIRST_BYTE_TIMEOUT_MS,
+                            perAttemptLabel: `${this.name} first byte`,
+                        },
+                    );
+                    try { opts.onStageChange?.('streaming'); } catch { /* heartbeat best-effort */ }
+                    return consumeCompatChatCompletionStream(stream, {
+                        signal: attemptSignal,
+                        label: this.name,
+                        onStreamDelta: opts.onStreamDelta,
+                        parseToolCalls,
+                    });
+                },
                 {
                     signal: totalSignal.signal,
-                    perAttemptTimeoutMs: PROVIDER_FIRST_BYTE_TIMEOUT_MS,
-                    perAttemptLabel: `${this.name} first byte`,
                     onRetry: ({ attempt, lastErr, delayMs, delayReason }) => {
                         const delayLabel = Number.isFinite(Number(delayMs)) ? `, delay ${delayMs}ms${delayReason ? ` (${delayReason})` : ''}` : '';
                         process.stderr.write(`[${this.name}] retry attempt ${attempt + 1} after ${lastErr?.message || lastErr?.code || 'transient error'}${delayLabel}\n`);
@@ -1057,8 +1087,9 @@ export class OpenAICompatProvider {
         } finally {
             totalSignal.cleanup();
         }
+        const response = assembled.response;
         const choice = response.choices[0];
-        const toolCalls = choice ? parseToolCalls(choice) : undefined;
+        const toolCalls = assembled.toolCalls;
         // Capture finish_reason early so we can refuse to return an
         // incomplete completion as final content. OpenAI-compat backends use
         // `length` (max_tokens / model context overflow) and `content_filter`
@@ -1115,11 +1146,11 @@ export class OpenAICompatProvider {
         // assistant message and echo it back next turn for providers that
         // require or benefit from that official multi-turn shape.
         const capturesReasoningContent = this.name === 'deepseek' || this.name === 'xai';
-        const reasoningContent = (capturesReasoningContent && typeof choice?.message?.reasoning_content === 'string')
-            ? choice.message.reasoning_content
+        const reasoningContent = (capturesReasoningContent && typeof assembled.reasoningContent === 'string')
+            ? assembled.reasoningContent
             : null;
         return {
-            content: choice?.message?.content || '',
+            content: assembled.content || '',
             model: response.model,
             toolCalls,
             stopReason,
@@ -1165,17 +1196,15 @@ export class OpenAICompatProvider {
         };
         if (previousResponseId) params.previous_response_id = previousResponseId;
         if (tools?.length) params.tools = toResponsesTools(tools);
-        // Non-streaming transport: there are no deltas to report, so without
-        // an explicit stage the session sits on the loop's per-iteration
-        // 'connecting' reset for the whole generation (bridge list shows a
-        // working session as stuck). Report 'requesting' for the in-flight
-        // window and fire one delta on arrival to feed the stall watchdog.
+        // SSE transport: report 'requesting' until the stream opens, then
+        // per-chunk onStreamDelta feeds the bridge stall watchdog.
         try { opts.onStageChange?.('requesting'); } catch { /* heartbeat best-effort */ }
         const reasoningEffort = normalizeXaiReasoningEffort(opts.xaiReasoningEffort
             ?? opts.effort
             ?? this.config?.reasoningEffort
             ?? process.env.MIXDOG_XAI_REASONING_EFFORT);
         if (reasoningEffort) params.reasoning = { effort: reasoningEffort };
+        params.stream = true;
         let response;
         let cacheLane = null;
         const scheduled = await withXaiResponsesCacheLane({
@@ -1189,14 +1218,29 @@ export class OpenAICompatProvider {
             signal,
         }, async (laneMeta) => {
             cacheLane = laneMeta;
-            const totalSignal = createTimeoutSignal(signal, PROVIDER_GENERATE_TOTAL_TIMEOUT_MS, 'xai responses total');
+            const totalSignal = createTimeoutSignal(signal, PROVIDER_NONSTREAM_TOTAL_TIMEOUT_MS, 'xai responses total');
             try {
                 return await withRetry(
-                    ({ signal: attemptSignal }) => this.client.responses.create(params, { signal: attemptSignal }),
+                    async ({ signal: attemptSignal }) => {
+                        const stream = await withRetry(
+                            ({ signal: openSignal }) => this.client.responses.create(params, { signal: openSignal }),
+                            {
+                                signal: attemptSignal,
+                                perAttemptTimeoutMs: PROVIDER_FIRST_BYTE_TIMEOUT_MS,
+                                perAttemptLabel: 'xai responses first byte',
+                            },
+                        );
+                        try { opts.onStageChange?.('streaming'); } catch { /* heartbeat best-effort */ }
+                        return consumeCompatResponsesStream(stream, {
+                            signal: attemptSignal,
+                            label: 'xai:responses',
+                            onStreamDelta: opts.onStreamDelta,
+                            parseResponsesToolCalls,
+                            responseOutputText,
+                        });
+                    },
                     {
                         signal: totalSignal.signal,
-                        perAttemptTimeoutMs: PROVIDER_FIRST_BYTE_TIMEOUT_MS,
-                        perAttemptLabel: 'xai responses first byte',
                         onRetry: ({ attempt, lastErr, delayMs, delayReason }) => {
                             const delayLabel = Number.isFinite(Number(delayMs)) ? `, delay ${delayMs}ms${delayReason ? ` (${delayReason})` : ''}` : '';
                             process.stderr.write(`[xai:responses] retry attempt ${attempt + 1} after ${lastErr?.message || lastErr?.code || 'transient error'}${delayLabel}\n`);
@@ -1207,10 +1251,10 @@ export class OpenAICompatProvider {
                 totalSignal.cleanup();
             }
         });
-        response = scheduled.value;
+        const streamed = scheduled.value;
+        response = streamed.response;
         cacheLane = cacheLane || scheduled.laneMeta;
-        try { opts.onStreamDelta?.(); } catch { /* heartbeat best-effort */ }
-        const toolCalls = parseResponsesToolCalls(response);
+        const toolCalls = streamed.toolCalls;
         writeXaiResponsesCacheTrace({
             model: useModel,
             opts,
@@ -1254,7 +1298,7 @@ export class OpenAICompatProvider {
             });
         }
         return {
-            content: responseOutputText(response),
+            content: streamed.content,
             model: response.model || useModel,
             toolCalls,
             providerState: {

package/src/agent/orchestrator/providers/openai-oauth-ws.mjs

@@ -43,6 +43,7 @@ import {
 } from '../stall-policy.mjs';
 
 const CODEX_WS_URL = 'wss://chatgpt.com/backend-api/codex/responses';
+const CODEX_OAUTH_ORIGINATOR = 'codex_cli_rs';
 const OPENAI_WS_URL = 'wss://api.openai.com/v1/responses';
 const XAI_WS_URL = 'wss://api.x.ai/v1/responses';
 const WS_IDLE_MS = 5 * 60_000;
@@ -202,7 +203,7 @@ function _buildHandshakeHeaders({ auth, sessionToken, turnState, cacheKey }) {
         : {
             'Authorization': `Bearer ${auth.access_token}`,
             'chatgpt-account-id': auth.account_id || '',
-            'originator': 'mixdog',
+            'originator': CODEX_OAUTH_ORIGINATOR,
             'OpenAI-Beta': 'responses_websockets=2026-02-06',
         };
     if (sessionToken) {

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

@@ -33,6 +33,7 @@ import { populateHttpStatusFromMessage } from './retry-classifier.mjs';
 import { getLlmDispatcher, preconnect } from '../../../shared/llm/http-agent.mjs';
 // --- Constants ---
 const CLIENT_ID = 'app_EMoamEEZ73f0CkXaXp7hrann';
+const CODEX_OAUTH_ORIGINATOR = 'codex_cli_rs';
 const TOKEN_URL = 'https://auth.openai.com/oauth/token';
 const CODEX_RESPONSES_URL = 'https://chatgpt.com/backend-api/codex/responses';
 // Version string baked into the models endpoint query — Codex rejects the
@@ -69,26 +70,33 @@ async function _resolveCodexClientVersion() {
     return CODEX_CLIENT_VERSION_FLOOR;
 }
 const CODEX_MODEL_CACHE_TTL_MS = 24 * 60 * 60_000;
+const CODEX_MODEL_CACHE_SCHEMA_VERSION = 2;
 const TOKEN_REFRESH_SKEW_MS = 5 * 60_000;
 
 function _codexModelCachePath() {
     return join(getPluginData(), 'openai-oauth-models.json');
 }
 
-async function _loadCodexModelCache() {
+function _loadCodexModelCacheSync() {
     const path = _codexModelCachePath();
     if (!existsSync(path)) return null;
     try {
         const raw = JSON.parse(readFileSync(path, 'utf-8'));
+        if (raw?.version !== CODEX_MODEL_CACHE_SCHEMA_VERSION) return null;
         if (!raw?.fetchedAt || !Array.isArray(raw.models)) return null;
         if (Date.now() - raw.fetchedAt > CODEX_MODEL_CACHE_TTL_MS) return null;
         return raw.models;
     } catch { return null; }
 }
 
+async function _loadCodexModelCache() {
+    return _loadCodexModelCacheSync();
+}
+
 async function _saveCodexModelCache(models) {
     try {
         writeJsonAtomicSync(_codexModelCachePath(), {
+            version: CODEX_MODEL_CACHE_SCHEMA_VERSION,
             fetchedAt: Date.now(),
             models,
         }, { lock: true, fsyncDir: true });
@@ -112,6 +120,27 @@ function _codexCatalogHas(id) {
     return _inMemoryCodexCatalog.some(m => m.id === id);
 }
 
+function _findCachedCodexModel(id) {
+    if (!id) return null;
+    if (!Array.isArray(_inMemoryCodexCatalog)) {
+        _inMemoryCodexCatalog = _loadCodexModelCacheSync();
+    }
+    if (!Array.isArray(_inMemoryCodexCatalog)) return null;
+    return _inMemoryCodexCatalog.find(m => m?.id === id) || null;
+}
+
+function _codexServiceTiers(modelInfo) {
+    return Array.isArray(modelInfo?.serviceTiers) ? modelInfo.serviceTiers : [];
+}
+
+function _codexModelSupportsServiceTier(id, serviceTier) {
+    const info = _findCachedCodexModel(id);
+    if (!info) return true;
+    const tiers = _codexServiceTiers(info);
+    if (!tiers.length) return false;
+    return tiers.some(t => t?.id === serviceTier);
+}
+
 // Codex returns dated ids (gpt-5.4-mini-2026-03-17). Strip the trailing
 // -YYYY-MM-DD to get the version alias (gpt-5.4-mini). Unknown shapes pass
 // through unchanged.
@@ -123,6 +152,18 @@ function _displayCodexModel(id) {
 function _normalizeCodexModel(m) {
     const id = m?.slug || m?.id;
     const family = _codexFamily(id);
+    const serviceTiers = Array.isArray(m?.service_tiers)
+        ? m.service_tiers
+            .map(t => ({
+                id: String(t?.id || '').trim(),
+                name: String(t?.name || '').trim(),
+                description: String(t?.description || '').trim(),
+            }))
+            .filter(t => t.id)
+        : [];
+    const additionalSpeedTiers = Array.isArray(m?.additional_speed_tiers)
+        ? m.additional_speed_tiers.map(t => String(t || '').trim()).filter(Boolean)
+        : [];
     // Codex doesn't use dated ids — everything is effectively a version alias.
     return {
         id,
@@ -130,12 +171,17 @@ function _normalizeCodexModel(m) {
         display: m?.display_name || id,
         family,
         provider: 'openai-oauth',
-        contextWindow: m?.context_window || 1000000,
+        contextWindow: m?.context_window || m?.max_context_window || 1000000,
+        maxContextWindow: m?.max_context_window || null,
         outputTokens: m?.auto_compact_token_limit || 32768,
+        autoCompactTokenLimit: m?.auto_compact_token_limit || null,
         tier: 'version',
         latest: false,
         description: m?.description || '',
         reasoningLevels: (m?.supported_reasoning_levels || []).map(r => r.effort),
+        serviceTiers,
+        defaultServiceTier: m?.default_service_tier || null,
+        additionalSpeedTiers,
     };
 }
 
@@ -482,10 +528,11 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
     if (opts.fast === true) {
         // 'priority' is the only fast-class value the Codex OAuth backend
         // accepts on the wire: 'fast' is hard-rejected ("Unsupported
-        // service_tier: fast", probed 2026-06-11), and 'priority' is accepted
-        // but downgraded to 'default' unless the account is entitled to
-        // priority processing. Keep sending it so entitled accounts benefit.
-        body.service_tier = 'priority';
+        // service_tier: fast", probed 2026-06-11). Match official Codex:
+        // only send the request value when the model catalog advertises it.
+        if (_codexModelSupportsServiceTier(model, 'priority')) {
+            body.service_tier = 'priority';
+        }
     }
     // Add tools
     if (tools?.length) {
@@ -564,7 +611,7 @@ function _buildOpenAIHttpFallbackHeaders({ auth, cacheKey }) {
         'Content-Type': 'application/json',
         Accept: 'text/event-stream',
         'OpenAI-Beta': 'responses=experimental',
-        originator: 'mixdog',
+        originator: CODEX_OAUTH_ORIGINATOR,
         'chatgpt-account-id': auth.account_id || '',
         'x-client-request-id': randomBytes(16).toString('hex'),
     };
@@ -954,6 +1001,9 @@ export class OpenAIOAuthProvider {
         // request skips the cold TLS handshake. Best-effort; never throws.
         preconnect('https://chatgpt.com');
     }
+    getCachedModelInfo(model) {
+        return _findCachedCodexModel(model);
+    }
     async ensureAuth({ forceRefresh = false, reason = 'preemptive' } = {}) {
         if (!this.tokens) this.tokens = loadTokens();
         if (!this.tokens)
@@ -1308,7 +1358,6 @@ export class OpenAIOAuthProvider {
 
 const AUTHORIZE_URL = 'https://auth.openai.com/oauth/authorize';
 const CODEX_OAUTH_SCOPE = 'openid profile email offline_access api.connectors.read api.connectors.invoke';
-const CODEX_OAUTH_ORIGINATOR = 'codex_cli_rs';
 const CALLBACK_HOST = '127.0.0.1';
 const CALLBACK_PORT = 1455;
 const CALLBACK_PATH = '/auth/callback';
@@ -1337,11 +1386,8 @@ export async function loginOAuth() {
     url.searchParams.set('state', state);
     url.searchParams.set('originator', CODEX_OAUTH_ORIGINATOR);
     process.stderr.write(`\n[openai-oauth] Open this URL to log in to ChatGPT (Codex):\n${url.toString()}\n\n`);
-    try {
-        const { exec } = await import('child_process');
-        const opener = process.platform === 'win32' ? 'start' : process.platform === 'darwin' ? 'open' : 'xdg-open';
-        exec(`${opener} "${url.toString()}"`, { windowsHide: true });
-    } catch { /* user opens manually */ }
+        const { openInBrowser } = await import('../../../shared/open-url.mjs');
+        openInBrowser(url.toString());
 
     return new Promise((resolve) => {
         const timeout = setTimeout(() => { server.close(); resolve(null); }, LOGIN_TIMEOUT_MS);

package/src/agent/orchestrator/session/manager.mjs

@@ -357,9 +357,10 @@ let nextId = Date.now();
 // without buying anything.
 const CONTEXT_WINDOWS = {
     // OpenAI GPT-5.x family
-    'gpt-5.5': 1000000,
-    'gpt-5.4-mini': 1000000,
-    'gpt-5.4-nano': 1000000,
+    'gpt-5.5': 272000,
+    'gpt-5.4': 272000,
+    'gpt-5.4-mini': 272000,
+    'gpt-5.4-nano': 272000,
     // Anthropic Claude 4.x
     'claude-opus-4-8': 1000000,
     'claude-opus-4-7': 1000000,
@@ -378,6 +379,18 @@ function guessContextWindow(model) {
         return 8192;
     return 128000;
 }
+function positiveContextWindow(value) {
+    const n = Number(value);
+    return Number.isFinite(n) && n > 0 ? Math.floor(n) : null;
+}
+function resolveSessionContextWindow(provider, model) {
+    const info = typeof provider?.getCachedModelInfo === 'function'
+        ? provider.getCachedModelInfo(model)
+        : null;
+    return positiveContextWindow(info?.contextWindow)
+        || positiveContextWindow(info?.context_window)
+        || guessContextWindow(model);
+}
 // Provider-scoped unified cache key. Goal: all orchestrator-internal
 // dispatches (bridge/maintenance/mcp/scheduler/webhook) targeting the
 // same provider land in a single server-side cache shard, so the
@@ -902,7 +915,7 @@ export function createSession(opts) {
         provider: providerName,
         model: modelName,
         messages,
-        contextWindow: guessContextWindow(modelName),
+        contextWindow: resolveSessionContextWindow(provider, modelName),
         tools,
         preset: toolPreset,
         presetName: presetObj?.name || null,
@@ -1417,6 +1430,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             runtime.session = session;
             if (!provider)
                 throw new Error(`Provider "${session.provider}" not available`);
+            session.contextWindow = resolveSessionContextWindow(provider, session.model);
             // Cap caller-supplied / prefetched context so an oversized
             // payload can't blow the session token budget before the
             // first model call. 32 KB ~ 8k tokens at the 4 B/tok

package/src/agent/orchestrator/stall-policy.mjs

@@ -70,6 +70,12 @@ export const PROVIDER_GENERATE_TOTAL_TIMEOUT_MS = resolveTimeoutMs(
     { minMs: PROVIDER_FIRST_BYTE_TIMEOUT_MS, maxMs: PROVIDER_MAX_BEFORE_WARN_MS },
 );
 
+export const PROVIDER_NONSTREAM_TOTAL_TIMEOUT_MS = resolveTimeoutMs(
+    ['MIXDOG_NONSTREAM_TOTAL_TIMEOUT_MS', 'MIXDOG_COMPAT_NONSTREAM_TOTAL_TIMEOUT_MS'],
+    480_000,
+    { minMs: PROVIDER_GENERATE_TOTAL_TIMEOUT_MS, maxMs: STALL_ABORT_MS },
+);
+
 export const PROVIDER_CACHE_CREATE_TIMEOUT_MS = resolveTimeoutMs(
     'MIXDOG_PROVIDER_CACHE_CREATE_TIMEOUT_MS',
     Math.min(120_000, PROVIDER_GENERATE_TOTAL_TIMEOUT_MS),

package/src/shared/config.mjs

@@ -299,7 +299,7 @@ export function getSearchApiKey(provider) {
 // exports keep working, then MIXDOG_AGENT_<P>_APIKEY, then the OS keychain.
 const AGENT_PROVIDER_ENV = Object.freeze({
   openai: 'OPENAI_API_KEY', anthropic: 'ANTHROPIC_API_KEY', gemini: 'GEMINI_API_KEY',
-  deepseek: 'DEEPSEEK_API_KEY', xai: 'XAI_API_KEY', nvidia: 'NVIDIA_API_KEY',
+  deepseek: 'DEEPSEEK_API_KEY', xai: 'XAI_API_KEY',
 })
 
 // Last-resort env aliases honored AFTER the standard env / MIXDOG_AGENT_* /

package/src/shared/disable-claude-builtins.mjs

@@ -11,12 +11,15 @@ import { getBackupRoot } from './user-data-guard.mjs';
 // behaviour can be restored. The createOnly gate in seed.mjs guarantees this
 // runs exactly once, so we never reapply on later boots.
 
-// Settings path is a parameter (defaulting to ~/.claude/settings.json) so it
-// can be redirected via MIXDOG_CLAUDE_SETTINGS_PATH for testing without a real
-// homedir.
+function claudeConfigBaseDir() {
+  return process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
+}
+
+// Settings path is a parameter (defaulting to <CLAUDE_CONFIG_DIR or ~/.claude>/settings.json)
+// so it can be redirected via MIXDOG_CLAUDE_SETTINGS_PATH for testing without a real homedir.
 export function resolveClaudeSettingsPath() {
   return process.env.MIXDOG_CLAUDE_SETTINGS_PATH
-    || join(homedir(), '.claude', 'settings.json');
+    || join(claudeConfigBaseDir(), 'settings.json');
 }
 
 function readJsonOrNull(filePath) {

package/src/shared/llm/cost.mjs

@@ -17,7 +17,7 @@ import { getModelMetadataSync } from '../../agent/orchestrator/providers/model-c
 // count *including* the cached portion (inclusive). Anthropic reports the
 // uncached remainder only and bills cached_read / cached_write as separate
 // additive slots (additive). Cost and prompt-total math has to branch on this.
-// OpenAI-compatible direct providers (deepseek / nvidia / ollama / lmstudio)
+// OpenAI-compatible direct providers (deepseek / ollama / lmstudio)
 // go through the OpenAI SDK and likewise report an inclusive prompt_tokens
 // with a separate cached-tokens detail — so they are inclusive too. Omitting
 // them bills the cached portion at the full input rate AND re-adds it as a
@@ -31,7 +31,7 @@ export function isInclusiveProvider(provider) {
     // usage rows — without it, cached tokens would be double-billed in the
     // cost fallback and prompt totals.
     return p.includes('openai') || p.includes('codex') || p.includes('gemini') || p.includes('google') || p.includes('xai') || p.includes('grok')
-        || p.includes('deepseek') || p.includes('nvidia') || p.includes('ollama') || p.includes('lmstudio') || p.includes('groq') || p.includes('openrouter');
+        || p.includes('deepseek') || p.includes('ollama') || p.includes('lmstudio') || p.includes('groq') || p.includes('openrouter');
 }
 
 /**

package/src/shared/open-url.mjs

@@ -0,0 +1,37 @@
+import { spawn } from 'child_process';
+
+/**
+ * Open a URL in the user's default browser. Best-effort and non-blocking —
+ * the caller always prints the URL too, so a failure here is never fatal.
+ *
+ * Platform dispatch (deterministic, not heuristic):
+ *  - Windows: `rundll32 url.dll,FileProtocolHandler <url>` passes the URL as a
+ *    single argv token, so query-string `&` separators are NOT re-parsed by a
+ *    shell. The old `start "<url>"` form is broken on Windows: cmd's `start`
+ *    treats the first quoted string as the WINDOW TITLE, so the URL is dropped
+ *    and nothing opens.
+ *  - macOS: `open <url>`.
+ *  - Linux/other: `xdg-open <url>`.
+ */
+export function openInBrowser(url) {
+  const u = String(url);
+  let cmd;
+  let args;
+  if (process.platform === 'win32') {
+    cmd = 'rundll32';
+    args = ['url.dll,FileProtocolHandler', u];
+  } else if (process.platform === 'darwin') {
+    cmd = 'open';
+    args = [u];
+  } else {
+    cmd = 'xdg-open';
+    args = [u];
+  }
+  try {
+    const child = spawn(cmd, args, { stdio: 'ignore', detached: true, windowsHide: true });
+    child.on('error', () => { /* opener missing — user uses the printed URL */ });
+    child.unref();
+  } catch {
+    /* spawn threw synchronously — user opens the printed URL manually */
+  }
+}

package/src/shared/seed.mjs

@@ -3,7 +3,7 @@ import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 import { DEFAULT_PRESETS, DEFAULT_MAINTENANCE } from '../agent/orchestrator/config.mjs';
 import { writeFileAtomicSync, withFileLockSync } from './atomic-file.mjs';
-import { backupUserData, markUserDataInitialized, shouldSeedMissingUserData } from './user-data-guard.mjs';
+import { backupUserData, hasUserDataInitMarker, markUserDataInitialized, shouldSeedMissingUserData } from './user-data-guard.mjs';
 import { disableClaudeBuiltinsOnFirstInstall } from './disable-claude-builtins.mjs';
 
 const DEFAULTS_DIR = join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'defaults');
@@ -49,12 +49,27 @@ const SEEDS = {
         };
         return JSON.stringify(composed, null, 2) + '\n';
     },
+    // Role→preset mapping consumed by Smart Bridge (loadResolvedRoles); without
+    // it on disk bridge roles fall back to the default preset. Baseline Lead
+    // workflow description ships alongside. Seeded HERE (not in setup-server)
+    // so this is the single first-install SSOT and the init marker is set once,
+    // after the whole default set lands.
+    'user-workflow.json': () => readFileSync(join(DEFAULTS_DIR, 'user-workflow.json'), 'utf8'),
+    'user-workflow.md': () => readFileSync(join(DEFAULTS_DIR, 'user-workflow.md'), 'utf8'),
 };
 
 export function ensureDataSeeds(dataDir) {
     if (!dataDir) return { created: [], skipped: [] };
     const created = [];
     const skipped = [];
+    // Capture fresh-install state ONCE, before the loop. The per-file
+    // markUserDataInitialized() below sets the marker as soon as the first seed
+    // lands; if we re-consulted the guard per file, every SUBSEQUENT first-time
+    // seed in this same pass would be refused (treated as a post-init deletion),
+    // which is exactly how user-workflow.json could end up permanently missing.
+    // On a fresh dir we seed the whole default set; once initialized, the guard
+    // governs (never recreate a file the user deleted on purpose).
+    const freshInstall = !hasUserDataInitMarker(dataDir);
     for (const [rel, bodyFn] of Object.entries(SEEDS)) {
         const full = join(dataDir, rel);
         if (existsSync(full)) {
@@ -62,7 +77,7 @@ export function ensureDataSeeds(dataDir) {
             skipped.push(rel);
             continue;
         }
-        if (!shouldSeedMissingUserData(dataDir, rel)) {
+        if (!freshInstall && !shouldSeedMissingUserData(dataDir, rel)) {
             skipped.push(rel);
             continue;
         }
@@ -112,7 +127,9 @@ export function ensureDataSeeds(dataDir) {
         }
     }
     if (created.length > 0) {
-        process.stderr.write(`[seed] created ${created.length} file(s): ${created.join(', ')}\n`);
+        if (process.env.MIXDOG_SETUP_QUIET !== '1') {
+            process.stderr.write(`[seed] created ${created.length} file(s): ${created.join(', ')}\n`);
+        }
         try { backupUserData(dataDir, 'post-seed'); } catch {}
     }
     return { created, skipped };

package/src/shared/user-data-guard.mjs

@@ -12,9 +12,13 @@ import { dirname, join, resolve } from 'path';
 import { homedir } from 'os';
 import { createHash } from 'crypto';
 
+function claudeConfigBaseDir() {
+  return process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
+}
+
 export function getBackupRoot() {
   return process.env.MIXDOG_USER_DATA_BACKUP_ROOT
-    || join(homedir(), '.claude', 'backups', 'mixdog-user-data');
+    || join(claudeConfigBaseDir(), 'backups', 'mixdog-user-data');
 }
 const RECOVERY_NOTICE = 'RECOVERY-REQUIRED.txt';
 
@@ -149,7 +153,9 @@ export function backupUserData(dataDir, reason = 'snapshot') {
   if (copied.length > 0) {
     markUserDataInitialized(dataDir);
     pruneBackups();
-    process.stderr.write(`[user-data-backup] ${reason}: copied ${copied.length} file(s) to ${backupDir}\n`);
+    if (process.env.MIXDOG_SETUP_QUIET !== '1') {
+      process.stderr.write(`[user-data-backup] ${reason}: copied ${copied.length} file(s) to ${backupDir}\n`);
+    }
   }
   return { dir: copied.length > 0 ? backupDir : null, copied };
 }