sneakoscope 8.1.2 → 8.2.0

package/dist/core/codex-app/glm-profile-installer.js

@@ -1,191 +0,0 @@
-import path from 'node:path';
-import { codexLbConfigPath, ensureGlobalCodexAppGlmProfile } from '../../cli/install-helpers.js';
-import { readText, writeJsonAtomic, nowIso, rmrf } from '../fsx.js';
-import { OPENROUTER_DEFAULT_PROFILE_ID, OPENROUTER_AUTH_COMMAND, OPENROUTER_AUTH_REFRESH_INTERVAL_MS, OPENROUTER_AUTH_TIMEOUT_MS, openRouterAuthCommandArgs, OPENROUTER_PROVIDER_ID, RETIRED_GLM_DESKTOP_CONFIG_PROFILE_IDS, buildGlmCodexAppModelProfile } from './openrouter-provider.js';
-import { openRouterSecretPaths, resolveOpenRouterApiKey } from '../providers/openrouter/openrouter-secret-store.js';
-import { escapeRegExp } from '../text/regex.js';
-export async function installCodexAppGlmProfile(input) {
-    const root = path.resolve(input.root);
-    const profile = buildGlmCodexAppModelProfile();
-    const profilePath = path.join(root, '.sneakoscope', 'codex-app', 'glm-model-profile.json');
-    const reportPath = path.join(root, '.sneakoscope', 'reports', 'codex-app-glm-profile.json');
-    const key = await resolveOpenRouterApiKey({ env: input.env || process.env });
-    const home = input.home || input.env?.HOME;
-    const configWrite = input.apply === false
-        ? null
-        : await ensureGlobalCodexAppGlmProfile({ home, configPath: input.configPath, env: input.env });
-    if (input.apply !== false) {
-        await rmrf(profilePath).catch(() => undefined);
-        await rmrf(reportPath).catch(() => undefined);
-    }
-    const configStatus = input.apply === false
-        ? await previewCodexAppGlmConfigStatus({ home, configPath: input.configPath, ...(input.env ? { env: input.env } : {}) })
-        : await inspectCodexAppOpenRouterConfig({ home, configPath: input.configPath, ...(input.env ? { env: input.env } : {}) });
-    const configWriteBlockers = configWrite?.ok === false
-        ? [`glm_codex_app_config_${configWrite.status || 'failed'}`]
-        : [];
-    const blockers = input.apply === false ? [] : [...configWriteBlockers, ...configStatus.blockers];
-    const warnings = [
-        ...key.warnings,
-        ...(key.key ? [] : ['openrouter_key_missing_until_sks_codex_app_set_openrouter_key']),
-        ...(input.apply === false ? ['codex_desktop_openrouter_config_not_written_apply_false'] : []),
-        'glm_desktop_profiles_retired_use_openrouter'
-    ];
-    const result = {
-        schema: 'sks.codex-app-glm-profile-result.v1',
-        generated_at: nowIso(),
-        ok: blockers.length === 0,
-        status: blockers.length === 0
-            ? input.apply === false
-                ? 'valid'
-                : 'removed'
-            : 'blocked',
-        profile,
-        profile_path: '.sneakoscope/codex-app/glm-model-profile.json',
-        report_path: '.sneakoscope/reports/codex-app-glm-profile.json',
-        config_path: configStatus.config_path,
-        codex_config_profile: OPENROUTER_DEFAULT_PROFILE_ID,
-        codex_reasoning_profiles: [],
-        config_write: configWrite,
-        config_status: configStatus,
-        openrouter_key_source: key.source,
-        blockers,
-        warnings
-    };
-    return result;
-}
-export async function doctorCodexAppGlmProfile(input) {
-    const root = path.resolve(input.root);
-    const profilePath = path.join(root, '.sneakoscope', 'codex-app', 'glm-model-profile.json');
-    const reportPath = path.join(root, '.sneakoscope', 'reports', 'codex-app-glm-profile.json');
-    const key = await resolveOpenRouterApiKey({ env: input.env || process.env });
-    const profile = buildGlmCodexAppModelProfile();
-    const home = input.home || input.env?.HOME;
-    const configStatus = await inspectCodexAppOpenRouterConfig({ home, configPath: input.configPath, ...(input.env ? { env: input.env } : {}) });
-    const leftoverMeta = await readText(profilePath, '').catch(() => '');
-    const blockers = [
-        ...configStatus.blockers,
-        ...(leftoverMeta.trim() ? ['retired_glm_model_profile_metadata_present'] : [])
-    ];
-    const warnings = [
-        ...key.warnings,
-        ...(key.key ? [] : ['openrouter_key_missing_until_sks_codex_app_set_openrouter_key']),
-        'glm_desktop_profiles_retired_use_openrouter'
-    ];
-    const result = {
-        schema: 'sks.codex-app-glm-profile-result.v1',
-        generated_at: nowIso(),
-        ok: blockers.length === 0,
-        status: blockers.length === 0 ? 'valid' : 'blocked',
-        profile,
-        profile_path: '.sneakoscope/codex-app/glm-model-profile.json',
-        report_path: '.sneakoscope/reports/codex-app-glm-profile.json',
-        config_path: configStatus.config_path,
-        codex_config_profile: OPENROUTER_DEFAULT_PROFILE_ID,
-        codex_reasoning_profiles: [],
-        config_write: null,
-        config_status: configStatus,
-        openrouter_key_source: key.source,
-        blockers,
-        warnings
-    };
-    await writeJsonAtomic(reportPath, result).catch(() => undefined);
-    return result;
-}
-async function previewCodexAppGlmConfigStatus(input) {
-    const configPath = input.configPath || codexLbConfigPath(input.home);
-    return {
-        schema: 'sks.codex-app-glm-config-status.v1',
-        ok: true,
-        config_path: configPath,
-        provider_present: false,
-        provider_auth_present: false,
-        profiles_present: [],
-        profiles_missing: [],
-        retired_profiles_remaining: [],
-        blockers: []
-    };
-}
-async function inspectCodexAppOpenRouterConfig(input) {
-    const configPath = input.configPath || codexLbConfigPath(input.home);
-    const text = await readText(configPath, '').catch(() => '');
-    const providerBody = tomlTableBody(text, `model_providers.${OPENROUTER_PROVIDER_ID}`);
-    const providerPresent = Boolean(providerBody);
-    const authBody = tomlTableBody(text, `model_providers.${OPENROUTER_PROVIDER_ID}.auth`);
-    const providerAuthPresent = Boolean(authBody);
-    const providerEnvKeyPresent = hasTomlKey(providerBody, 'env_key');
-    const authEnv = { ...(input.env || process.env), ...(input.home ? { HOME: input.home } : {}) };
-    const authArgs = openRouterAuthCommandArgs(openRouterSecretPaths(authEnv).keyPath);
-    const blockers = [];
-    if (!providerPresent) {
-        blockers.push('glm_codex_app_config_missing_openrouter_provider');
-    }
-    else {
-        if (!hasTomlString(providerBody, 'base_url', 'https://openrouter.ai/api/v1'))
-            blockers.push('glm_codex_app_config_invalid_openrouter_base_url');
-        if (!hasTomlString(providerBody, 'wire_api', 'responses'))
-            blockers.push('glm_codex_app_config_invalid_openrouter_wire_api');
-        if (providerEnvKeyPresent)
-            blockers.push('glm_codex_app_config_openrouter_auth_env_key_conflict');
-    }
-    if (!providerAuthPresent) {
-        blockers.push('glm_codex_app_config_missing_openrouter_auth');
-    }
-    else {
-        if (!hasTomlString(authBody, 'command', OPENROUTER_AUTH_COMMAND))
-            blockers.push('glm_codex_app_config_invalid_openrouter_auth_command');
-        if (!hasTomlStringArray(authBody, 'args', authArgs))
-            blockers.push('glm_codex_app_config_invalid_openrouter_auth_args');
-        if (!hasTomlInteger(authBody, 'timeout_ms', OPENROUTER_AUTH_TIMEOUT_MS))
-            blockers.push('glm_codex_app_config_invalid_openrouter_auth_timeout');
-        if (!hasTomlInteger(authBody, 'refresh_interval_ms', OPENROUTER_AUTH_REFRESH_INTERVAL_MS))
-            blockers.push('glm_codex_app_config_invalid_openrouter_auth_refresh');
-    }
-    const retiredRemaining = [];
-    for (const profileId of RETIRED_GLM_DESKTOP_CONFIG_PROFILE_IDS) {
-        if (tomlTableBody(text, `profiles.${profileId}`)) {
-            retiredRemaining.push(profileId);
-            blockers.push(`retired_glm_desktop_profile_present:${profileId}`);
-        }
-    }
-    return {
-        schema: 'sks.codex-app-glm-config-status.v1',
-        ok: blockers.length === 0,
-        config_path: configPath,
-        provider_present: providerPresent,
-        provider_auth_present: providerAuthPresent,
-        profiles_present: [],
-        profiles_missing: [],
-        retired_profiles_remaining: retiredRemaining,
-        blockers
-    };
-}
-function tomlTableBody(text, table) {
-    const header = `[${table}]`;
-    const lines = String(text || '').split('\n');
-    const start = lines.findIndex((line) => line.trim() === header);
-    if (start === -1)
-        return '';
-    const body = [];
-    for (let index = start + 1; index < lines.length; index += 1) {
-        const line = lines[index];
-        if (/^\s*\[[^\]]+\]\s*$/.test(line || ''))
-            break;
-        body.push(line || '');
-    }
-    return body.join('\n');
-}
-function hasTomlString(text, key, value) {
-    const pattern = new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*"${escapeRegExp(value)}"\\s*(?:#.*)?$`, 'm');
-    return pattern.test(text);
-}
-function hasTomlKey(text, key) {
-    return new RegExp(`^\\s*${escapeRegExp(key)}\\s*=`, 'm').test(text);
-}
-function hasTomlStringArray(text, key, values) {
-    const expected = values.map((value) => JSON.stringify(value)).join(', ');
-    return new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*\\[${escapeRegExp(expected)}\\]\\s*(?:#.*)?$`, 'm').test(text);
-}
-function hasTomlInteger(text, key, value) {
-    return new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*${value}\\s*(?:#.*)?$`, 'm').test(text);
-}

package/dist/core/codex-app/glm-profile-schema.js

@@ -1,42 +0,0 @@
-import { OPENROUTER_DEFAULT_PROFILE_ID, OPENROUTER_PROVIDER_ID, GLM_CODEX_SELECTABLE_REASONING_EFFORTS, GLM_CODEX_CONFIG_REASONING_PROFILES, GLM_52_OPENROUTER_MODEL, buildGlmCodexAppModelProfile } from './openrouter-provider.js';
-export function validateGlmCodexAppModelProfile(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        return { ok: false, blockers: ['glm_codex_app_profile_missing'], profile: null };
-    }
-    const profile = value;
-    const expected = buildGlmCodexAppModelProfile();
-    const blockers = [
-        profile.schema === expected.schema ? null : 'glm_codex_app_profile_invalid_schema',
-        profile.id === OPENROUTER_DEFAULT_PROFILE_ID ? null : 'glm_codex_app_profile_invalid_id',
-        profile.provider === 'openrouter' ? null : 'glm_codex_app_profile_invalid_provider',
-        profile.model === GLM_52_OPENROUTER_MODEL ? null : 'glm_codex_app_profile_invalid_model',
-        profile.codexConfigProvider === OPENROUTER_PROVIDER_ID ? null : 'glm_codex_app_profile_invalid_codex_config_provider',
-        profile.codexConfigProfile === OPENROUTER_DEFAULT_PROFILE_ID ? null : 'glm_codex_app_profile_invalid_codex_config_profile',
-        hasExpectedReasoningEfforts(profile.supportedReasoningEfforts) ? null : 'glm_codex_app_profile_invalid_reasoning_efforts',
-        hasExpectedReasoningProfiles(profile.reasoningProfiles) ? null : 'glm_codex_app_profile_invalid_reasoning_profiles',
-        profile.mode === 'openrouter-desktop' ? null : 'glm_codex_app_profile_invalid_mode',
-        profile.strictModelLock === false ? null : 'glm_codex_app_profile_unexpected_strict_lock',
-        profile.gptFallbackAllowed === false ? null : 'glm_codex_app_profile_allows_gpt_fallback',
-        profile.defaultProfile === 'speed' ? null : 'glm_codex_app_profile_default_not_speed',
-        profile.defaultSettings?.tool_choice === 'none' ? null : 'glm_codex_app_profile_default_tools_not_omitted',
-        profile.defaultSettings?.provider_require_parameters === false ? null : 'glm_codex_app_profile_default_requires_parameters',
-        profile.defaultSettings?.provider_allow_fallbacks === false ? null : 'glm_codex_app_profile_allows_provider_fallback'
-    ].filter((item) => Boolean(item));
-    return {
-        ok: blockers.length === 0,
-        blockers,
-        profile: blockers.length === 0 ? profile : null
-    };
-}
-function hasExpectedReasoningEfforts(value) {
-    if (!Array.isArray(value)) {
-        return false;
-    }
-    return GLM_CODEX_SELECTABLE_REASONING_EFFORTS.every((effort) => value.includes(effort));
-}
-function hasExpectedReasoningProfiles(value) {
-    if (!Array.isArray(value)) {
-        return false;
-    }
-    return value.length === 0 && GLM_CODEX_CONFIG_REASONING_PROFILES.length === 0;
-}

package/dist/core/codex-app/multi-provider-router.js

@@ -1,391 +0,0 @@
-import os from 'node:os';
-import { exists, nowIso, readText } from '../fsx.js';
-import { ensureTrailingNewline, normalizeCodexFastModeUiConfig, safeWriteCodexConfigToml, upsertTopLevelTomlString, upsertTomlTable } from '../codex-runtime/codex-desktop-config-policy.js';
-import { unselectCodexLbProvider } from '../../cli/install-helpers.js';
-import { restartCodexApp } from './codex-app-restart.js';
-import { codexUserConfigPath, defaultOpenCodexCatalogPath, normalizeCodexModelId, readCodexModelCatalogFile, readTopLevelTomlString } from './codex-model-catalog.js';
-import { hasTomlKey, hasTomlTablePrefix, hasUnexpectedTomlKeys, isLoopbackHostname, isSksManagedCatalogPath, probeRouterModels, resolveCatalogPath, routerBlocked, tomlBoolean, tomlString, tomlTableBody, uniqueStrings } from './multi-provider-router-support.js';
-import { classifyCodexDesktopRouting, OPENCODEX_DESIGN_B_FORCE_HINT, opencodexDesignBBlocksRouterActivation } from './codex-desktop-routing-ownership.js';
-import { desktopPickerStatusFromCache, invalidateCodexModelsCache } from './codex-models-cache.js';
-export const MULTI_PROVIDER_ROUTER_ID = 'sks-router';
-export const MULTI_PROVIDER_ROUTER_NAME = 'SKS Multi-Provider Router';
-export const MULTI_PROVIDER_ROUTER_DEFAULT_BASE_URL = 'http://127.0.0.1:10100/v1';
-const MULTI_PROVIDER_ROUTER_TIMEOUT_MS = 5_000;
-export function normalizeMultiProviderRouterBaseUrl(value) {
-    const raw = String(value || '').trim() || MULTI_PROVIDER_ROUTER_DEFAULT_BASE_URL;
-    let parsed;
-    try {
-        parsed = new URL(raw);
-    }
-    catch {
-        return { ok: false, value: null, blocker: 'multi_provider_router_base_url_invalid' };
-    }
-    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
-        return { ok: false, value: null, blocker: 'multi_provider_router_base_url_protocol_unsupported' };
-    }
-    if (parsed.username || parsed.password || parsed.search || parsed.hash) {
-        return { ok: false, value: null, blocker: 'multi_provider_router_base_url_contains_credentials_or_query' };
-    }
-    if (!isLoopbackHostname(parsed.hostname)) {
-        return { ok: false, value: null, blocker: 'multi_provider_router_requires_loopback' };
-    }
-    const normalizedPath = parsed.pathname.replace(/\/+$/, '');
-    if (!normalizedPath || normalizedPath === '')
-        parsed.pathname = '/v1';
-    else if (normalizedPath === '/')
-        parsed.pathname = '/v1';
-    else if (normalizedPath !== '/v1') {
-        return { ok: false, value: null, blocker: 'multi_provider_router_base_url_must_end_in_v1' };
-    }
-    else {
-        parsed.pathname = '/v1';
-    }
-    return { ok: true, value: parsed.toString().replace(/\/$/, ''), blocker: null };
-}
-export async function multiProviderRouterStatus(input = {}) {
-    const env = input.env || process.env;
-    const home = input.home || env.HOME || os.homedir();
-    const configPath = input.configPath || codexUserConfigPath({ home, env });
-    const config = await readText(configPath, '');
-    const providerBody = tomlTableBody(config, `model_providers.${MULTI_PROVIDER_ROUTER_ID}`);
-    const providerPresent = Boolean(providerBody);
-    const providerName = tomlString(providerBody, 'name');
-    const configuredBaseUrl = tomlString(providerBody, 'base_url');
-    const baseUrlResult = normalizeMultiProviderRouterBaseUrl(input.baseUrl || configuredBaseUrl || MULTI_PROVIDER_ROUTER_DEFAULT_BASE_URL);
-    const baseUrl = baseUrlResult.value || String(input.baseUrl || configuredBaseUrl || MULTI_PROVIDER_ROUTER_DEFAULT_BASE_URL);
-    const configuredCatalogPath = readTopLevelTomlString(config, 'model_catalog_json');
-    const catalogPath = resolveCatalogPath(input.catalogPath || configuredCatalogPath || defaultOpenCodexCatalogPath({ home, env }), { home, env, configPath });
-    const catalog = await readCodexModelCatalogFile({
-        filePath: catalogPath,
-        configured: Boolean(configuredCatalogPath)
-    });
-    const selectedProvider = readTopLevelTomlString(config, 'model_provider');
-    const selected = selectedProvider === MULTI_PROVIDER_ROUTER_ID;
-    const activeModel = selected ? readTopLevelTomlString(config, 'model') : null;
-    const activeModelPresent = Boolean(activeModel && catalog.models.some((entry) => entry.model === activeModel));
-    const providerContractOk = providerPresent
-        && providerName === MULTI_PROVIDER_ROUTER_NAME
-        && baseUrlResult.ok
-        && configuredBaseUrl === baseUrl
-        && tomlString(providerBody, 'wire_api') === 'responses'
-        && tomlBoolean(providerBody, 'requires_openai_auth') === false
-        && !hasTomlKey(providerBody, 'env_key')
-        && !hasTomlKey(providerBody, 'experimental_bearer_token')
-        && !hasTomlKey(providerBody, 'http_headers')
-        && !hasTomlKey(providerBody, 'env_http_headers')
-        && !hasUnexpectedTomlKeys(providerBody, ['name', 'base_url', 'wire_api', 'requires_openai_auth'])
-        && !hasTomlTablePrefix(config, `model_providers.${MULTI_PROVIDER_ROUTER_ID}.`);
-    const blockers = uniqueStrings([
-        ...(providerPresent ? [] : ['multi_provider_router_provider_missing']),
-        ...(providerPresent && !providerContractOk ? ['multi_provider_router_provider_contract_drift'] : []),
-        ...(baseUrlResult.blocker ? [baseUrlResult.blocker] : []),
-        ...catalog.blockers,
-        ...(selected && !activeModel ? ['multi_provider_router_active_model_missing'] : []),
-        ...(selected && activeModel && !activeModelPresent ? ['multi_provider_router_active_model_not_in_catalog'] : [])
-    ]);
-    const ready = providerContractOk && catalog.ok && (!selected || activeModelPresent);
-    const ownership = classifyCodexDesktopRouting(config, { home, env, configPath });
-    return {
-        schema: 'sks.codex-app-multi-provider-router-status.v1',
-        ok: ready,
-        status: !providerPresent
-            ? 'not_configured'
-            : ready
-                ? 'configured'
-                : 'blocked',
-        provider: MULTI_PROVIDER_ROUTER_ID,
-        provider_name: MULTI_PROVIDER_ROUTER_NAME,
-        selected_provider: selectedProvider,
-        selected,
-        provider_present: providerPresent,
-        provider_contract_ok: providerContractOk,
-        base_url: baseUrl,
-        base_url_loopback: baseUrlResult.ok,
-        catalog_path: catalogPath,
-        catalog_configured: Boolean(configuredCatalogPath),
-        catalog,
-        models: catalog.models.map((entry) => entry.model),
-        model_count: catalog.model_count,
-        models_truncated: catalog.truncated,
-        active_model: activeModel,
-        active_model_present: activeModelPresent,
-        runtime_verified: false,
-        config_path: configPath,
-        routing_ownership: ownership,
-        desktop_picker: desktopPickerStatusFromCache({
-            catalogOk: catalog.ok,
-            cache: null,
-            restartAppRequested: false
-        }),
-        blockers,
-        warnings: uniqueStrings([
-            ...catalog.warnings,
-            ...ownership.warnings,
-            ...(selected
-                && activeModel
-                && activeModelPresent
-                && catalog.models.find((entry) => entry.model === activeModel)?.multi_agent_version !== 'v2'
-                ? ['multi_provider_router_active_model_multi_agent_v2_missing']
-                : [])
-        ])
-    };
-}
-export async function testMultiProviderRouter(input) {
-    const env = input.env || process.env;
-    const home = input.home || env.HOME || os.homedir();
-    const baseUrlResult = normalizeMultiProviderRouterBaseUrl(input.baseUrl);
-    if (!baseUrlResult.ok || !baseUrlResult.value) {
-        return routerBlocked('sks.codex-app-multi-provider-router-test.v1', baseUrlResult.blocker || 'multi_provider_router_base_url_invalid');
-    }
-    const catalogPath = resolveCatalogPath(input.catalogPath || defaultOpenCodexCatalogPath({ home, env }), { home, env });
-    const catalog = await readCodexModelCatalogFile({ filePath: catalogPath, configured: true });
-    if (!catalog.ok) {
-        return {
-            ...routerBlocked('sks.codex-app-multi-provider-router-test.v1', ...catalog.blockers),
-            base_url: baseUrlResult.value,
-            catalog_path: catalogPath,
-            catalog
-        };
-    }
-    const model = input.model ? normalizeCodexModelId(input.model) : null;
-    if (input.model && !model) {
-        return routerBlocked('sks.codex-app-multi-provider-router-test.v1', 'multi_provider_router_model_invalid');
-    }
-    if (model && !catalog.models.some((entry) => entry.model === model)) {
-        return {
-            ...routerBlocked('sks.codex-app-multi-provider-router-test.v1', 'multi_provider_router_model_not_in_catalog'),
-            base_url: baseUrlResult.value,
-            catalog_path: catalogPath,
-            model
-        };
-    }
-    const probe = await probeRouterModels({
-        baseUrl: baseUrlResult.value,
-        fetchImpl: input.fetchImpl || fetch,
-        timeoutMs: input.timeoutMs || MULTI_PROVIDER_ROUTER_TIMEOUT_MS
-    });
-    const liveModelPresent = !model || probe.models.includes(model);
-    const blockers = uniqueStrings([
-        ...probe.blockers,
-        ...(liveModelPresent ? [] : ['multi_provider_router_model_not_live'])
-    ]);
-    return {
-        schema: 'sks.codex-app-multi-provider-router-test.v1',
-        generated_at: nowIso(),
-        ok: blockers.length === 0,
-        status: blockers.length === 0 ? 'connected' : 'blocked',
-        base_url: baseUrlResult.value,
-        catalog_path: catalogPath,
-        model,
-        catalog_model_count: catalog.model_count,
-        live_model_count: probe.models.length,
-        live_model_present: liveModelPresent,
-        probe,
-        blockers,
-        warnings: catalog.warnings
-    };
-}
-export async function useMultiProviderRouter(input) {
-    const env = input.env || process.env;
-    const home = input.home || env.HOME || os.homedir();
-    const configPath = input.configPath || codexUserConfigPath({ home, env });
-    const model = normalizeCodexModelId(input.model);
-    if (!model)
-        return routerBlocked('sks.codex-app-use-multi-provider-router.v1', 'multi_provider_router_model_invalid');
-    const baseUrlResult = normalizeMultiProviderRouterBaseUrl(input.baseUrl);
-    if (!baseUrlResult.ok || !baseUrlResult.value) {
-        return routerBlocked('sks.codex-app-use-multi-provider-router.v1', baseUrlResult.blocker || 'multi_provider_router_base_url_invalid');
-    }
-    const catalogPath = resolveCatalogPath(input.catalogPath || defaultOpenCodexCatalogPath({ home, env }), { home, env, configPath });
-    const catalog = await readCodexModelCatalogFile({ filePath: catalogPath, configured: true });
-    if (!catalog.ok) {
-        return {
-            ...routerBlocked('sks.codex-app-use-multi-provider-router.v1', ...catalog.blockers),
-            model,
-            base_url: baseUrlResult.value,
-            catalog_path: catalogPath,
-            catalog
-        };
-    }
-    if (!catalog.models.some((entry) => entry.model === model)) {
-        return {
-            ...routerBlocked('sks.codex-app-use-multi-provider-router.v1', 'multi_provider_router_model_not_in_catalog'),
-            model,
-            base_url: baseUrlResult.value,
-            catalog_path: catalogPath
-        };
-    }
-    const probe = await testMultiProviderRouter({
-        baseUrl: baseUrlResult.value,
-        catalogPath,
-        model,
-        home,
-        env,
-        ...(input.fetchImpl ? { fetchImpl: input.fetchImpl } : {}),
-        ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs })
-    });
-    if (!probe.ok) {
-        return {
-            schema: 'sks.codex-app-use-multi-provider-router.v1',
-            generated_at: nowIso(),
-            ok: false,
-            status: 'probe_blocked',
-            model,
-            base_url: baseUrlResult.value,
-            catalog_path: catalogPath,
-            probe,
-            blockers: probe.blockers,
-            warnings: probe.warnings || []
-        };
-    }
-    const configExistedBefore = await exists(configPath);
-    const current = await readText(configPath, '');
-    const ownership = classifyCodexDesktopRouting(current, { home, env, configPath });
-    const designBBlocker = opencodexDesignBBlocksRouterActivation(ownership, {
-        forceRoutingOverride: input.forceRoutingOverride === true
-    });
-    if (designBBlocker) {
-        return {
-            ...routerBlocked('sks.codex-app-use-multi-provider-router.v1', designBBlocker),
-            model,
-            base_url: baseUrlResult.value,
-            catalog_path: catalogPath,
-            routing_ownership: ownership,
-            hint: OPENCODEX_DESIGN_B_FORCE_HINT
-        };
-    }
-    const providerBody = tomlTableBody(current, `model_providers.${MULTI_PROVIDER_ROUTER_ID}`);
-    const existingProviderName = tomlString(providerBody, 'name');
-    if (providerBody && existingProviderName !== MULTI_PROVIDER_ROUTER_NAME) {
-        return routerBlocked('sks.codex-app-use-multi-provider-router.v1', 'multi_provider_router_provider_id_conflict');
-    }
-    const providerContractConflict = (providerBody || hasTomlTablePrefix(current, `model_providers.${MULTI_PROVIDER_ROUTER_ID}.`)) && (hasUnexpectedTomlKeys(providerBody, ['name', 'base_url', 'wire_api', 'requires_openai_auth'])
-        || hasTomlTablePrefix(current, `model_providers.${MULTI_PROVIDER_ROUTER_ID}.`));
-    if (providerContractConflict) {
-        return routerBlocked('sks.codex-app-use-multi-provider-router.v1', 'multi_provider_router_existing_provider_contract_conflict');
-    }
-    const configuredCatalogPath = readTopLevelTomlString(current, 'model_catalog_json');
-    const configuredCatalogResolved = configuredCatalogPath
-        ? resolveCatalogPath(configuredCatalogPath, { home, env, configPath })
-        : null;
-    const catalogConflict = configuredCatalogPath
-        && configuredCatalogResolved !== catalogPath
-        && !isSksManagedCatalogPath(configuredCatalogResolved, { home, env })
-        && input.replaceCatalog !== true;
-    if (catalogConflict) {
-        return {
-            ...routerBlocked('sks.codex-app-use-multi-provider-router.v1', 'multi_provider_router_user_catalog_conflict'),
-            configured_catalog_path: configuredCatalogPath,
-            requested_catalog_path: catalogPath,
-            hint: 'Re-run with --replace-catalog only if replacing the current user model catalog is intentional.'
-        };
-    }
-    const unselect = await unselectCodexLbProvider({
-        home,
-        configPath,
-        processEnv: env
-    }).catch((err) => ({ ok: false, status: 'failed', provider_error: err?.message || String(err) }));
-    if (unselect?.ok !== true) {
-        return {
-            ...routerBlocked('sks.codex-app-use-multi-provider-router.v1', unselect?.reason === 'shared_codex_lb_auth_active'
-                ? 'legacy_codex_lb_desktop_config_requires_migration'
-                : String(unselect?.status || 'codex_lb_unselect_failed')),
-            model,
-            base_url: baseUrlResult.value,
-            catalog_path: catalogPath,
-            unselect,
-            guidance: unselect?.reason === 'shared_codex_lb_auth_active'
-                ? ['Run: sks codex-lb migrate-legacy-desktop --restart-app']
-                : []
-        };
-    }
-    const currentAfterUnselect = await readText(configPath, '');
-    const providerBlock = [
-        `[model_providers.${MULTI_PROVIDER_ROUTER_ID}]`,
-        `name = ${JSON.stringify(MULTI_PROVIDER_ROUTER_NAME)}`,
-        `base_url = ${JSON.stringify(baseUrlResult.value)}`,
-        'wire_api = "responses"',
-        'requires_openai_auth = false'
-    ].join('\n');
-    let next = upsertTomlTable(currentAfterUnselect, `model_providers.${MULTI_PROVIDER_ROUTER_ID}`, providerBlock);
-    next = upsertTopLevelTomlString(next, 'model_catalog_json', catalogPath);
-    next = upsertTopLevelTomlString(next, 'model_provider', MULTI_PROVIDER_ROUTER_ID);
-    next = upsertTopLevelTomlString(next, 'model', model);
-    next = normalizeCodexFastModeUiConfig(next);
-    next = ensureTrailingNewline(next);
-    const write = await safeWriteCodexConfigToml(configPath, currentAfterUnselect, next, 'multi-provider-router-use', {
-        verifyUnchangedBeforeWrite: true,
-        expectedBeforeExists: configExistedBefore
-    });
-    if (!write.ok) {
-        return {
-            ...routerBlocked('sks.codex-app-use-multi-provider-router.v1', String(write.status || 'multi_provider_router_config_write_blocked')),
-            model,
-            base_url: baseUrlResult.value,
-            catalog_path: catalogPath,
-            write
-        };
-    }
-    const restart = await (input.restartImpl || restartCodexApp)({ enabled: Boolean(input.restartApp) });
-    const cache = await invalidateCodexModelsCache({ home, env, catalogPath });
-    const status = await multiProviderRouterStatus({ home, env, configPath });
-    const configApplied = status.selected
-        && status.provider_contract_ok
-        && status.catalog.ok
-        && status.active_model === model
-        && status.active_model_present;
-    const restartRequired = Boolean(input.restartApp);
-    const restartCompleted = !restartRequired || (restart.ok && restart.skipped !== true);
-    const operationOk = configApplied && restartCompleted;
-    const desktopPicker = desktopPickerStatusFromCache({
-        catalogOk: catalog.ok && configApplied,
-        cache,
-        restartAppRequested: Boolean(input.restartApp)
-    });
-    return {
-        schema: 'sks.codex-app-use-multi-provider-router.v1',
-        generated_at: nowIso(),
-        ok: operationOk,
-        status: !configApplied
-            ? 'configuration_incomplete'
-            : restartCompleted
-                ? restartRequired ? 'configured_restarted' : 'configured'
-                : 'configured_restart_blocked',
-        provider: MULTI_PROVIDER_ROUTER_ID,
-        model,
-        base_url: baseUrlResult.value,
-        catalog_path: catalogPath,
-        config_path: configPath,
-        probe,
-        write,
-        unselect,
-        restart_app: restart,
-        restart_ok: restart.ok && restart.skipped !== true,
-        restart_completed: restartCompleted,
-        restart_skipped: restart.skipped === true,
-        config_applied: configApplied,
-        runtime_verified: false,
-        models_cache: cache,
-        desktop_picker: desktopPicker,
-        routing_ownership: ownership,
-        router: {
-            ...status,
-            desktop_picker: desktopPicker
-        },
-        blockers: uniqueStrings([
-            ...(configApplied ? [] : ['multi_provider_router_configuration_incomplete']),
-            ...(restartCompleted ? [] : (restart.blockers || ['multi_provider_router_restart_blocked']))
-        ]),
-        warnings: uniqueStrings([
-            ...catalog.warnings,
-            ...ownership.warnings,
-            ...cache.warnings,
-            ...(catalog.models.find((entry) => entry.model === model)?.multi_agent_version === 'v2'
-                ? []
-                : ['multi_provider_router_model_multi_agent_v2_missing']),
-            ...(desktopPicker.models_cache_invalidated ? [] : ['multi_provider_router_models_cache_not_invalidated']),
-            'multi_provider_router_runtime_not_verified',
-            'desktop_picker_restart_recommended_after_catalog_change'
-        ])
-    };
-}