sneakoscope 8.1.2 → 8.2.0

package/dist/core/codex-app/openrouter-activate.js

@@ -1,405 +0,0 @@
-import path from 'node:path';
-import os from 'node:os';
-import { ensureDir, exists, readText, nowIso } from '../fsx.js';
-import { openRouterSecretPaths, resolveOpenRouterApiKey } from '../providers/openrouter/openrouter-secret-store.js';
-import { OPENROUTER_AUTH_COMMAND, OPENROUTER_AUTH_REFRESH_INTERVAL_MS, OPENROUTER_AUTH_TIMEOUT_MS, openRouterAuthCommandArgs, OPENROUTER_PROVIDER_ID, normalizeOpenRouterModelId } from './openrouter-provider.js';
-import { installCodexAppGlmProfile } from './glm-profile-installer.js';
-import { restartCodexApp } from './codex-app-restart.js';
-import { codexLbConfigPath, ensureGlobalCodexAppGlmProfile, unselectCodexLbProvider } from '../../cli/install-helpers.js';
-import { ensureTrailingNewline, normalizeCodexFastModeUiConfig, safeWriteCodexConfigToml, upsertTopLevelTomlString } from '../codex-runtime/codex-desktop-config-policy.js';
-import { readTopLevelTomlString, sksOpenRouterCatalogPath } from './codex-model-catalog.js';
-import { resolveCatalogPath } from './multi-provider-router-support.js';
-import { openRouterCatalogBindDecision, writeOpenRouterManagedCatalog } from './openrouter-model-catalog.js';
-import { classifyCodexDesktopRouting } from './codex-desktop-routing-ownership.js';
-import { desktopPickerStatusFromCache, invalidateCodexModelsCache } from './codex-models-cache.js';
-import { assessThreadVisibilityImpact, captureDesktopRoutingSnapshot, desktopRoutingSnapshotPath, readDesktopRoutingSnapshot, remapThreadCatalogProvider, restoreDesktopRoutingSnapshot, writeDesktopRoutingSnapshot } from './desktop-routing-snapshot.js';
-import { escapeRegExp } from '../text/regex.js';
-export async function openRouterStatus(input = {}) {
-    const home = input.home || process.env.HOME || os.homedir();
-    const configPath = input.configPath || codexLbConfigPath(home);
-    const config = await readText(configPath, '');
-    const env = { ...(input.env || process.env), HOME: home };
-    const key = await resolveOpenRouterApiKey({ env });
-    const authArgs = openRouterAuthCommandArgs(openRouterSecretPaths(env).keyPath);
-    const providerPresent = new RegExp(`\\[model_providers\\.${OPENROUTER_PROVIDER_ID}\\]`).test(config);
-    const providerBody = tomlTableBody(config, `model_providers.${OPENROUTER_PROVIDER_ID}`);
-    const providerEnvKeyPresent = hasTomlKey(providerBody, 'env_key');
-    const authBody = tomlTableBody(config, `model_providers.${OPENROUTER_PROVIDER_ID}.auth`);
-    const providerAuthPresent = Boolean(authBody);
-    const providerAuthConflict = providerEnvKeyPresent && providerAuthPresent;
-    const providerAuthValid = providerAuthPresent
-        && !providerAuthConflict
-        && hasTomlString(authBody, 'command', OPENROUTER_AUTH_COMMAND)
-        && hasTomlStringArray(authBody, 'args', authArgs)
-        && hasTomlInteger(authBody, 'timeout_ms', OPENROUTER_AUTH_TIMEOUT_MS)
-        && hasTomlInteger(authBody, 'refresh_interval_ms', OPENROUTER_AUTH_REFRESH_INTERVAL_MS);
-    const selected = readTopLevelTomlString(config, 'model_provider') === OPENROUTER_PROVIDER_ID;
-    const model = readTopLevelTomlString(config, 'model');
-    const managedCatalogPath = sksOpenRouterCatalogPath({ home, env });
-    const configuredCatalogPath = readTopLevelTomlString(config, 'model_catalog_json');
-    const modelCatalogBound = Boolean(configuredCatalogPath
-        && resolveCatalogPath(configuredCatalogPath, { home, env, configPath }) === path.resolve(managedCatalogPath));
-    const blockers = [];
-    if (!key.key)
-        blockers.push('openrouter_key_missing');
-    if (!providerPresent)
-        blockers.push('openrouter_provider_missing');
-    if (providerAuthConflict)
-        blockers.push('openrouter_provider_auth_env_key_conflict');
-    else if (!providerAuthPresent)
-        blockers.push('openrouter_provider_auth_missing');
-    else if (!providerAuthValid)
-        blockers.push('openrouter_provider_auth_invalid');
-    if (selected && !model)
-        blockers.push('openrouter_model_missing');
-    const ownership = classifyCodexDesktopRouting(config, { home, env, configPath });
-    const currentProvider = readTopLevelTomlString(config, 'model_provider');
-    const threadVisibility = assessThreadVisibilityImpact({
-        home,
-        env,
-        currentProvider,
-        targetProvider: selected ? OPENROUTER_PROVIDER_ID : (currentProvider || 'openai')
-    });
-    const previousSnapshot = await readDesktopRoutingSnapshot({ home, env });
-    const previousRoutingRestoreAvailable = Boolean(previousSnapshot && previousSnapshot.model_provider !== OPENROUTER_PROVIDER_ID);
-    const warnings = [
-        ...(selected && !modelCatalogBound ? ['openrouter_model_catalog_not_bound'] : []),
-        ...ownership.warnings,
-        ...(selected && threadVisibility.hidden_if_switched > 0
-            ? ['desktop_other_provider_threads_hidden_until_restore']
-            : []),
-        ...(previousRoutingRestoreAvailable ? ['desktop_routing_snapshot_restore_available'] : [])
-    ];
-    return {
-        schema: 'sks.codex-app-openrouter-status.v1',
-        ok: blockers.length === 0,
-        key_present: Boolean(key.key),
-        key_source: key.source || null,
-        provider_present: providerPresent,
-        provider_env_key_present: providerEnvKeyPresent,
-        provider_auth_present: providerAuthPresent,
-        provider_auth_conflict: providerAuthConflict,
-        provider_auth_valid: providerAuthValid,
-        selected,
-        model,
-        model_source: model ? 'config' : null,
-        model_catalog_path: managedCatalogPath,
-        model_catalog_bound: modelCatalogBound,
-        config_path: configPath,
-        routing_ownership: ownership,
-        desktop_picker: desktopPickerStatusFromCache({
-            catalogOk: modelCatalogBound,
-            cache: null,
-            restartAppRequested: false
-        }),
-        thread_visibility: threadVisibility,
-        previous_routing_restore_available: previousRoutingRestoreAvailable,
-        blockers,
-        warnings
-    };
-}
-export async function useOpenRouter(input) {
-    const model = normalizeOpenRouterModelId(input.model);
-    if (!model) {
-        return {
-            schema: 'sks.codex-app-use-openrouter.v1',
-            generated_at: nowIso(),
-            ok: false,
-            status: 'blocked',
-            mode: 'openrouter',
-            blockers: ['openrouter_model_invalid'],
-            warnings: [],
-            hint: 'Choose a catalog model or pass --model <openrouter-model-id>.'
-        };
-    }
-    const home = input.home || process.env.HOME || os.homedir();
-    const configPath = input.configPath || codexLbConfigPath(home);
-    const env = { ...(input.env || process.env), HOME: home };
-    await ensureDir(path.dirname(configPath));
-    const key = await resolveOpenRouterApiKey({ env });
-    if (!key.key) {
-        return {
-            schema: 'sks.codex-app-use-openrouter.v1',
-            generated_at: nowIso(),
-            ok: false,
-            status: 'blocked',
-            mode: 'openrouter',
-            model,
-            blockers: ['openrouter_key_missing'],
-            warnings: [],
-            hint: 'Save a key first: sks codex-app set-openrouter-key --api-key-stdin'
-        };
-    }
-    const profile = await installCodexAppGlmProfile({
-        root: input.root,
-        apply: true,
-        home,
-        env,
-        configPath
-    });
-    const activationProfile = {
-        ...profile,
-        profile: {
-            ...profile.profile,
-            model
-        }
-    };
-    if (!profile.ok) {
-        return {
-            schema: 'sks.codex-app-use-openrouter.v1',
-            generated_at: nowIso(),
-            ok: false,
-            status: 'blocked',
-            mode: 'openrouter',
-            model,
-            profile: activationProfile,
-            blockers: profile.blockers,
-            warnings: profile.warnings || []
-        };
-    }
-    const configExistedBefore = await exists(configPath);
-    const currentBeforeSwitch = await readText(configPath, '');
-    const previousProvider = readTopLevelTomlString(currentBeforeSwitch, 'model_provider');
-    const threadVisibility = assessThreadVisibilityImpact({
-        home,
-        env,
-        currentProvider: previousProvider,
-        targetProvider: OPENROUTER_PROVIDER_ID
-    });
-    const preserveThreadSidebar = input.preserveThreadSidebar !== false;
-    const routingSnapshot = captureDesktopRoutingSnapshot(currentBeforeSwitch, {
-        reason: 'use-openrouter'
-    });
-    let snapshotWrite;
-    if (routingSnapshot.model_provider === OPENROUTER_PROVIDER_ID) {
-        const existingSnapshot = await readDesktopRoutingSnapshot({ home, env });
-        const crossProviderSnapshotPreserved = Boolean(existingSnapshot && existingSnapshot.model_provider !== OPENROUTER_PROVIDER_ID);
-        snapshotWrite = {
-            ok: crossProviderSnapshotPreserved,
-            path: desktopRoutingSnapshotPath({ home, env }),
-            skipped: crossProviderSnapshotPreserved
-                ? 'preserved_existing_cross_provider_snapshot'
-                : 'self_referential_snapshot_not_written'
-        };
-    }
-    else {
-        snapshotWrite = await writeDesktopRoutingSnapshot(routingSnapshot, { home, env });
-    }
-    const unselect = await unselectCodexLbProvider({
-        home,
-        configPath,
-        processEnv: env
-    }).catch((err) => ({ ok: false, status: 'failed', provider_error: err?.message || String(err) }));
-    if (unselect?.ok !== true) {
-        const sharedAuthActive = unselect?.reason === 'shared_codex_lb_auth_active';
-        return {
-            schema: 'sks.codex-app-use-openrouter.v1',
-            generated_at: nowIso(),
-            ok: false,
-            status: 'blocked',
-            mode: 'openrouter',
-            model,
-            profile: activationProfile,
-            unselect,
-            routing_snapshot: routingSnapshot,
-            routing_snapshot_write: snapshotWrite,
-            thread_visibility: threadVisibility,
-            blockers: [
-                sharedAuthActive
-                    ? 'legacy_codex_lb_desktop_config_requires_migration'
-                    : String(unselect?.status || 'codex_lb_unselect_failed')
-            ],
-            warnings: [],
-            ...(sharedAuthActive
-                ? { guidance: ['Run: sks codex-lb migrate-legacy-desktop --restart-app'] }
-                : {})
-        };
-    }
-    const modelCatalog = await writeOpenRouterManagedCatalog({ model, home, env });
-    const current = await readText(configPath, '');
-    const catalogBind = openRouterCatalogBindDecision(current, { home, env, configPath });
-    let next = upsertTopLevelTomlString(current, 'model_provider', OPENROUTER_PROVIDER_ID);
-    next = upsertTopLevelTomlString(next, 'model', model);
-    if (modelCatalog.ok && catalogBind.bindable) {
-        next = upsertTopLevelTomlString(next, 'model_catalog_json', modelCatalog.path);
-    }
-    next = normalizeCodexFastModeUiConfig(next);
-    next = ensureTrailingNewline(next);
-    const write = await safeWriteCodexConfigToml(configPath, current, next, 'openrouter-use', {
-        verifyUnchangedBeforeWrite: true,
-        expectedBeforeExists: configExistedBefore
-    });
-    if (!write.ok) {
-        return {
-            schema: 'sks.codex-app-use-openrouter.v1',
-            generated_at: nowIso(),
-            ok: false,
-            status: 'blocked',
-            mode: 'openrouter',
-            model,
-            write,
-            unselect,
-            routing_snapshot: routingSnapshot,
-            routing_snapshot_write: snapshotWrite,
-            thread_visibility: threadVisibility,
-            thread_sidebar_remap: null,
-            blockers: [String(write.status || 'openrouter_config_write_blocked')],
-            warnings: []
-        };
-    }
-    let threadSidebarRemap = null;
-    let threadSidebarMeta;
-    if (preserveThreadSidebar
-        && previousProvider
-        && previousProvider !== OPENROUTER_PROVIDER_ID) {
-        threadSidebarRemap = remapThreadCatalogProvider({
-            home,
-            env,
-            fromProvider: previousProvider,
-            toProvider: OPENROUTER_PROVIDER_ID
-        });
-        if (threadSidebarRemap.ok && threadSidebarRemap.remapped > 0) {
-            threadSidebarMeta = {
-                remapped: true,
-                from_provider: previousProvider,
-                to_provider: OPENROUTER_PROVIDER_ID,
-                thread_ids: threadSidebarRemap.thread_ids,
-                catalog_db: threadSidebarRemap.catalog_db
-            };
-            await writeDesktopRoutingSnapshot(captureDesktopRoutingSnapshot(currentBeforeSwitch, {
-                reason: 'use-openrouter',
-                threadSidebar: threadSidebarMeta
-            }), { home, env });
-        }
-    }
-    const restart = await (input.restartImpl || restartCodexApp)({ enabled: Boolean(input.restartApp) });
-    const cache = modelCatalog?.models_cache
-        || await invalidateCodexModelsCache({
-            home,
-            env,
-            catalogPath: modelCatalog.ok ? modelCatalog.path : null,
-            seedMode: 'merge'
-        });
-    const status = await openRouterStatus({ home, configPath, env });
-    const modelCatalogApplied = Boolean(modelCatalog.ok
-        && (!catalogBind.bindable || status.model_catalog_bound));
-    const configApplied = Boolean(status.selected
-        && status.key_present
-        && status.provider_present
-        && status.provider_auth_valid
-        && status.model === model
-        && modelCatalogApplied);
-    const desktopPicker = desktopPickerStatusFromCache({
-        catalogOk: modelCatalogApplied,
-        cache,
-        restartAppRequested: Boolean(input.restartApp)
-    });
-    return {
-        schema: 'sks.codex-app-use-openrouter.v1',
-        generated_at: nowIso(),
-        ok: configApplied,
-        status: configApplied ? (restart.ok ? 'active' : 'active_restart_blocked') : 'activation_incomplete',
-        mode: 'openrouter',
-        model,
-        profile: activationProfile,
-        unselect,
-        write,
-        restart_app: restart,
-        config_applied: configApplied,
-        restart_ok: restart.ok,
-        openrouter: {
-            ...status,
-            desktop_picker: desktopPicker
-        },
-        model_catalog: modelCatalog,
-        model_catalog_bind: catalogBind,
-        models_cache: cache,
-        desktop_picker: desktopPicker,
-        routing_ownership: status.routing_ownership,
-        routing_snapshot: routingSnapshot,
-        routing_snapshot_write: snapshotWrite,
-        previous_routing_restore_available: Boolean(snapshotWrite.ok),
-        thread_visibility: threadVisibility,
-        thread_sidebar_remap: threadSidebarRemap,
-        readiness: {
-            selected: status.selected,
-            key_present: status.key_present,
-            provider_present: status.provider_present,
-            provider_auth_present: status.provider_auth_present,
-            provider_auth_valid: status.provider_auth_valid,
-            model: status.model,
-            model_catalog_ok: modelCatalog.ok,
-            model_catalog_bound: status.model_catalog_bound,
-            features_normalized: true,
-            config_applied: configApplied,
-            restart_ok: restart.ok,
-            models_cache_invalidated: desktopPicker.models_cache_invalidated,
-            ok: configApplied
-        },
-        blockers: [
-            ...(status.selected ? [] : ['openrouter_not_selected']),
-            ...(status.model === model ? [] : ['openrouter_model_not_applied']),
-            ...(status.provider_auth_valid ? [] : ['openrouter_provider_auth_not_applied']),
-            ...(modelCatalogApplied
-                ? []
-                : (modelCatalog.blockers.length ? modelCatalog.blockers : ['openrouter_model_catalog_not_applied']))
-        ],
-        warnings: [
-            ...(unselect?.ok === false ? [`codex_lb_unselect:${unselect.provider_error || unselect.status}`] : []),
-            ...(restart.ok ? [] : (restart.blockers || ['openrouter_restart_blocked']).map((blocker) => `restart:${blocker}`)),
-            ...(profile.warnings || []),
-            ...(catalogBind.bindable ? [] : ['openrouter_model_catalog_user_catalog_preserved']),
-            ...modelCatalog.warnings,
-            ...cache.warnings,
-            ...(desktopPicker.models_cache_invalidated ? [] : ['openrouter_models_cache_not_invalidated']),
-            ...(threadSidebarRemap && !threadSidebarRemap.ok
-                ? [`thread_sidebar_remap_failed:${threadSidebarRemap.error || 'unknown'}`]
-                : []),
-            ...(threadVisibility.hidden_if_switched > 0 && !(threadSidebarMeta?.remapped)
-                ? [`desktop_hides_${threadVisibility.hidden_if_switched}_other_provider_threads`]
-                : []),
-            ...(snapshotWrite.ok
-                ? []
-                : [snapshotWrite.skipped
-                        ? `routing_snapshot_not_written:${snapshotWrite.skipped}`
-                        : `routing_snapshot_write_failed:${snapshotWrite.error || 'unknown'}`]),
-            'desktop_picker_restart_recommended_after_catalog_change',
-            'restore_previous_provider_via_sks_codex_app_restore_desktop_routing'
-        ],
-        hint: snapshotWrite.ok
-            ? 'Other-provider Desktop chats stay visible when sidebar remap succeeds; otherwise restore with: sks codex-app restore-desktop-routing --restart-app'
-            : 'If Desktop chats disappeared, run: sks codex-app restore-desktop-routing --restart-app'
-    };
-}
-export { restoreDesktopRoutingSnapshot };
-export async function ensureOpenRouterProviderInstalled(opts = {}) {
-    return ensureGlobalCodexAppGlmProfile(opts);
-}
-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) {
-    return new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*"${escapeRegExp(value)}"\\s*(?:#.*)?$`, 'm').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/openrouter-model-catalog.js

@@ -1,217 +0,0 @@
-import os from 'node:os';
-import path from 'node:path';
-import { nowIso, readText, writeTextAtomic } from '../fsx.js';
-import { CODEX_MODEL_CATALOG_MAX_MODELS, catalogModelRowBlockers, normalizeCodexModelId, readCodexModelCatalogFile, readTopLevelTomlString, sksOpenRouterCatalogPath } from './codex-model-catalog.js';
-import { isSksManagedCatalogPath, resolveCatalogPath } from './multi-provider-router-support.js';
-import { OPENROUTER_SELECTABLE_REASONING_EFFORTS } from './openrouter-provider.js';
-import { OPENROUTER_CATALOG_BASE_INSTRUCTIONS } from './openrouter-base-instructions.js';
-import { ensureTrailingNewline, removeTopLevelTomlKeyIfValue, safeWriteCodexConfigToml, upsertTopLevelTomlString } from '../codex-runtime/codex-desktop-config-policy.js';
-import { readRoleModelPreferences } from '../subagents/role-model-preferences.js';
-import { stampRoleModelCatalogPriorities } from './role-model-catalog-priority.js';
-import { invalidateCodexModelsCache } from './codex-models-cache.js';
-const OPENROUTER_REASONING_LEVEL_DESCRIPTIONS = {
-    none: 'No extra reasoning pass',
-    minimal: 'Fastest responses with minimal reasoning',
-    low: 'Fast responses with lighter reasoning',
-    medium: 'Balances speed and reasoning depth for everyday tasks',
-    high: 'Greater reasoning depth for complex problems',
-    xhigh: 'Extra high reasoning depth for complex problems'
-};
-export function openRouterCatalogModelRow(model) {
-    return {
-        slug: model,
-        display_name: model,
-        description: 'OpenRouter model activated by SKS',
-        default_reasoning_level: 'medium',
-        supported_reasoning_levels: OPENROUTER_SELECTABLE_REASONING_EFFORTS.map((effort) => ({
-            effort,
-            description: OPENROUTER_REASONING_LEVEL_DESCRIPTIONS[effort] || `${effort} reasoning`
-        })),
-        shell_type: 'default',
-        visibility: 'list',
-        supported_in_api: true,
-        priority: 0,
-        base_instructions: OPENROUTER_CATALOG_BASE_INSTRUCTIONS,
-        default_reasoning_summary: 'auto',
-        supports_reasoning_summaries: true,
-        support_verbosity: false,
-        truncation_policy: { mode: 'bytes', limit: 10_000 },
-        supports_parallel_tool_calls: true,
-        experimental_supported_tools: [],
-        input_modalities: ['text'],
-        context_window: 272_000,
-        max_context_window: 272_000,
-        multi_agent_version: 'v2'
-    };
-}
-export async function writeOpenRouterManagedCatalog(input) {
-    const env = input.env || process.env;
-    const home = input.home || env.HOME || os.homedir();
-    const catalogPath = sksOpenRouterCatalogPath({ home, env });
-    const model = normalizeCodexModelId(input.model);
-    if (!model) {
-        return {
-            schema: 'sks.openrouter-model-catalog-write.v1',
-            ok: false,
-            status: 'failed',
-            path: catalogPath,
-            models: [],
-            catalog: null,
-            blockers: ['openrouter_model_invalid'],
-            warnings: []
-        };
-    }
-    const warnings = [];
-    const existingRows = [];
-    const seenSlugs = new Set([model]);
-    const existingText = await readText(catalogPath, '');
-    if (existingText.trim()) {
-        try {
-            const parsed = JSON.parse(existingText);
-            if (parsed && typeof parsed === 'object' && Array.isArray(parsed.models)) {
-                for (const row of parsed.models) {
-                    if (!row || typeof row !== 'object' || Array.isArray(row))
-                        continue;
-                    const slug = normalizeCodexModelId(row.slug);
-                    if (!slug || seenSlugs.has(slug))
-                        continue;
-                    if (catalogModelRowBlockers(row).length) {
-                        warnings.push(`openrouter_model_catalog_previous_row_dropped:${slug}`);
-                        continue;
-                    }
-                    seenSlugs.add(slug);
-                    existingRows.push(row);
-                }
-            }
-            else {
-                warnings.push('openrouter_model_catalog_previous_shape_invalid');
-            }
-        }
-        catch {
-            warnings.push('openrouter_model_catalog_previous_invalid_json');
-        }
-    }
-    const baseRows = [openRouterCatalogModelRow(model), ...existingRows].slice(0, CODEX_MODEL_CATALOG_MAX_MODELS);
-    const rolePrefs = await readRoleModelPreferences({ env }).catch(() => null);
-    const stamped = stampRoleModelCatalogPriorities(baseRows, rolePrefs?.store || null);
-    if (stamped.missing_from_catalog.length) {
-        warnings.push(...stamped.missing_from_catalog.map((slug) => `role_model_not_in_openrouter_catalog:${slug}`));
-    }
-    const rows = stamped.rows;
-    const nextText = `${JSON.stringify({ generated_at: nowIso(), generated_by: 'sks-openrouter-activation', models: rows }, null, 2)}\n`;
-    try {
-        await writeTextAtomic(catalogPath, nextText, { mode: 0o600 });
-    }
-    catch (err) {
-        return {
-            schema: 'sks.openrouter-model-catalog-write.v1',
-            ok: false,
-            status: 'failed',
-            path: catalogPath,
-            models: rows.map((row) => String(row.slug)),
-            catalog: null,
-            blockers: [`openrouter_model_catalog_write_failed:${err?.code || err?.message || 'unknown'}`],
-            warnings
-        };
-    }
-    const cache = await invalidateCodexModelsCache({ home, env, catalogPath, seedMode: 'merge' });
-    if (!cache.ok)
-        warnings.push(...cache.blockers);
-    else
-        warnings.push(...cache.warnings);
-    const catalog = await readCodexModelCatalogFile({ filePath: catalogPath, configured: true });
-    return {
-        schema: 'sks.openrouter-model-catalog-write.v1',
-        ok: catalog.ok && catalog.models.some((entry) => entry.model === model),
-        status: existingText.trim() === nextText.trim() ? 'current' : 'written',
-        path: catalogPath,
-        models: catalog.models.map((entry) => entry.model),
-        catalog,
-        models_cache: cache,
-        role_model_priority: {
-            stamped: stamped.stamped,
-            stamped_models: stamped.stamped_models,
-            missing_from_catalog: stamped.missing_from_catalog
-        },
-        blockers: catalog.blockers,
-        warnings
-    };
-}
-export function openRouterCatalogBindDecision(configText, input = {}) {
-    const env = input.env || process.env;
-    const home = input.home || env.HOME || os.homedir();
-    const catalogPath = sksOpenRouterCatalogPath({ home, env });
-    const configured = readTopLevelTomlString(String(configText || ''), 'model_catalog_json');
-    if (!configured)
-        return { bindable: true, bound: false, configured_path: null, reason: 'unconfigured' };
-    const resolved = resolveCatalogPath(configured, {
-        home,
-        env,
-        ...(input.configPath === undefined ? {} : { configPath: input.configPath })
-    });
-    if (resolved === path.resolve(catalogPath)) {
-        return { bindable: true, bound: true, configured_path: configured, reason: 'already_bound' };
-    }
-    if (isSksManagedCatalogPath(resolved, { home, env })) {
-        return { bindable: true, bound: false, configured_path: configured, reason: 'sks_managed_replaceable' };
-    }
-    return { bindable: false, bound: false, configured_path: configured, reason: 'user_catalog_preserved' };
-}
-export async function ensureOpenRouterModelCatalog(input) {
-    const env = input.env || process.env;
-    const home = input.home || env.HOME || os.homedir();
-    const current = await readText(input.configPath, '');
-    const selectedProvider = readTopLevelTomlString(current, 'model_provider');
-    if (selectedProvider !== 'openrouter') {
-        const bind = openRouterCatalogBindDecision(current, { home, env, configPath: input.configPath });
-        if (bind.bound) {
-            const configured = readTopLevelTomlString(current, 'model_catalog_json') || '';
-            const next = ensureTrailingNewline(removeTopLevelTomlKeyIfValue(current, 'model_catalog_json', configured));
-            const safeWrite = await safeWriteCodexConfigToml(input.configPath, current, next, 'openrouter-model-catalog-unbind');
-            return {
-                schema: 'sks.openrouter-model-catalog-repair.v1',
-                ok: safeWrite.ok,
-                status: safeWrite.ok ? 'unbound_dangling' : String(safeWrite.status || 'config_write_blocked'),
-                selected_provider: selectedProvider,
-                write: safeWrite,
-                blockers: safeWrite.ok ? [] : [String(safeWrite.status || 'openrouter_model_catalog_unbind_failed')],
-                warnings: []
-            };
-        }
-        return { schema: 'sks.openrouter-model-catalog-repair.v1', ok: true, status: 'skipped', reason: 'openrouter_not_selected' };
-    }
-    const model = normalizeCodexModelId(readTopLevelTomlString(current, 'model'));
-    if (!model) {
-        return { schema: 'sks.openrouter-model-catalog-repair.v1', ok: false, status: 'blocked', blockers: ['openrouter_model_missing'] };
-    }
-    const write = await writeOpenRouterManagedCatalog({ model, home, env });
-    const bind = openRouterCatalogBindDecision(current, { home, env, configPath: input.configPath });
-    if (!write.ok || !bind.bindable || bind.bound) {
-        return {
-            schema: 'sks.openrouter-model-catalog-repair.v1',
-            ok: write.ok,
-            status: write.ok ? (bind.bound ? 'current' : 'catalog_written_not_bound') : 'failed',
-            model,
-            catalog: write,
-            bind,
-            blockers: write.blockers,
-            warnings: [
-                ...write.warnings,
-                ...(bind.bindable || bind.bound ? [] : ['openrouter_model_catalog_user_catalog_preserved'])
-            ]
-        };
-    }
-    const next = ensureTrailingNewline(upsertTopLevelTomlString(current, 'model_catalog_json', write.path));
-    const safeWrite = await safeWriteCodexConfigToml(input.configPath, current, next, 'openrouter-model-catalog');
-    return {
-        schema: 'sks.openrouter-model-catalog-repair.v1',
-        ok: safeWrite.ok,
-        status: safeWrite.ok ? 'bound' : String(safeWrite.status || 'config_write_blocked'),
-        model,
-        catalog: write,
-        bind,
-        write: safeWrite,
-        blockers: safeWrite.ok ? [] : [String(safeWrite.status || 'openrouter_model_catalog_bind_failed')],
-        warnings: write.warnings
-    };
-}

package/dist/core/codex-app/provider-child-policy.js

@@ -1,64 +0,0 @@
-import { assertProviderModeModel } from './provider-mode.js';
-export function decideProviderChildModel(input) {
-    const mode = input.session.mode;
-    if (mode === 'chatgpt-oauth') {
-        if (input.requestedModel) {
-            return blocked('native-oauth', 'oauth_child_model_override_forbidden');
-        }
-        return {
-            schema: 'sks.provider-child-model-decision.v1',
-            ok: true,
-            strategy: 'native-oauth',
-            model_override: null,
-            inherit_session_mode: true,
-            inherit_credential_binding: true,
-            settings_owner: 'codex-native',
-            blockers: []
-        };
-    }
-    const requested = String(input.requestedModel || '').trim();
-    if (!requested)
-        return blocked(mode === 'codex-lb' ? 'codex-lb-dynamic' : 'openrouter-registered', 'child_model_selection_required');
-    if (mode === 'codex-lb') {
-        try {
-            assertProviderModeModel('codex-lb', requested, input.session.allowed_models);
-        }
-        catch (error) {
-            return blocked('codex-lb-dynamic', `child_${error.message}`);
-        }
-        return allowed('codex-lb-dynamic', requested, 'codex-lb-session');
-    }
-    const registered = input.registeredOpenRouterModels || [];
-    try {
-        assertProviderModeModel('openrouter', requested, registered);
-        assertProviderModeModel('openrouter', requested, input.session.allowed_models);
-    }
-    catch (error) {
-        return blocked('openrouter-registered', `child_${error.message}`);
-    }
-    return allowed('openrouter-registered', requested, 'sks-center');
-}
-function allowed(strategy, model, owner) {
-    return {
-        schema: 'sks.provider-child-model-decision.v1',
-        ok: true,
-        strategy,
-        model_override: model,
-        inherit_session_mode: true,
-        inherit_credential_binding: true,
-        settings_owner: owner,
-        blockers: []
-    };
-}
-function blocked(strategy, blocker) {
-    return {
-        schema: 'sks.provider-child-model-decision.v1',
-        ok: false,
-        strategy,
-        model_override: null,
-        inherit_session_mode: true,
-        inherit_credential_binding: true,
-        settings_owner: strategy === 'native-oauth' ? 'codex-native' : strategy === 'openrouter-registered' ? 'sks-center' : 'codex-lb-session',
-        blockers: [blocker]
-    };
-}