sneakoscope 7.0.5 → 7.1.1

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.1**, 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
 
@@ -50,6 +54,12 @@ The SKS menu bar shows the installed Codex CLI version and latest known version.
 
 **Manage MCP Servers…** opens a native macOS manager for the global `~/.codex/config.toml`. It can add remote URL or local stdio servers, enable/disable existing entries, remove entries after confirmation, and refresh the current state. Mutations are lock-protected, backed up, TOML-validated, and written with mode `0600`; configured environment values and command arguments are never rendered in the list. Changes apply to new Codex sessions. The same plumbing is available through the canonical `sks mcp config list|get|add|edit|duplicate|enable|disable|remove|test|login|logout|backups|restore` surface for diagnostics and automation.
 
+### Telegram remote coding on this Mac
+
+Open **SKS Center → Remote & Telegram**, create a private bot with BotFather, send `/start` to that bot from the Telegram account you want to pair, then choose **Connect Bot & Register Coding Session…** and paste the token. SKS verifies the bot, stores the token only in macOS Keychain, pairs only that private chat/user, and registers one dedicated session bound to the current project. Choose **Start Hub**, then send ordinary text to the bot. On the first real message, the Hub creates the Codex thread and starts its first turn in the same App Server connection so the thread is durably resumable; later messages resume that exact thread and return the final response to Telegram.
+
+The Hub runs as a user LaunchAgent and uses `caffeinate -i` while the logged-in Mac is available. The Mac still needs to remain powered on, logged in, awake, and network-connected; closing the lid or logging out can stop access. Telegram input has no arbitrary shell path, runs with approvals disabled and network access disabled inside the Codex workspace sandbox, and cannot target an unpaired chat or another project.
+
 ## The Front Door
 
 | Command | What it does |

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "7.0.5"
+version = "7.1.1"
 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' },
@@ -36,7 +36,7 @@ export const COMMAND_MANIFEST_LITE = [
     { name: 'codex-lb', summary: 'Inspect codex-lb status and circuit health', maturity: 'beta' },
     { name: 'menubar', summary: 'Inspect/install/restart/uninstall SKS menu bar', maturity: 'beta', skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
     { name: 'remote', summary: 'Inspect official Remote readiness and run the proof-aware SSH stdio worker', maturity: 'beta' },
-    { name: 'telegram', summary: 'Inspect and run the private proof-aware Telegram Hub', maturity: 'beta' },
+    { name: 'telegram', summary: 'Pair and run the private local Codex Telegram Hub', maturity: 'beta' },
     { name: 'hooks', summary: 'Explain and inspect Codex hooks', maturity: 'beta', skipMigrationGate: true },
     { name: 'zellij-lane', summary: 'Render a Zellij lane frame for SKS sessions', maturity: 'beta' },
     { name: 'zellij-slot-pane', summary: 'Render a compact Zellij worker slot pane', maturity: 'beta' },

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')),
@@ -155,7 +155,7 @@ const COMMAND_DEFINITIONS = {
     'codex-lb': entry('beta', 'Inspect codex-lb status and circuit health', 'dist/commands/codex-lb.js', directCommand(() => import('../commands/codex-lb.js'), 'dist/commands/codex-lb.js')),
     menubar: activeRouteDiagnostic(entry('beta', 'Inspect/install/restart/uninstall SKS menu bar', 'dist/core/commands/menubar-command.js', subcommand(() => import('../core/commands/menubar-command.js'), 'menubarCommand', 'dist/core/commands/menubar-command.js', 'status'))),
     remote: entry('beta', 'Inspect official Remote readiness and run the proof-aware SSH stdio worker', 'dist/core/commands/remote-command.js', argsCommand(() => import('../core/commands/remote-command.js'), 'remoteCommand', 'dist/core/commands/remote-command.js')),
-    telegram: entry('beta', 'Inspect and run the private proof-aware Telegram Hub', 'dist/core/commands/telegram-command.js', argsCommand(() => import('../core/commands/telegram-command.js'), 'telegramCommand', 'dist/core/commands/telegram-command.js')),
+    telegram: entry('beta', 'Pair and run the private local Codex Telegram Hub', 'dist/core/commands/telegram-command.js', argsCommand(() => import('../core/commands/telegram-command.js'), 'telegramCommand', 'dist/core/commands/telegram-command.js')),
     hooks: skipMigrationGate(entry('beta', 'Explain and inspect Codex hooks', 'dist/commands/hooks.js', directCommand(() => import('../commands/hooks.js'), 'dist/commands/hooks.js'))),
     'zellij-lane': entry('beta', 'Render a Zellij lane frame for SKS sessions', 'dist/commands/zellij-lane.js', directCommand(() => import('../commands/zellij-lane.js'), 'dist/commands/zellij-lane.js')),
     'zellij-slot-pane': entry('beta', 'Render a compact Zellij worker slot pane', 'dist/commands/zellij-slot-pane.js', directCommand(() => import('../commands/zellij-slot-pane.js'), 'dist/commands/zellij-slot-pane.js')),

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,10 @@ 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 { MULTI_PROVIDER_ROUTER_DEFAULT_BASE_URL, multiProviderRouterStatus, testMultiProviderRouter, useMultiProviderRouter } from '../core/codex-app/multi-provider-router.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 +85,56 @@ 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 === 'router-status' || action === 'multi-provider-status' || action === 'opencodex-status') {
+        const result = await multiProviderRouterStatus({
+            baseUrl: readOption(args, '--base-url', ''),
+            catalogPath: readOption(args, '--catalog', '')
+        });
+        return printCodexAppResult(args, result);
+    }
+    if (action === 'router-test' || action === 'multi-provider-test' || action === 'opencodex-test') {
+        const result = await testMultiProviderRouter({
+            baseUrl: readOption(args, '--base-url', MULTI_PROVIDER_ROUTER_DEFAULT_BASE_URL),
+            catalogPath: readOption(args, '--catalog', ''),
+            model: readOption(args, '--model', '')
+        });
+        return printCodexAppResult(args, result);
+    }
+    if (action === 'use-router' || action === 'use-multi-provider' || action === 'use-opencodex') {
+        const result = await useMultiProviderRouter({
+            model: readOption(args, '--model', ''),
+            baseUrl: readOption(args, '--base-url', MULTI_PROVIDER_ROUTER_DEFAULT_BASE_URL),
+            catalogPath: readOption(args, '--catalog', ''),
+            replaceCatalog: flag(args, '--replace-catalog'),
+            restartApp: flag(args, '--restart-app') || flag(args, '--restart') || !flag(args, '--no-restart-app')
+        });
+        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', ''),
+            provider: readOption(args, '--provider', ''),
+            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 +195,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>]|router-status [--base-url <loopback-url>] [--catalog <path>]|router-test --model <provider/model> [--base-url <loopback-url>] [--catalog <path>]|use-router --model <provider/model> [--base-url <loopback-url>] [--catalog <path>] [--replace-catalog]|role-models|set-role-model --role <name> [--provider <id>] --model <catalog-slug> --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-profile.js

@@ -0,0 +1,78 @@
+import { flag } from '../cli/args.js';
+import { sksMenuBarRestartDeferred } from '../core/codex-app/sks-menubar.js';
+export function doctorProfileFromArgs(args = [], doctorFix = false) {
+    const explicit = readOption(args, '--profile');
+    if (isDoctorProfile(explicit))
+        return explicit;
+    if (flag(args, '--full'))
+        return 'full';
+    if (flag(args, '--capabilities'))
+        return 'capabilities';
+    return doctorFix ? 'fix' : 'fast';
+}
+export function doctorArgWarnings(args = []) {
+    const warnings = [];
+    const explicit = readOption(args, '--profile');
+    if (explicit && !isDoctorProfile(explicit)) {
+        warnings.push(`unknown_profile:${explicit}; supported profiles: migration, full, capabilities, fast, fix`);
+    }
+    for (const value of unknownDoctorFlags(args))
+        warnings.push(`unknown_flag:${value}`);
+    return warnings;
+}
+export function doctorMenuBarInstallPolicy(args = [], doctorFix = false, env = process.env) {
+    const profile = doctorProfileFromArgs(args, doctorFix);
+    const phaseEnabled = doctorPhaseIdsForProfile(profile).includes('sks_menubar');
+    const apply = doctorFix && phaseEnabled;
+    return {
+        profile,
+        phase_enabled: phaseEnabled,
+        apply,
+        launch: apply && !sksMenuBarRestartDeferred(env)
+    };
+}
+export function doctorPhaseIdsForProfile(profile) {
+    const required = [
+        'codex_startup_repair',
+        'startup_config_repair',
+        'context7_repair',
+        'context7_mcp_repair',
+        'hook_trust_repair',
+        'command_alias_cleanup'
+    ];
+    if (profile === 'migration')
+        return required;
+    const optional = ['supabase_mcp_repair', 'native_capability_repair', 'sks_menubar'];
+    if (profile === 'full' || profile === 'capabilities')
+        return ['setup', ...required, ...optional];
+    return [...required, ...optional];
+}
+function unknownDoctorFlags(args) {
+    const knownBoolean = new Set([
+        '--fix', '--yes', '-y', '--machine-only', '--actual-codex', '--require-actual-codex',
+        '--full', '--capabilities', '--repair-codex-app-ui', '--repair-zellij', '--install-homebrew',
+        '--repair-native-capabilities', '--repair-codex-native', '--local-only', '--global-only', '--project', '--global',
+        '--dry-run', '--json'
+    ]);
+    const knownValue = new Set(['--profile', '--report-file', '--codex-bin', '--install-scope']);
+    const unknown = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = String(args[index] || '');
+        if (!arg.startsWith('-'))
+            continue;
+        if (knownValue.has(arg)) {
+            index += 1;
+            continue;
+        }
+        if (!knownBoolean.has(arg))
+            unknown.push(arg);
+    }
+    return unknown;
+}
+function isDoctorProfile(value) {
+    return ['migration', 'full', 'capabilities', 'fast', 'fix'].includes(String(value || ''));
+}
+function readOption(args, name) {
+    const index = args.indexOf(name);
+    return index >= 0 && args[index + 1] ? String(args[index + 1]) : null;
+}