sneakoscope 7.0.5 → 7.1.0

package/README.md

@@ -6,6 +6,10 @@
 
 Proof-first orchestration for Codex CLI, ChatGPT Desktop, AI coding agents, multi-agent workflows, release verification, and the macOS menu bar.
 
+<p align="center">
+  <img src="docs/assets/sks-logo.svg" alt="Sneakoscope Codex logo" width="160" height="160" />
+</p>
+
 [![npm version](https://img.shields.io/npm/v/sneakoscope?color=cb3837&logo=npm)](https://www.npmjs.com/package/sneakoscope)
 [![node](https://img.shields.io/badge/node-%3E%3D20.11-339933?logo=node.js&logoColor=white)](#requirements)
 [![license](https://img.shields.io/badge/license-MIT-blue)](#license)
@@ -18,7 +22,7 @@ Proof-first orchestration for Codex CLI, ChatGPT Desktop, AI coding agents, mult
 Sneakoscope Codex (`sks`) is an open-source trust layer for Codex CLI and ChatGPT Desktop. It coordinates bounded AI coding agents, records machine-verifiable evidence, preserves project memory, and blocks release claims that are not supported by current tests or artifacts. Search visibility outcomes are measured separately; SKS does not promise rankings or traffic.
 <!-- END SKS SEARCH VISIBILITY MARKETING -->
 
-Current release: **SKS 7.0.5**, with the package preferred Codex channel at **CLI 0.145.0**. SKS stays version-agnostic: older hosts keep working where capabilities allow, while Menu Bar / Center induce updates to the preferred latest. It resolves managed SKS skills from the authoritative global install, preserves a runnable Naruto child slot when `max_threads=2`, and keeps current-version Menu Bar repair transactional so stamped generations remain verifiable. Naruto uses stable opt-in multi-agent V2 when the host exposes it. See [CHANGELOG.md](CHANGELOG.md).
+Current release: **SKS 7.1.0**, with the package preferred Codex channel at **CLI 0.145.0**. SKS stays version-agnostic: older hosts keep working where capabilities allow, while Menu Bar / Center induce updates to the preferred latest. It resolves managed SKS skills from the authoritative global install, preserves a runnable Naruto child slot when `max_threads=2`, and keeps current-version Menu Bar repair transactional so stamped generations remain verifiable. Naruto uses stable opt-in multi-agent V2 when the host exposes it. See [CHANGELOG.md](CHANGELOG.md).
 
 ## What 7.0.0 Ships
 

package/crates/sks-core/Cargo.lock

@@ -76,7 +76,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "7.0.5"
+version = "7.1.0"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "7.0.5"
+version = "7.1.0"
 edition = "2021"
 
 [dependencies]

package/dist/cli/command-manifest-lite.js

@@ -16,7 +16,7 @@ export const COMMAND_MANIFEST_LITE = [
     { name: 'update', summary: 'Inspect, review, apply, or roll back the global SKS update', maturity: 'stable' },
     { name: 'uninstall', summary: 'Uninstall SKS global skills, hooks, config, menu bar, and optional project residue', maturity: 'stable', allowedDuringActiveRoute: true },
     { name: 'update-check', summary: 'Show the shared SKS, Codex CLI, and Menu Bar update status', maturity: 'stable', readonly: true, skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
-    { name: 'mcp', summary: 'Manage scoped Codex MCP configuration', maturity: 'beta' },
+    { name: 'mcp', summary: 'Manage scoped Codex MCP configuration', maturity: 'beta', skipMigrationGate: true },
     { name: 'wizard', summary: 'Open setup wizard help', maturity: 'stable' },
     { name: 'usage', summary: 'Show focused usage topic', maturity: 'stable', readonly: true, allowedDuringActiveRoute: true, diagnostic: true },
     { name: 'quickstart', summary: 'Show quickstart flow', maturity: 'stable' },

package/dist/cli/command-registry.js

@@ -135,7 +135,7 @@ const COMMAND_DEFINITIONS = {
         activeRoutePolicy: 'always'
     }),
     'update-check': readOnly(entry('stable', 'Show the shared SKS, Codex CLI, and Menu Bar update status', 'dist/core/commands/basic-cli.js', basicArgs('updateCheckCommand'))),
-    mcp: entry('beta', 'Manage scoped Codex MCP configuration', 'dist/core/commands/mcp-config-command.js', argsCommand(() => import('../core/commands/mcp-config-command.js'), 'mcpConfigCommand', 'dist/core/commands/mcp-config-command.js')),
+    mcp: skipMigrationGate(entry('beta', 'Manage scoped Codex MCP configuration', 'dist/core/commands/mcp-config-command.js', argsCommand(() => import('../core/commands/mcp-config-command.js'), 'mcpConfigCommand', 'dist/core/commands/mcp-config-command.js'))),
     wizard: entry('stable', 'Open setup wizard help', 'dist/core/commands/basic-cli.js', basicNoArgs('quickstartCommand')),
     usage: readOnly(entry('stable', 'Show focused usage topic', 'dist/core/commands/basic-cli.js', basicArgs('usageCommand'))),
     quickstart: entry('stable', 'Show quickstart flow', 'dist/core/commands/basic-cli.js', basicNoArgs('quickstartCommand')),

package/dist/cli/install-helpers-codex-lb-config.js

@@ -1,7 +1,8 @@
 import path from 'node:path';
 import os from 'node:os';
 import { ensureDir, readText } from '../core/fsx.js';
-import { GLM_CODEX_CONFIG_PROVIDER_ID, GLM_52_OPENROUTER_MODEL, OPENROUTER_DEFAULT_PROFILE_ID, RETIRED_GLM_DESKTOP_CONFIG_PROFILE_IDS } from '../core/codex-app/openrouter-provider.js';
+import { GLM_CODEX_CONFIG_PROVIDER_ID, GLM_52_OPENROUTER_MODEL, OPENROUTER_AUTH_COMMAND, OPENROUTER_AUTH_REFRESH_INTERVAL_MS, OPENROUTER_AUTH_TIMEOUT_MS, openRouterAuthCommandArgs, OPENROUTER_DEFAULT_PROFILE_ID, RETIRED_GLM_DESKTOP_CONFIG_PROFILE_IDS } from '../core/codex-app/openrouter-provider.js';
+import { openRouterSecretPaths, resolveOpenRouterApiKey } from '../core/providers/openrouter/openrouter-secret-store.js';
 import { reconcileRetiredSksConfigText } from '../core/auto-review.js';
 import { removeTopLevelTomlKeyIfValue, safeWriteCodexConfigToml, upsertTopLevelTomlString, upsertTomlTable } from '../core/codex-runtime/codex-desktop-config-policy.js';
 import { codexLbConfigPath, normalizeCodexLbBaseUrl } from './install-helpers-codex-lb-shared.js';
@@ -58,30 +59,41 @@ export function removeCodexLbSharedOpenAiRouting(text = '', baseUrl = '') {
         text: removeTopLevelLine(withoutValue, CODEX_LB_SHARED_OPENAI_ROUTING_MARKER)
     };
 }
-export function upsertCodexAppGlmConfig(text = '') {
+export function upsertCodexAppGlmConfig(text = '', input = {}) {
     let next = String(text || '');
+    const authEnv = { ...(input.env || process.env), ...(input.home ? { HOME: input.home } : {}) };
+    const authArgs = openRouterAuthCommandArgs(openRouterSecretPaths(authEnv).keyPath);
     const providerBlock = [
         `[model_providers.${GLM_CODEX_CONFIG_PROVIDER_ID}]`,
         'name = "OpenRouter"',
         'base_url = "https://openrouter.ai/api/v1"',
         'wire_api = "responses"',
-        'env_key = "OPENROUTER_API_KEY"',
         'requires_openai_auth = false'
     ].join('\n');
     next = upsertTomlTable(next, `model_providers.${GLM_CODEX_CONFIG_PROVIDER_ID}`, providerBlock);
+    const authBlock = [
+        `[model_providers.${GLM_CODEX_CONFIG_PROVIDER_ID}.auth]`,
+        `command = ${JSON.stringify(OPENROUTER_AUTH_COMMAND)}`,
+        `args = [${authArgs.map((value) => JSON.stringify(value)).join(', ')}]`,
+        `timeout_ms = ${OPENROUTER_AUTH_TIMEOUT_MS}`,
+        `refresh_interval_ms = ${OPENROUTER_AUTH_REFRESH_INTERVAL_MS}`
+    ].join('\n');
+    next = upsertTomlTable(next, `model_providers.${GLM_CODEX_CONFIG_PROVIDER_ID}.auth`, authBlock);
+    next = next.replace(new RegExp(`\\n+\\[model_providers\\.${GLM_CODEX_CONFIG_PROVIDER_ID}\\.auth\\]`), `\n\n[model_providers.${GLM_CODEX_CONFIG_PROVIDER_ID}.auth]`);
     next = reconcileRetiredSksConfigText(next).text;
     return `${next.trim()}\n`;
 }
 export async function ensureGlobalCodexAppGlmProfile(opts = {}) {
-    if (process.env.SKS_SKIP_CODEX_GLM_PROFILE_REPAIR === '1' && opts.force !== true) {
+    const env = opts.env || process.env;
+    if (env.SKS_SKIP_CODEX_GLM_PROFILE_REPAIR === '1' && opts.force !== true) {
         return { ok: true, status: 'skipped', reason: 'SKS_SKIP_CODEX_GLM_PROFILE_REPAIR=1' };
     }
-    const home = opts.home || process.env.HOME || os.homedir();
+    const home = opts.home || env.HOME || os.homedir();
     const configPath = opts.configPath || codexLbConfigPath(home);
     try {
         await ensureDir(path.dirname(configPath));
         const current = await readText(configPath, '');
-        const next = upsertCodexAppGlmConfig(current);
+        const next = upsertCodexAppGlmConfig(current, { home, env: opts.env });
         const safeWrite = await safeWriteCodexConfigToml(configPath, current, next, 'openrouter-provider');
         return {
             ...safeWrite,
@@ -107,6 +119,42 @@ export async function ensureGlobalCodexAppGlmProfile(opts = {}) {
         };
     }
 }
+export async function ensureStoredOpenRouterProviderDuringInstall(opts = {}) {
+    const home = opts.home || opts.env?.HOME || process.env.HOME || os.homedir();
+    const env = { ...(opts.env || process.env), HOME: home };
+    const key = await resolveOpenRouterApiKey({ env });
+    if (!key.key) {
+        return {
+            schema: 'sks.openrouter-provider-upgrade-repair.v1',
+            ok: true,
+            status: 'skipped',
+            reason: 'openrouter_key_missing',
+            key_present: false,
+            key_source: null,
+            blockers: [],
+            warnings: key.warnings
+        };
+    }
+    const repair = await ensureGlobalCodexAppGlmProfile({
+        ...opts,
+        home,
+        env
+    });
+    const ok = repair?.ok !== false;
+    return {
+        schema: 'sks.openrouter-provider-upgrade-repair.v1',
+        ok,
+        status: ok ? repair?.status || 'present' : 'failed',
+        reason: ok ? 'stored_openrouter_key_provider_reconciled' : 'stored_openrouter_key_provider_repair_failed',
+        key_present: true,
+        key_source: key.source,
+        config_path: repair?.config_path || opts.configPath || codexLbConfigPath(home),
+        provider: GLM_CODEX_CONFIG_PROVIDER_ID,
+        blockers: ok ? [] : ['openrouter_provider_repair_failed'],
+        warnings: key.warnings,
+        repair
+    };
+}
 export function detectCodexLbSetupDrift(state = {}) {
     const drift = [];
     if (state.useDefaultProvider && state.selected !== true)

package/dist/cli/install-helpers.js

@@ -27,7 +27,7 @@ import { repairCodexImagegen } from '../core/doctor/imagegen-repair.js';
 import { canAskYesNo, compareVersions, hasCodexUnstableFeatureWarningSuppression, hasDeprecatedCodexHooksFeatureFlag, hasTopLevelCodexModeLock, isProjectSetupCandidate } from './install-tool-helpers.js';
 import { checkCodexLbResponseChain } from './install-helpers-codex-lb-chain.js';
 import { CODEX_LB_CANONICAL_FAST_SERVICE_TIER, CODEX_LB_PROVIDER_ENV_KEY, CODEX_LB_PROVIDER_NAME, askPostinstallQuestion, codexAuthChatgptBackupPath, codexAuthPath, codexLbConfigPath, codexLbEnvPath, hasTopLevelCodexLbSelected, normalizeCodexLbBaseUrl, parseCodexLbEnvKey, redactSecretText } from './install-helpers-codex-lb-shared.js';
-import { appliedCodexLbPersistenceModes, captureCodexLbSetupWriteState, codexLbSharedOpenAiRoutingState, detectCodexLbSetupDrift, ensureGlobalCodexAppGlmProfile, parseCodexLbEnvBaseUrl, parseCodexSharedLoginApiKey, removeCodexLbSharedOpenAiRouting, sha256Text, shellSingleQuote, upsertCodexAppGlmConfig, upsertCodexLbConfig, upsertCodexLbSharedOpenAiRouting } from './install-helpers-codex-lb-config.js';
+import { appliedCodexLbPersistenceModes, captureCodexLbSetupWriteState, codexLbSharedOpenAiRoutingState, detectCodexLbSetupDrift, ensureGlobalCodexAppGlmProfile, ensureStoredOpenRouterProviderDuringInstall, parseCodexLbEnvBaseUrl, parseCodexSharedLoginApiKey, removeCodexLbSharedOpenAiRouting, sha256Text, shellSingleQuote, upsertCodexAppGlmConfig, upsertCodexLbConfig, upsertCodexLbSharedOpenAiRouting } from './install-helpers-codex-lb-config.js';
 import { ensureCodexImagegenDuringInstall, ensureGlobalCodexSkillsDuringInstall, ensureGlobalContext7DuringInstall, ensureGlobalGetdesignSkillDuringInstall, ensureSksCommandDuringInstall } from './install-helpers-install-support.js';
 function packagedSksEntrypoint() {
     return path.join(packageRoot(), 'dist', 'bin', 'sks.js');
@@ -89,6 +89,15 @@ export async function postinstall({ bootstrap, args = [] }) {
             console.log(`Codex App Fast mode: skipped (${fastModeRepair.reason}).`);
         else if (fastModeRepair.status === 'failed')
             console.log(`Codex App Fast mode: auto repair failed. Run \`sks setup\`. ${fastModeRepair.error || ''}`.trim());
+        const openRouterProviderRepair = await ensureStoredOpenRouterProviderDuringInstall();
+        if (openRouterProviderRepair.status === 'updated')
+            console.log('OpenRouter provider: repaired for the stored key (credentials and active model were preserved).');
+        else if (openRouterProviderRepair.status === 'present')
+            console.log('OpenRouter provider: stored-key configuration already compatible.');
+        else if (openRouterProviderRepair.status === 'skipped')
+            console.log('OpenRouter provider: no stored key; no provider configuration was added.');
+        else if (openRouterProviderRepair.status === 'failed')
+            console.log('OpenRouter provider: stored key was preserved, but provider repair failed. Run `sks doctor --fix`.');
         const imagegenRepair = await ensureCodexImagegenDuringInstall();
         if (imagegenRepair.status === 'ready')
             console.log('Codex App Image Gen: ready ($imagegen/gpt-image-2 detected).');
@@ -258,7 +267,7 @@ async function reportPostinstallCodexLbAuth(snapshot = null) {
 async function postinstallHarnessConflictNotice(conflictScan) {
     console.log('\nSneakoscope Codex package installed, but SKS setup is blocked.');
     console.log(formatHarnessConflictReport(conflictScan, { includePrompt: false }));
-    console.log('\nWhat this means: npm can finish installing the package. Conflicting OMX/DCodex markers are quarantined automatically by `sks setup`, `sks doctor --fix`, `sks update`, or `sks conflicts cleanup --yes`.');
+    console.log('\nWhat this means: npm can finish installing the package. Conflicting OMX/DCodex markers must be removed explicitly with `sks conflicts cleanup --yes` before `sks setup`, `sks doctor --fix`, or `sks update` can proceed.');
     console.log('No files were removed by postinstall.');
     console.log('Cleanup requires a human-approved Codex App session. Keep the model selected in Codex and use high reasoning effort.');
     if (shouldAskPostinstallQuestion()) {
@@ -1924,7 +1933,7 @@ export { checkContext7, ensureCodexCliTool, ensureMadLaunchDependencies, ensureR
 export { codexFastModeDesktopStatus, ensureGlobalCodexFastModeDuringInstall, normalizeCodexFastModeUiConfig, safeWriteCodexConfigToml } from '../core/codex-runtime/codex-desktop-config-policy.js';
 export { checkRequiredSkills, context7GlobalMcpStatus, ensureCodexImagegenDuringInstall, ensureGlobalCodexSkillsDuringInstall, ensureProjectContext7Config, ensureSksCommandDuringInstall, globalCodexSkillsRoot, selftestSksShimRepair } from './install-helpers-install-support.js';
 export { askPostinstallQuestion, codexLbConfigPath, codexLbEnvPath, normalizeCodexLbBaseUrl } from './install-helpers-codex-lb-shared.js';
-export { ensureGlobalCodexAppGlmProfile, upsertCodexAppGlmConfig, upsertCodexLbConfig } from './install-helpers-codex-lb-config.js';
+export { ensureGlobalCodexAppGlmProfile, ensureStoredOpenRouterProviderDuringInstall, upsertCodexAppGlmConfig, upsertCodexLbConfig } from './install-helpers-codex-lb-config.js';
 export { checkCodexLbResponseChain } from './install-helpers-codex-lb-chain.js';
 export { selftestCodexLb } from './install-helpers-codex-lb-selftest.js';
 function escapeRegExp(value) {

package/dist/commands/codex-app.js

@@ -14,7 +14,9 @@ import { doctorCodexAppGlmProfile, installCodexAppGlmProfile } from '../core/cod
 import { openRouterStatus, useOpenRouter } from '../core/codex-app/openrouter-activate.js';
 import { OPENROUTER_DEFAULT_MODEL } from '../core/codex-app/openrouter-provider.js';
 import { promptForOpenRouterKeyHidden, writeStoredOpenRouterKey } from '../core/providers/openrouter/openrouter-secret-store.js';
+import { compactOpenRouterModelsResult, listOpenRouterModels, testOpenRouterConnection } from '../core/providers/openrouter/openrouter-account.js';
 import { restartCodexApp } from '../core/codex-app/codex-app-restart.js';
+import { resetRoleModelPreference, roleModelPreferencesStatus, setRoleModelPreference } from '../core/subagents/role-model-preferences.js';
 export async function run(_command, args = []) {
     const action = args[0] || 'check';
     if (action === 'restart')
@@ -82,6 +84,30 @@ export async function run(_command, args = []) {
         const result = await openRouterStatus({});
         return printCodexAppResult(args, result);
     }
+    if (action === 'openrouter-models') {
+        const models = await listOpenRouterModels({});
+        const result = flag(args, '--ids-only') ? compactOpenRouterModelsResult(models) : models;
+        return printCodexAppResult(args, result);
+    }
+    if (action === 'openrouter-test') {
+        const result = await testOpenRouterConnection({ model: readOption(args, '--model', '') });
+        return printCodexAppResult(args, result);
+    }
+    if (action === 'role-models') {
+        return printCodexAppResult(args, await roleModelPreferencesStatus());
+    }
+    if (action === 'set-role-model') {
+        const result = await setRoleModelPreference({
+            role: readOption(args, '--role', ''),
+            model: readOption(args, '--model', ''),
+            reasoning: readOption(args, '--reasoning', '')
+        });
+        return printCodexAppResult(args, result);
+    }
+    if (action === 'reset-role-model') {
+        const result = await resetRoleModelPreference({ role: readOption(args, '--role', '') });
+        return printCodexAppResult(args, result);
+    }
     if (action === 'product-design' || action === 'design-product' || action === 'ensure-product-design') {
         const checkOnly = flag(args, '--check-only') || flag(args, '--no-install');
         const status = await codexProductDesignPluginStatus({
@@ -142,7 +168,7 @@ export async function run(_command, args = []) {
             process.exitCode = 1;
         return;
     }
-    console.error('Usage: sks codex-app check|status|harness-matrix|skill-sync|agent-role-sync|init-deep|hook-lifecycle|execution-profile|set-openrouter-key [--api-key-stdin]|use-openrouter --model <id>|openrouter-status|product-design [--check-only]|ensure-product-design|chrome-extension|pat status|remote-control [--json]');
+    console.error('Usage: sks codex-app check|status|harness-matrix|skill-sync|agent-role-sync|init-deep|hook-lifecycle|execution-profile|set-openrouter-key [--api-key-stdin]|use-openrouter --model <id>|openrouter-status|openrouter-models [--ids-only]|openrouter-test [--model <id>]|role-models|set-role-model --role <name> --model <id> --reasoning <effort>|reset-role-model --role <name>|product-design [--check-only]|ensure-product-design|chrome-extension|pat status|remote-control [--json]');
     console.error('Note: glm-profile is retired (strips leftover Desktop GLM profiles); use set-openrouter-key / use-openrouter.');
     process.exitCode = 1;
 }

package/dist/commands/doctor.js

@@ -35,32 +35,27 @@ export async function run(_command, args = [], deps = {}) {
     const doctorFix = flag(args, '--fix');
     const globalOnly = doctorFix && flag(args, '--global-only');
     if (doctorFix) {
-        const { cleanupOtherHarnessConflicts } = await import('../core/harness-conflicts.js');
         const conflictScan = await scanHarnessConflicts(root);
         if (conflictScan.hard_block) {
-            const cleanup = await cleanupOtherHarnessConflicts(root);
-            if (!cleanup.ok) {
-                const blocked = {
-                    schema: 'sks.doctor-status.v3',
-                    ok: false,
-                    status: 'blocked_harness_conflict',
-                    diagnostic_depth: 'fix',
-                    root,
-                    blockers: (cleanup.remaining || conflictScan.hard).map((item) => `${item.name || 'harness'}:${item.path}`),
-                    conflicts: cleanup.after?.conflicts || conflictScan.conflicts,
-                    other_harness_cleanup: cleanup,
-                    cleanup_prompt_command: 'sks conflicts cleanup --yes',
-                    no_fix_writes_performed: cleanup.cleaned.length === 0
-                };
-                process.exitCode = 1;
-                if (flag(args, '--json')) {
-                    printJson(blocked);
-                    return blocked;
-                }
-                console.error(formatHarnessConflictReport(cleanup.after || conflictScan, { includePrompt: false }));
-                console.error('Automatic OMX/DCodex removal did not clear every conflict. Live markers must be removed; inspect backup under .sneakoscope/quarantine/other-harness/.');
+            const blocked = {
+                schema: 'sks.doctor-status.v3',
+                ok: false,
+                status: 'blocked_harness_conflict',
+                diagnostic_depth: 'fix',
+                root,
+                blockers: conflictScan.hard.map((item) => `${item.name || 'harness'}:${item.path}`),
+                conflicts: conflictScan.conflicts,
+                cleanup_prompt_command: 'sks conflicts cleanup --yes',
+                no_fix_writes_performed: true
+            };
+            process.exitCode = 1;
+            if (flag(args, '--json')) {
+                printJson(blocked);
                 return blocked;
             }
+            console.error(formatHarnessConflictReport(conflictScan, { includePrompt: false }));
+            console.error('Run `sks conflicts cleanup --yes` to quarantine OMX/DCodex markers before doctor --fix.');
+            return blocked;
         }
     }
     const doctorProfile = doctorProfileFromArgs(args, doctorFix);
@@ -89,6 +84,8 @@ export async function executeDoctorGlobalOnlyFix(args = [], root, deps = {}) {
         || (await import('../core/doctor/command-alias-cleanup.js')).runDoctorCommandAliasCleanup;
     const ensureGlobalFastModeImpl = deps.ensureGlobalCodexFastModeDuringInstallImpl
         || (await import('../cli/install-helpers.js')).ensureGlobalCodexFastModeDuringInstall;
+    const ensureStoredOpenRouterProviderImpl = deps.ensureStoredOpenRouterProviderDuringInstallImpl
+        || (await import('../cli/install-helpers.js')).ensureStoredOpenRouterProviderDuringInstall;
     const installMenuBarImpl = deps.installSksMenuBarImpl || installSksMenuBar;
     const codexLbStatusImpl = deps.codexLbStatusImpl || codexLbStatus;
     const providerStatus = await codexLbStatusImpl({
@@ -131,6 +128,16 @@ export async function executeDoctorGlobalOnlyFix(args = [], root, deps = {}) {
         status: 'failed',
         error: err?.message || String(err)
     }));
+    const openRouterEnv = deps.env || (deps.home
+        ? { ...process.env, HOME: home, SKS_HOME: path.join(home, '.sneakoscope') }
+        : { ...process.env, HOME: home });
+    const openRouterProvider = await ensureStoredOpenRouterProviderImpl({ home, env: openRouterEnv }).catch((err) => ({
+        schema: 'sks.openrouter-provider-upgrade-repair.v1',
+        ok: false,
+        status: 'failed',
+        blockers: ['openrouter_provider_repair_failed'],
+        error: err?.message || String(err)
+    }));
     const menuBar = await installMenuBarImpl({
         home,
         root: home,
@@ -151,10 +158,12 @@ export async function executeDoctorGlobalOnlyFix(args = [], root, deps = {}) {
     const globalFastModeReady = globalFastMode?.status !== 'failed'
         && globalFastMode?.ok !== false;
     const menuBarReady = menuBar?.ok !== false;
+    const openRouterProviderReady = openRouterProvider?.ok !== false;
     const blockers = [...new Set([
             ...(!globalSkillsReady ? [`global_skills_reconcile_failed:${globalSkills?.error || 'core_skill_integrity'}`] : []),
             ...(currentSurface?.ok !== true ? (currentSurface?.blockers || ['global_current_surface_reconcile_failed']) : []),
             ...(!globalFastModeReady ? [`global_fast_mode_repair_failed:${globalFastMode?.error || globalFastMode?.status || 'unknown'}`] : []),
+            ...(!openRouterProviderReady ? (openRouterProvider?.blockers || ['openrouter_provider_repair_failed']) : []),
             ...(!menuBarReady ? (menuBar?.blockers || ['sks_menubar_repair_failed']) : []),
             ...(!recoveryReady ? (providerStatus?.tool_output_recovery?.blockers || ['codex_lb_tool_output_recovery_unverified']) : [])
         ].map(String).filter(Boolean))];
@@ -183,6 +192,7 @@ export async function executeDoctorGlobalOnlyFix(args = [], root, deps = {}) {
         skills: { global: globalSkills, project: { skipped: true, reason: 'global_only_doctor' } },
         current_public_surface: currentSurface,
         codex_app_fast_mode: globalFastMode,
+        openrouter_provider: openRouterProvider,
         sks_menubar: menuBar,
         codex_lb: {
             provider_status: providerStatus,
@@ -192,6 +202,7 @@ export async function executeDoctorGlobalOnlyFix(args = [], root, deps = {}) {
         blockers,
         next_actions: [
             ...(recoveryReady ? [] : (providerStatus?.tool_output_recovery?.operator_actions || [])),
+            ...(!openRouterProviderReady ? ['Run `sks codex-app set-openrouter-key` to repair the stored-key provider configuration without switching models.'] : []),
             'Run `sks doctor --fix --json` from a specific project directory when project-scoped repair is required.'
         ]
     };
@@ -432,10 +443,20 @@ async function runDoctor(args = [], root, doctorFix) {
     const doctorDirtyPlan = doctorFix ? (await import('../core/doctor/doctor-dirty-planner.js')).planDoctorDirtyRepair(root, doctorPhaseIds) : null;
     let setupRepair = null;
     let sksUpdate = null;
+    let openRouterProviderRepair = { ok: true, status: 'skipped', reason: 'doctor_without_fix' };
     let migrationPreFix = null;
     if (doctorFix) {
         migrationPreFix = await captureCodexConfigSnapshot();
         const installScope = installScopeFromArgs(args);
+        openRouterProviderRepair = flag(args, '--local-only')
+            ? { ok: true, status: 'skipped', reason: 'local-only repair' }
+            : await (await import('../cli/install-helpers.js')).ensureStoredOpenRouterProviderDuringInstall().catch((err) => ({
+                schema: 'sks.openrouter-provider-upgrade-repair.v1',
+                ok: false,
+                status: 'failed',
+                blockers: ['openrouter_provider_repair_failed'],
+                error: err?.message || String(err)
+            }));
         setupRepair = {
             schema: 'sks.doctor-setup-phase.v2',
             ok: true,
@@ -449,7 +470,8 @@ async function runDoctor(args = [], root, doctorFix) {
                 : { status: 'skipped', reason: 'project or local-only repair' },
             codex_app_fast_mode: flag(args, '--local-only')
                 ? { status: 'skipped', reason: 'local-only repair' }
-                : await (await import('../cli/install-helpers.js')).ensureGlobalCodexFastModeDuringInstall().catch((err) => ({ status: 'failed', error: err?.message || String(err) }))
+                : await (await import('../cli/install-helpers.js')).ensureGlobalCodexFastModeDuringInstall().catch((err) => ({ status: 'failed', error: err?.message || String(err) })),
+            openrouter_provider: openRouterProviderRepair
         };
     }
     const skillsReconcile = await reconcileDoctorSkills(root, doctorFix);
@@ -1217,7 +1239,12 @@ async function runDoctor(args = [], root, doctorFix) {
         ]
     });
     if (doctorFix) {
-        const readinessBlockers = Array.isArray(ready.blockers) ? ready.blockers.map(String).filter(Boolean) : [];
+        const readinessBlockers = [
+            ...(Array.isArray(ready.blockers) ? ready.blockers.map(String).filter(Boolean) : []),
+            ...(openRouterProviderRepair?.ok === false
+                ? ((openRouterProviderRepair?.blockers || ['openrouter_provider_repair_failed']).map(String))
+                : [])
+        ];
         const migrationWarnings = [
             ...(doctorNativeCapabilityRepair?.optional_warnings || []),
             ...(doctorFixPostcheck?.optional_warnings || [])
@@ -1265,6 +1292,7 @@ async function runDoctor(args = [], root, doctorFix) {
         && commandAliasCleanup.ok !== false
         && codexStartupRepair.ok !== false
         && agentRoleConfigRepair.ok !== false
+        && openRouterProviderRepair.ok !== false
         && (officialSubagentConfig.blockers || []).length === 0
         && codexLbRecoveryReady;
     const result = {
@@ -1284,6 +1312,7 @@ async function runDoctor(args = [], root, doctorFix) {
         rust,
         codex_app: codexApp,
         codex_app_ui: codexAppUi,
+        openrouter_provider: openRouterProviderRepair,
         sks_menubar: sksMenuBar,
         provider_context: providerContext,
         codex_lb: codexLb,
@@ -1344,7 +1373,7 @@ async function runDoctor(args = [], root, doctorFix) {
         sneakoscope: { ok: await exists(`${root}/.sneakoscope`) },
         package: { bytes: pkgBytes, human: formatBytes(pkgBytes) },
         skills: skillsReconcile,
-        repair: { sks_update: sksUpdate, setup: setupRepair, codex_config: configRepair, migration_journal: migrationJournal, global_sks_installs: globalSksInstallCleanup, agent_role_config: agentRoleConfigRepair, zellij: zellijRepair, context7: context7Repair, codex_startup: codexStartupRepair, startup_config: startupConfigRepair, context7_mcp: context7McpRepair, supabase_mcp: supabaseMcpRepair, mcp_transport_collision: mcpTransportCollisionRepair, imagegen: imagegenRepair, computer_use: computerUseRepair, browser_use: browserUseRepair, hook_trust: hookTrustRepair, sks_menubar: sksMenuBar, doctor_transaction: doctorFixTransaction, doctor_dirty_plan: doctorDirtyPlan, doctor_postcheck: doctorFixPostcheck, codex_native: codexNativeRepair, doctor_native_capability: doctorNativeCapabilityRepair, command_aliases: commandAliasCleanup, skills: skillsReconcile, sks_temp_sweep: sksTempSweep }
+        repair: { sks_update: sksUpdate, setup: setupRepair, openrouter_provider: openRouterProviderRepair, codex_config: configRepair, migration_journal: migrationJournal, global_sks_installs: globalSksInstallCleanup, agent_role_config: agentRoleConfigRepair, zellij: zellijRepair, context7: context7Repair, codex_startup: codexStartupRepair, startup_config: startupConfigRepair, context7_mcp: context7McpRepair, supabase_mcp: supabaseMcpRepair, mcp_transport_collision: mcpTransportCollisionRepair, imagegen: imagegenRepair, computer_use: computerUseRepair, browser_use: browserUseRepair, hook_trust: hookTrustRepair, sks_menubar: sksMenuBar, doctor_transaction: doctorFixTransaction, doctor_dirty_plan: doctorDirtyPlan, doctor_postcheck: doctorFixPostcheck, codex_native: codexNativeRepair, doctor_native_capability: doctorNativeCapabilityRepair, command_aliases: commandAliasCleanup, skills: skillsReconcile, sks_temp_sweep: sksTempSweep }
     };
     if (reportFile)
         await writeJsonReportFile(reportFile, result);