sneakoscope 8.1.2 → 8.2.0

package/dist/commands/doctor.js

@@ -1,6 +1,5 @@
 import os from 'node:os';
 import path from 'node:path';
-import { createHash } from 'node:crypto';
 import { projectRoot, exists, formatBytes, nowIso, readText, writeJsonAtomic } from '../core/fsx.js';
 import { flag } from '../cli/args.js';
 import { printJson } from '../cli/output.js';
@@ -8,23 +7,14 @@ import { ui as cliUi } from '../cli/cli-theme.js';
 import { getCodexInfo } from '../core/codex-adapter.js';
 import { rustInfo } from '../core/rust-accelerator.js';
 import { codexAppIntegrationStatus } from '../core/codex-app.js';
-import { codexLbMetrics, readCodexLbCircuit } from '../core/codex-lb-circuit.js';
-import { codexLbStatus } from '../cli/install-helpers.js';
-import { codexLbToolOutputRecoveryOverrideAcknowledged } from '../core/codex-lb/codex-lb-tool-output-recovery.js';
-import { codexLbEnvPath, loadCodexLbEnv } from '../core/codex-lb/codex-lb-env.js';
-import { codexLbLegacyKeychainMigrationStampPath, inspectDesktopCenterLaunchCredentials, inspectCodexLbLegacyKeychainMigration, repairCodexLbLegacyKeychainMigration, syncDesktopCenterLaunchCredentials } from '../core/codex-lb/desktop-center-credentials.js';
-import { codexLbRoutingTruthIsActive, measureAndWriteCodexLbRoutingTruth, readCodexLbRoutingTruthReceipt } from '../core/codex-lb/routing-truth.js';
-import { removeCodexLbOrphanManagedMarkers } from '../cli/install-helpers-codex-lb-config.js';
-import { safeWriteCodexConfigToml } from '../core/codex-runtime/codex-desktop-config-policy.js';
+import { desktopBridgeStatusV3 } from '../core/codex-lb/desktop-controller-v3.js';
 import { probeTelegram, telegramSelfHealAction } from '../core/telegram/doctor.js';
 import { TelegramClient } from '../core/telegram/client.js';
 import { resolveTelegramBotToken } from '../core/telegram/keychain.js';
 import { telegramLivenessPath } from '../core/telegram/liveness.js';
-import { normalizeInstallScope } from '../core/init.js';
 import { inspectCodexConfigReadability } from '../core/codex/codex-config-readability.js';
 import { inspectOAuthCallbackPortConflict, oauthCallbackDoctorGuidance } from '../core/codex/oauth-callback-port-diagnostic.js';
 import { inventoryCodexPermissionProfiles } from '../core/codex/codex-permission-profiles.js';
-import { appendMigrationEvents, hashConfigText } from '../core/migration/migration-transaction-journal.js';
 import { resolveProviderContext } from '../core/provider/provider-context.js';
 import { readLocalModelConfig } from '../core/agents/ollama-worker-config.js';
 import { writeCodexCurrentAppCapabilityArtifacts } from '../core/codex-control/codex-current-app-capability.js';
@@ -42,11 +32,12 @@ import { sweepSksTempDirs } from '../core/retention.js';
 import { detectImagegenCapability } from '../core/imagegen/imagegen-capability.js';
 import { CURRENT_CODEX_RELEASE_MANIFEST } from '../core/codex-compat/codex-release-manifest.js';
 import { formatHarnessConflictReport, scanHarnessConflicts } from '../core/harness-conflicts.js';
-import { doctorArgWarnings as baseDoctorArgWarnings, doctorMenuBarInstallPolicy, doctorPhaseIdsForProfile, doctorProfileFromArgs } from './doctor-profile.js';
-export { doctorMenuBarInstallPolicy, doctorProfileFromArgs } from './doctor-profile.js';
-const CODEX_LB_KEYCHAIN_MIGRATION_RETRY_FLAG = '--retry-codex-lb-keychain-migration';
+import { doctorArgWarnings as baseDoctorArgWarnings, doctorMenuBarInstallPolicy, doctorPhaseIdsForProfile, doctorProfileFromArgs, doctorProfileRequiresDesktopBridgeReadiness } from './doctor-profile.js';
+import { buildCodexAppUiDiagnosticFailure, buildRuntimeReadiness, captureCodexConfigSnapshot, deferredNativeRepair, doctorDedupeStatus, doctorSkillStatus, fallbackCodexNativeFeatureMatrix, formatCodexDoctorConsoleStatus, installScopeFromArgs, isMigrationUserOwnedProjectConfigBlocker, mergeObservedCodexStartupWarnings, nativeCapabilityStatus, readOption, rebootstrapSksMenuBarLaunchdForDoctorFix, sksMenuBarRunningVersionConsoleLines, uniqueNativeManualActions, writeFixMigrationJournal, writeJsonReportFile } from './doctor-helpers.js';
+export { doctorMenuBarInstallPolicy, doctorProfileFromArgs, doctorProfileRequiresDesktopBridgeReadiness } from './doctor-profile.js';
+export { buildCodexAppUiDiagnosticFailure, buildRuntimeReadiness, formatCodexDoctorConsoleStatus, rebootstrapSksMenuBarLaunchdForDoctorFix, sksMenuBarRunningVersionConsoleLines };
 export function doctorArgWarnings(args = []) {
-    return baseDoctorArgWarnings(args.filter((arg) => arg !== CODEX_LB_KEYCHAIN_MIGRATION_RETRY_FLAG));
+    return baseDoctorArgWarnings(args);
 }
 export function deferCommandAliasCleanupToMigrationReceipt(result) {
     const observedBlockers = Array.isArray(result?.blockers)
@@ -67,195 +58,50 @@ export function deferCommandAliasCleanupToMigrationReceipt(result) {
         ]
     };
 }
-export async function inspectDoctorCodexLbSecretResolution(input = {}, deps = {}) {
+export async function inspectDoctorDesktopBridgeStatus(input = {}, deps = {}) {
     const processEnv = input.processEnv || process.env;
     const home = path.resolve(input.home || processEnv.HOME || os.homedir());
-    const suppliedMigrationOptions = input.migrationOptions || {};
-    const migrationOptions = {
-        ...suppliedMigrationOptions,
-        home,
-        env: suppliedMigrationOptions.env || processEnv,
-        processEnv: suppliedMigrationOptions.processEnv || processEnv,
-        ...(input.baseUrl ? { baseUrl: input.baseUrl } : {}),
-        ...(input.forceRetry === true ? { forceRetry: true } : {})
-    };
-    if (processEnv.SKS_TEST_FORBID_REAL_HOME === '1' && suppliedMigrationOptions.platform === undefined) {
-        migrationOptions.platform = 'linux';
-    }
-    const mode = input.fix === true ? 'repair' : 'inspect';
-    const reconcile = mode === 'repair'
-        ? deps.repairImpl || repairCodexLbLegacyKeychainMigration
-        : deps.inspectImpl || inspectCodexLbLegacyKeychainMigration;
-    let migration;
-    try {
-        migration = await reconcile(migrationOptions);
-    }
-    catch (error) {
-        migration = {
-            schema: 'sks.codex-lb-legacy-keychain-reconciliation.v1',
-            ok: false,
-            status: `${mode}_failed`,
-            mode,
-            env_key_valid: false,
-            keychain_item_present: null,
-            prompt_risk: 'none',
-            attempted: false,
-            stamp_path: codexLbLegacyKeychainMigrationStampPath(home),
-            stamp_outcome: null,
-            keychain_deleted: false,
-            keychain_cleared: [],
-            blockers: [`codex_lb_legacy_keychain_${mode}_failed:${error instanceof Error ? error.message : String(error)}`]
-        };
-    }
-    const envPath = String(suppliedMigrationOptions.envPath || codexLbEnvPath(home));
-    let loaded = null;
-    let resolutionError = null;
     try {
-        loaded = await (deps.loadEnvImpl || loadCodexLbEnv)({
+        const status = await (deps.desktopBridgeStatusImpl || desktopBridgeStatusV3)({
             home,
-            processEnv,
-            envPath,
-            ...(suppliedMigrationOptions.metadataPath ? { metadataPath: suppliedMigrationOptions.metadataPath } : {})
+            env: processEnv
         });
+        if (!status || typeof status !== 'object' || !status.providers || !status.readiness) {
+            throw new Error('invalid Desktop Bridge status response');
+        }
+        const enabledProviders = Object.values(status.providers)
+            .filter((provider) => provider?.enabled === true);
+        const expected = enabledProviders.length > 0;
+        const blockers = expected && status.readiness.ready !== true
+            ? (status.readiness.blockers || []).map(String).filter(Boolean)
+            : [];
+        return {
+            schema: 'sks.doctor-desktop-bridge.v1',
+            ok: blockers.length === 0,
+            read_only: true,
+            credentials_mutated: false,
+            managed: status.management?.managed === true,
+            status,
+            providers: status.providers,
+            blockers,
+            warnings: (status.readiness.warnings || []).map(String).filter(Boolean),
+            recovery_actions: (status.recovery_actions || []).map(String).filter(Boolean)
+        };
     }
     catch (error) {
-        resolutionError = error instanceof Error ? error.message : String(error);
-    }
-    const source = String(loaded?.source || 'missing');
-    const unsafeEnvFile = Array.isArray(loaded?.blockers)
-        && loaded.blockers.some((blocker) => String(blocker).startsWith('codex_lb_env_file_'));
-    const resolutionPath = source === 'env-file' || unsafeEnvFile
-        ? String(loaded?.env_paths?.[0] || envPath)
-        : null;
-    const operatorActions = [];
-    if (mode === 'inspect' && migration.prompt_risk === 'one_time_on_repair') {
-        operatorActions.push('Run `sks doctor --fix` to perform the one-time legacy Keychain transfer.');
-    }
-    if (mode === 'repair'
-        && migration.ok === false
-        && (migration.attempted === true || migration.status === 'already_attempted')) {
-        operatorActions.push(`Run \`sks doctor --fix ${CODEX_LB_KEYCHAIN_MIGRATION_RETRY_FLAG}\` to explicitly retry the one-time Keychain transfer.`);
-    }
-    return {
-        ok: migration.ok !== false && resolutionError === null,
-        secret_resolution: {
-            source,
-            path: resolutionPath,
-            prompt_risk: migration.prompt_risk || 'none'
-        },
-        legacy_keychain_migration: {
-            ...migration,
-            operator_actions: operatorActions,
-            ...(resolutionError ? { resolution_error: resolutionError } : {})
-        }
-    };
-}
-export async function inspectDoctorCodexLbDivergence(input = {}, deps = {}) {
-    const processEnv = input.processEnv || process.env;
-    const home = path.resolve(input.home || processEnv.HOME || os.homedir());
-    const status = input.providerStatus || {};
-    const configPath = String(status.config_path || path.join(home, '.codex', 'config.toml'));
-    const configText = await (deps.readTextImpl || readText)(configPath, '');
-    const orphan = removeCodexLbOrphanManagedMarkers(configText);
-    let orphanRepair = {
-        schema: 'sks.codex-lb-orphan-managed-marker-repair.v1',
-        attempted: false,
-        changed: false,
-        markers: orphan.orphan_markers,
-        receipt: null
-    };
-    if (input.fix === true && orphan.changed) {
-        const write = deps.writeConfigImpl || safeWriteCodexConfigToml;
-        const receipt = await write(configPath, configText, orphan.text, 'doctor-codex-lb-orphan-marker');
-        orphanRepair = {
-            ...orphanRepair,
-            attempted: true,
-            changed: receipt?.ok !== false,
-            receipt
+        return {
+            schema: 'sks.doctor-desktop-bridge.v1',
+            ok: false,
+            read_only: true,
+            credentials_mutated: false,
+            managed: null,
+            status: null,
+            providers: null,
+            blockers: [`desktop_bridge_status_unavailable:${error instanceof Error ? error.message : String(error)}`],
+            warnings: [],
+            recovery_actions: ['Run `sks bridge status --json` to inspect Desktop Bridge provider readiness.']
         };
     }
-    const load = deps.loadEnvImpl || loadCodexLbEnv;
-    const canonical = await load({
-        home,
-        processEnv: {},
-        envPath: String(status.env_path || codexLbEnvPath(home))
-    }).catch(() => null);
-    const ambientKey = String(processEnv.CODEX_LB_API_KEY || '').trim();
-    const canonicalKey = String(canonical?.secret_api_key || '').trim();
-    const sha256 = (value) => value
-        ? createHash('sha256').update(value).digest('hex')
-        : null;
-    const ambientHash = sha256(ambientKey);
-    const canonicalHash = sha256(canonicalKey);
-    const staleAmbient = Boolean(ambientHash && canonicalHash && ambientHash !== canonicalHash);
-    const bridgeActive = status.desktop_mode === 'desktop-native-bridge';
-    const definedButNotSelected = status.provider_configured === true
-        && status.selected !== true
-        && !bridgeActive
-        && status.desktop_mode !== 'desktop-dual-auth-compat';
-    const mode = status.selected === true
-        ? 'cli-provider'
-        : bridgeActive
-            ? 'desktop-native-bridge'
-            : 'disabled';
-    const inspectLaunch = deps.inspectLaunchImpl || inspectDesktopCenterLaunchCredentials;
-    const syncLaunch = deps.syncLaunchImpl || syncDesktopCenterLaunchCredentials;
-    const launchOptions = {
-        mode,
-        home,
-        ...(input.launchctlBin ? { launchctlBin: input.launchctlBin } : {}),
-        ...(input.platform ? { platform: input.platform } : {}),
-        ...(input.forceLaunchctl ? { force: true } : {}),
-        ...(input.runProcessImpl ? { runProcessImpl: input.runProcessImpl } : {})
-    };
-    const launchBefore = await inspectLaunch(launchOptions);
-    const launchRepair = input.fix === true && launchBefore.ok === false
-        ? await syncLaunch({ ...launchOptions, skipPurge: true })
-        : null;
-    const launchAfter = launchRepair ? await inspectLaunch(launchOptions) : launchBefore;
-    const warnings = [
-        ...(definedButNotSelected
-            ? ['codex_lb_defined_but_not_selected']
-            : []),
-        ...(staleAmbient ? ['codex_lb_stale_ambient_key'] : []),
-        ...(orphan.orphan_markers.length > 0
-            ? [`codex_lb_orphan_managed_markers:${orphan.orphan_markers.join(',')}`]
-            : [])
-    ];
-    const blockers = [
-        ...(launchAfter.ok === false ? launchAfter.blockers || ['codex_lb_launchd_selection_state_mismatch'] : []),
-        ...(input.fix === true && orphan.changed && orphanRepair.changed !== true
-            ? ['codex_lb_orphan_marker_repair_failed']
-            : [])
-    ];
-    return {
-        schema: 'sks.doctor-codex-lb-divergence.v1',
-        ok: blockers.length === 0,
-        warnings,
-        blockers,
-        operator_actions: [
-            ...(definedButNotSelected
-                ? ['Run `sks codex-lb use-cli` to select the stored provider.']
-                : []),
-            ...(staleAmbient
-                ? ['Remove or update the stale shell export: `unset CODEX_LB_API_KEY`; the canonical key remains in ~/.codex/sks-codex-lb.env.']
-                : []),
-            ...(launchAfter.operator_actions || [])
-        ],
-        ambient_key: {
-            present: Boolean(ambientKey),
-            sha256: ambientHash,
-            matches_canonical: ambientHash && canonicalHash ? ambientHash === canonicalHash : null
-        },
-        canonical_key: {
-            present: Boolean(canonicalKey),
-            sha256: canonicalHash,
-            path: String(status.env_path || codexLbEnvPath(home))
-        },
-        orphan_markers: orphan.orphan_markers,
-        orphan_marker_repair: orphanRepair,
-        launchd: { before: launchBefore, repair: launchRepair, after: launchAfter }
-    };
 }
 export async function run(_command, args = [], deps = {}) {
     const root = await projectRoot();
@@ -319,50 +165,10 @@ 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 doctorEnv = deps.env || (deps.home
         ? { ...process.env, HOME: home }
         : process.env);
-    const statusOptions = {
-        home,
-        env: doctorEnv,
-        processEnv: doctorEnv
-    };
-    const preRepairProviderStatus = await codexLbStatusImpl({
-        ...statusOptions,
-        probeToolOutputRecovery: false
-    }).catch(() => null);
-    const codexLbSecretProbeImpl = deps.codexLbSecretProbeImpl || inspectDoctorCodexLbSecretResolution;
-    const codexLbSecretProbe = await codexLbSecretProbeImpl({
-        home,
-        processEnv: doctorEnv,
-        fix: true,
-        forceRetry: flag(args, CODEX_LB_KEYCHAIN_MIGRATION_RETRY_FLAG),
-        baseUrl: preRepairProviderStatus?.base_url || preRepairProviderStatus?.provider_base_url || null,
-        migrationOptions: {
-            ...(deps.codexLbMigrationOptions || {}),
-            ...(!deps.codexLbMigrationOptions && deps.codexLbStatusImpl ? { platform: 'linux' } : {})
-        }
-    });
-    const providerStatus = await codexLbStatusImpl({
-        ...statusOptions,
-        probeToolOutputRecovery: true,
-        allowUnverifiedToolOutputRecovery: codexLbToolOutputRecoveryOverrideAcknowledged({ args })
-    }).catch((err) => ({
-        selected: null,
-        provider_ready: false,
-        recovery_probe_failed: true,
-        tool_output_recovery: {
-            ok: false,
-            status: 'probe_failed',
-            blockers: ['codex_lb_tool_output_recovery_status_probe_failed'],
-            operator_actions: []
-        },
-        error: err?.message || String(err)
-    }));
     const globalSkills = await reconcileSkillsImpl({
         targetDir: path.join(home, '.agents', 'skills'),
         scope: 'global',
@@ -388,18 +194,6 @@ export async function executeDoctorGlobalOnlyFix(args = [], root, deps = {}) {
         status: 'failed',
         error: err?.message || String(err)
     }));
-    const openRouterEnv = {
-        ...doctorEnv,
-        HOME: home,
-        SKS_HOME: path.join(home, '.sneakoscope')
-    };
-    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,
@@ -414,18 +208,10 @@ export async function executeDoctorGlobalOnlyFix(args = [], root, deps = {}) {
         blockers: [err?.message || String(err)],
         warnings: []
     }));
-    const codexLbRoutingTruth = await codexLbRoutingTruthForStatus(providerStatus, { home, remeasure: true });
-    const codexLbRoutingReady = !doctorCodexLbRouteExpected(providerStatus)
-        || codexLbRoutingTruthIsActive(codexLbRoutingTruth);
-    const codexLbDivergence = await inspectDoctorCodexLbDivergence({
+    const desktopBridge = await inspectDoctorDesktopBridgeStatus({
         home,
-        processEnv: doctorEnv,
-        providerStatus,
-        fix: true,
-        ...(deps.codexLbLaunchctlBin ? { launchctlBin: deps.codexLbLaunchctlBin } : {}),
-        ...(deps.codexLbLaunchPlatform ? { platform: deps.codexLbLaunchPlatform } : {}),
-        ...(deps.codexLbLaunchRunProcessImpl ? { runProcessImpl: deps.codexLbLaunchRunProcessImpl } : {})
-    }, deps.codexLbDivergenceDeps || {});
+        processEnv: doctorEnv
+    }, { desktopBridgeStatusImpl: deps.desktopBridgeStatusImpl });
     const telegramRemote = await inspectTelegramRemote({
         live: true,
         fix: true,
@@ -433,26 +219,20 @@ export async function executeDoctorGlobalOnlyFix(args = [], root, deps = {}) {
         home,
         env: doctorEnv
     }, deps);
-    const recoveryReady = codexLbRecoveryStatusReady(providerStatus, true);
     const globalSkillsReady = !globalSkills?.error
         && globalSkills?.ok !== false
         && globalSkills?.core_skill_integrity?.ok !== false;
     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']) : []),
-            ...(codexLbSecretProbe.ok === false
-                ? (codexLbSecretProbe.legacy_keychain_migration?.blockers || ['codex_lb_secret_resolution_failed'])
-                : []),
-            ...(!recoveryReady ? (providerStatus?.tool_output_recovery?.blockers || ['codex_lb_tool_output_recovery_unverified']) : []),
-            ...(!codexLbRoutingReady ? (codexLbRoutingTruth?.blockers || ['codex_lb_routing_truth_unverified']) : []),
-            ...(codexLbDivergence.blockers || [])
+            ...(desktopBridge.ok === false
+                ? (desktopBridge.blockers || ['desktop_bridge_unavailable'])
+                : [])
         ].map(String).filter(Boolean))];
     const ok = blockers.length === 0;
     return {
@@ -479,26 +259,14 @@ 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,
+        openrouter_provider: desktopBridge.providers?.openrouter || null,
         sks_menubar: menuBar,
         telegram_remote: telegramRemote,
-        codex_lb: {
-            provider_status: providerStatus,
-            tool_output_recovery: providerStatus?.tool_output_recovery || null,
-            recovery_ok: recoveryReady,
-            routing_truth: codexLbRoutingTruth,
-            routing_ok: codexLbRoutingReady,
-            secret_resolution: codexLbSecretProbe.secret_resolution,
-            legacy_keychain_migration: codexLbSecretProbe.legacy_keychain_migration,
-            divergence: codexLbDivergence
-        },
+        desktop_bridge: desktopBridge,
         blockers,
         next_actions: [
-            ...(recoveryReady ? [] : (providerStatus?.tool_output_recovery?.operator_actions || [])),
-            ...(codexLbSecretProbe.legacy_keychain_migration?.operator_actions || []),
-            ...(codexLbDivergence.operator_actions || []),
+            ...(desktopBridge.ok === false ? desktopBridge.recovery_actions || [] : []),
             ...telegramDoctorOperatorActions(telegramRemote),
-            ...(!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.'
         ]
     };
@@ -528,7 +296,7 @@ async function runDoctorGlobalOnlyFix(args = [], root, deps = {}) {
         const telegramCheckedLine = telegramDoctorCheckedLine(result.telegram_remote);
         if (telegramCheckedLine)
             console.log(telegramCheckedLine);
-        console.log(`codex-lb key: ${result.codex_lb.secret_resolution.source} (prompt risk ${result.codex_lb.secret_resolution.prompt_risk})`);
+        console.log(`Desktop Bridge: ${result.desktop_bridge.ok ? 'ready' : 'blocked'} (${result.desktop_bridge.status?.readiness?.state || 'unavailable'})`);
         for (const blocker of result.blockers)
             console.log(`- blocker: ${blocker}`);
         for (const action of result.next_actions)
@@ -538,107 +306,6 @@ async function runDoctorGlobalOnlyFix(args = [], root, deps = {}) {
         process.exitCode = 1;
     return result;
 }
-function codexLbRecoveryStatusReady(status, probeRequired = false) {
-    if (status == null)
-        return !probeRequired;
-    if (status.recovery_probe_failed === true || status.error)
-        return false;
-    if (status.selected === false)
-        return true;
-    if (!probeRequired)
-        return true;
-    return status.selected === true && status.tool_output_recovery?.ok === true;
-}
-export async function codexLbRoutingTruthForStatus(status, deps = {}) {
-    if (!status)
-        return null;
-    const statusEnvPath = typeof status.env_path === 'string' && status.env_path
-        ? status.env_path
-        : null;
-    const resolvedHome = deps.home
-        ? path.resolve(deps.home)
-        : statusEnvPath
-            ? path.dirname(path.dirname(statusEnvPath))
-            : undefined;
-    const envOptions = {
-        ...(resolvedHome ? { home: resolvedHome } : {}),
-        ...(statusEnvPath ? { envPath: statusEnvPath } : {})
-    };
-    const routeSelected = doctorCodexLbRouteExpected(status);
-    const mode = status.desktop_mode === 'desktop-native-bridge' ? 'bridge' : 'cli-provider';
-    const receiptOptions = {
-        ...(resolvedHome ? { home: resolvedHome } : {}),
-        ...(deps.receiptPath ? { receiptPath: deps.receiptPath } : {}),
-        expectedMode: mode,
-        expectedSelected: routeSelected
-    };
-    const receipt = await readCodexLbRoutingTruthReceipt(receiptOptions).catch(() => null);
-    if (deps.remeasure !== true && receipt?.fresh === true)
-        return receipt;
-    try {
-        const loaded = await loadCodexLbEnv({ ...envOptions, processEnv: {} });
-        const baseUrl = loaded.base_url || status.base_url || null;
-        const configuredHost = publicUrlHost(baseUrl);
-        const authTransport = mode === 'cli-provider'
-            ? 'authorization-bearer'
-            : doctorBridgeRoutingTransport(status, receipt);
-        const contextReceipt = await readCodexLbRoutingTruthReceipt({
-            ...receiptOptions,
-            expectedConfiguredHost: configuredHost,
-            expectedAuthTransport: authTransport
-        }).catch(() => null);
-        if (deps.remeasure !== true && contextReceipt?.fresh === true)
-            return contextReceipt;
-        return measureAndWriteCodexLbRoutingTruth({
-            mode,
-            selected: routeSelected,
-            baseUrl,
-            apiKey: loaded.secret_api_key,
-            authTransport,
-            measure: routeSelected,
-            ...(deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {})
-        }, {
-            ...envOptions,
-            ...(deps.receiptPath ? { receiptPath: deps.receiptPath } : {})
-        });
-    }
-    catch {
-        return measureAndWriteCodexLbRoutingTruth({
-            mode,
-            selected: routeSelected,
-            baseUrl: status.base_url || null,
-            apiKey: null,
-            authTransport: mode === 'cli-provider'
-                ? 'authorization-bearer'
-                : doctorBridgeRoutingTransport(status, receipt),
-            measure: false
-        }, {
-            ...envOptions,
-            ...(deps.receiptPath ? { receiptPath: deps.receiptPath } : {})
-        });
-    }
-}
-function doctorCodexLbRouteExpected(status) {
-    return status?.selected === true || status?.desktop_mode === 'desktop-native-bridge';
-}
-function doctorBridgeRoutingTransport(status, receipt) {
-    if (receipt?.mode === 'bridge'
-        && (receipt.auth_transport === 'authorization-bearer'
-            || receipt.auth_transport === 'x-codex-lb-api-key')) {
-        return receipt.auth_transport;
-    }
-    return status?.gateway_auth_transport === 'x-codex-lb-api-key'
-        ? 'x-codex-lb-api-key'
-        : 'authorization-bearer';
-}
-function publicUrlHost(value) {
-    try {
-        return value ? new URL(String(value)).host : null;
-    }
-    catch {
-        return null;
-    }
-}
 export async function inspectTelegramRemote(input = {}, deps = {}) {
     const env = input.env || process.env;
     const home = path.resolve(input.home || env.HOME || os.homedir());
@@ -752,7 +419,7 @@ async function runDoctorJsonFastPath(args = [], root) {
         requireActualCodex: false,
         codexBin: codexBin || undefined
     };
-    const [codex, rust, codexConfig, sneakoscopeExists, oauthCallbackPortDiagnostic, codexLbSecretProbe] = await Promise.all([
+    const [codex, rust, codexConfig, sneakoscopeExists, oauthCallbackPortDiagnostic, desktopBridge] = await Promise.all([
         codexBin
             ? Promise.resolve({ bin: codexBin, version: 'fixture-or-explicit', available: true })
             : getCodexInfo().catch(() => ({ bin: null, version: null, available: false })),
@@ -765,7 +432,7 @@ async function runDoctorJsonFastPath(args = [], root) {
         })),
         exists(`${root}/.sneakoscope`),
         inspectOAuthCallbackPortConflict(),
-        inspectDoctorCodexLbSecretResolution({ processEnv: process.env, fix: false })
+        inspectDoctorDesktopBridgeStatus({ processEnv: process.env })
     ]);
     const oauthCallbackOperatorActions = oauthCallbackDoctorGuidance(oauthCallbackPortDiagnostic);
     const telegramRemote = await inspectTelegramRemote();
@@ -794,18 +461,19 @@ async function runDoctorJsonFastPath(args = [], root) {
     const deferredBrowserUse = deferredNativeRepair('sks.doctor-browser-use-repair.v1', false, [
         'Chrome/web review route needs the Codex Chrome Extension enabled before use.'
     ]);
+    const desktopBridgeReady = desktopBridge.ok !== false;
     const result = {
         schema: 'sks.doctor-status.v3',
         elapsed_ms: Date.now() - startedAtMs,
-        ok: true,
-        status: 'fast_readonly_ok',
+        ok: desktopBridgeReady,
+        status: desktopBridgeReady ? 'fast_readonly_ok' : 'blocked',
         diagnostic_depth: 'fast',
         deep_diagnostics_skipped: true,
         deep_ok: null,
         not_counted_as_full_doctor: true,
         next_actions: [
             'Run sks doctor --full --json for deep diagnostics.',
-            ...(codexLbSecretProbe.legacy_keychain_migration?.operator_actions || []),
+            ...(desktopBridge.ok === false ? desktopBridge.recovery_actions || [] : []),
             ...telegramDoctorOperatorActions(telegramRemote)
         ],
         root,
@@ -815,7 +483,7 @@ async function runDoctorJsonFastPath(args = [], root) {
         warnings: [...oauthCallbackPortDiagnostic.warnings],
         operator_actions: [
             ...oauthCallbackOperatorActions,
-            ...(codexLbSecretProbe.legacy_keychain_migration?.operator_actions || [])
+            ...(desktopBridge.ok === false ? desktopBridge.recovery_actions || [] : [])
         ],
         node: { ok: Number(process.versions.node.split('.')[0]) >= 20, version: process.version },
         codex,
@@ -843,25 +511,28 @@ async function runDoctorJsonFastPath(args = [], root) {
         },
         telegram_remote: telegramRemote,
         provider_context: {
-            schema: 'sks.provider-context.v1',
+            schema: 'sks.provider-context.v2',
             generated_at: nowIso(),
             provider: 'unknown',
             auth_mode: 'unknown',
             route: '$Doctor',
             service_tier: process.env.SKS_SERVICE_TIER || 'fast',
-            source: 'skipped',
+            source: 'unknown',
             confidence: 'low',
             conflict: false,
             warnings: ['provider_context_optional_diagnostic_skipped'],
-            signals: {}
-        },
-        codex_lb: {
-            ...codexLbMetrics(await readCodexLbCircuit(root).catch(() => ({}))),
-            routing_truth: null,
-            routing_measurement_deferred: true,
-            secret_resolution: codexLbSecretProbe.secret_resolution,
-            legacy_keychain_migration: codexLbSecretProbe.legacy_keychain_migration
+            signals: {
+                openai_api_key_present: false,
+                codex_app_auth_present: false,
+                desktop_bridge_status_available: false,
+                desktop_bridge_managed: false,
+                desktop_bridge_ready: false,
+                desktop_bridge_provider: null,
+                desktop_bridge_native_identity_configured: false,
+                desktop_bridge_credential_state: null
+            }
         },
+        desktop_bridge: desktopBridge,
         codex_doctor: null,
         pre_repair_codex_doctor: null,
         post_repair_codex_doctor: null,
@@ -960,20 +631,15 @@ async function runDoctor(args = [], root, doctorFix, deps = {}) {
     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' };
+    const openRouterProviderRepair = {
+        ok: true,
+        status: 'read_only',
+        reason: 'Desktop Bridge owns provider credentials; Doctor does not migrate them.'
+    };
     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,
@@ -1105,59 +771,12 @@ async function runDoctor(args = [], root, doctorFix, deps = {}) {
     const codexApp = deepDiagnostics
         ? await codexAppIntegrationStatus({ codex }).catch((err) => ({ ok: false, error: err.message }))
         : { ok: false, skipped: true, warnings: ['codex_app_optional_diagnostic_skipped'] };
-    const codexLbCircuit = codexLbMetrics(await readCodexLbCircuit(root).catch(() => ({})));
-    const codexLbPreRepairStatus = doctorFix
-        ? await codexLbStatus({ probeToolOutputRecovery: false }).catch(() => null)
-        : null;
-    const codexLbSecretProbe = await inspectDoctorCodexLbSecretResolution({
-        processEnv: process.env,
-        fix: doctorFix,
-        forceRetry: flag(args, CODEX_LB_KEYCHAIN_MIGRATION_RETRY_FLAG),
-        baseUrl: codexLbPreRepairStatus?.base_url || codexLbPreRepairStatus?.provider_base_url || null
-    });
-    const codexLbProviderStatus = await codexLbStatus({
-        probeToolOutputRecovery: deepDiagnostics || doctorFix,
-        allowUnverifiedToolOutputRecovery: codexLbToolOutputRecoveryOverrideAcknowledged({ args })
-    }).catch((err) => ({
-        selected: null,
-        provider_ready: false,
-        recovery_probe_failed: deepDiagnostics || doctorFix,
-        tool_output_recovery: {
-            ok: false,
-            status: deepDiagnostics || doctorFix ? 'probe_failed' : 'not_checked',
-            blockers: deepDiagnostics || doctorFix ? ['codex_lb_tool_output_recovery_status_probe_failed'] : [],
-            operator_actions: []
-        },
-        error: err?.message || String(err)
-    }));
-    const codexLbRecoveryReady = codexLbRecoveryStatusReady(codexLbProviderStatus, deepDiagnostics || doctorFix);
-    const codexLbRoutingTruth = await codexLbRoutingTruthForStatus(codexLbProviderStatus, {
-        remeasure: deepDiagnostics || doctorFix
-    });
-    const codexLbRoutingReady = !doctorCodexLbRouteExpected(codexLbProviderStatus)
-        || codexLbRoutingTruthIsActive(codexLbRoutingTruth);
-    const codexLbDivergence = await inspectDoctorCodexLbDivergence({
-        processEnv: process.env,
-        providerStatus: codexLbProviderStatus,
-        fix: doctorFix,
-        ...(deps.codexLbLaunchctlBin ? { launchctlBin: deps.codexLbLaunchctlBin } : {}),
-        ...(deps.codexLbLaunchPlatform ? { platform: deps.codexLbLaunchPlatform } : {}),
-        ...(deps.codexLbLaunchRunProcessImpl ? { runProcessImpl: deps.codexLbLaunchRunProcessImpl } : {})
-    }, deps.codexLbDivergenceDeps || {});
-    const codexLb = {
-        ...codexLbCircuit,
-        provider_status: codexLbProviderStatus,
-        tool_output_recovery: codexLbProviderStatus?.tool_output_recovery || null,
-        recovery_ok: codexLbRecoveryReady,
-        routing_truth: codexLbRoutingTruth,
-        routing_ok: codexLbRoutingReady,
-        secret_resolution: codexLbSecretProbe.secret_resolution,
-        legacy_keychain_migration: codexLbSecretProbe.legacy_keychain_migration,
-        divergence: codexLbDivergence
-    };
+    const desktopBridge = await inspectDoctorDesktopBridgeStatus({
+        processEnv: process.env
+    }, { desktopBridgeStatusImpl: deps.desktopBridgeStatusImpl });
     const providerContext = deepDiagnostics
         ? await resolveProviderContext({ root, route: '$Doctor', serviceTier: process.env.SKS_SERVICE_TIER || 'fast' }).catch((err) => ({
-            schema: 'sks.provider-context.v1',
+            schema: 'sks.provider-context.v2',
             generated_at: new Date().toISOString(),
             provider: 'unknown',
             auth_mode: 'unknown',
@@ -1169,29 +788,35 @@ async function runDoctor(args = [], root, doctorFix, deps = {}) {
             warnings: [err?.message || String(err)],
             signals: {
                 openai_api_key_present: false,
-                codex_lb_key_present: false,
-                codex_lb_explicit: false,
                 codex_app_auth_present: false,
-                model_provider: null
+                desktop_bridge_status_available: false,
+                desktop_bridge_managed: false,
+                desktop_bridge_ready: false,
+                desktop_bridge_provider: null,
+                desktop_bridge_native_identity_configured: false,
+                desktop_bridge_credential_state: null
             }
         }))
         : {
-            schema: 'sks.provider-context.v1',
+            schema: 'sks.provider-context.v2',
             generated_at: new Date().toISOString(),
             provider: 'unknown',
             auth_mode: 'unknown',
             route: '$Doctor',
             service_tier: process.env.SKS_SERVICE_TIER || 'fast',
-            source: 'skipped',
+            source: 'unknown',
             confidence: 'low',
             conflict: false,
             warnings: ['provider_context_optional_diagnostic_skipped'],
             signals: {
                 openai_api_key_present: false,
-                codex_lb_key_present: false,
-                codex_lb_explicit: false,
                 codex_app_auth_present: false,
-                model_provider: null
+                desktop_bridge_status_available: false,
+                desktop_bridge_managed: false,
+                desktop_bridge_ready: false,
+                desktop_bridge_provider: null,
+                desktop_bridge_native_identity_configured: false,
+                desktop_bridge_credential_state: null
             }
         };
     const explicitCodexAppUiRepair = flag(args, '--repair-codex-app-ui');
@@ -1252,7 +877,6 @@ async function runDoctor(args = [], root, doctorFix, deps = {}) {
             'Run: sks menubar status',
             'Run: sks menubar install',
             'Run: sks menubar restart',
-            'Rotate CODEX_LB_API_KEY and OPENROUTER_API_KEY if they were previously exposed in launchd.'
         ],
         blockers: [err?.message || String(err)],
         warnings: []
@@ -1750,7 +1374,7 @@ async function runDoctor(args = [], root, doctorFix, deps = {}) {
         codex,
         codex_config: codexConfig,
         codex_app: codexApp,
-        codex_lb: codexLb,
+        desktop_bridge: desktopBridge,
         codex_doctor: authoritativeCodexDoctor,
         pre_repair_codex_doctor: preRepairCodexDoctor,
         post_repair_codex_doctor: postRepairCodexDoctor,
@@ -1786,7 +1410,7 @@ async function runDoctor(args = [], root, doctorFix, deps = {}) {
             ...(codexStartupRepair.manual_actions || []),
             ...(codexConfigSyntaxRepair?.manual_actions || []),
             ...(pluginPolicy?.doctor_warnings || []),
-            ...(codexLbSecretProbe.legacy_keychain_migration?.operator_actions || []),
+            ...(desktopBridge.ok === false ? desktopBridge.recovery_actions || [] : []),
             ...telegramDoctorOperatorActions(telegramRemote)
         ]
     };
@@ -1874,10 +1498,7 @@ async function runDoctor(args = [], root, doctorFix, deps = {}) {
         && agentRoleConfigRepair.ok !== false
         && openRouterProviderRepair.ok !== false
         && (officialSubagentConfig.blockers || []).length === 0
-        && codexLbSecretProbe.ok !== false
-        && codexLbDivergence.ok !== false
-        && codexLbRecoveryReady
-        && codexLbRoutingReady;
+        && (!doctorProfileRequiresDesktopBridgeReadiness(doctorProfile) || desktopBridge.ok !== false);
     const result = {
         schema: 'sks.doctor-status.v3',
         elapsed_ms: Date.now() - startedAtMs,
@@ -1892,11 +1513,10 @@ async function runDoctor(args = [], root, doctorFix, deps = {}) {
         not_counted_as_full_doctor: !deepDiagnostics,
         root,
         arg_warnings: argWarnings,
-        warnings: [...oauthCallbackPortDiagnostic.warnings, ...(codexLbDivergence.warnings || [])],
+        warnings: [...oauthCallbackPortDiagnostic.warnings, ...(desktopBridge.warnings || [])],
         operator_actions: [
             ...oauthCallbackOperatorActions,
-            ...(codexLbSecretProbe.legacy_keychain_migration?.operator_actions || []),
-            ...(codexLbDivergence.operator_actions || [])
+            ...(desktopBridge.ok === false ? desktopBridge.recovery_actions || [] : [])
         ],
         node: { ok: Number(process.versions.node.split('.')[0]) >= 20, version: process.version },
         codex,
@@ -1905,11 +1525,11 @@ async function runDoctor(args = [], root, doctorFix, deps = {}) {
         rust,
         codex_app: codexApp,
         codex_app_ui: codexAppUi,
-        openrouter_provider: openRouterProviderRepair,
+        openrouter_provider: desktopBridge.providers?.openrouter || null,
         sks_menubar: sksMenuBar,
         telegram_remote: telegramRemote,
         provider_context: providerContext,
-        codex_lb: codexLb,
+        desktop_bridge: desktopBridge,
         codex_doctor: authoritativeCodexDoctor,
         pre_repair_codex_doctor: preRepairCodexDoctor,
         post_repair_codex_doctor: postRepairCodexDoctor,
@@ -2188,25 +1808,20 @@ async function runDoctor(args = [], root, doctorFix, deps = {}) {
         console.log(`  warning: ${warning}`);
     if (codexCurrentAppDoctor?.fixed?.length)
         console.log(`  doctor --fix repaired: ${codexCurrentAppDoctor.fixed.join(', ')}`);
-    console.log(`codex-lb:  ${codexLb.ok ? 'ok' : `warning ${codexLb.circuit?.state || 'unknown'}`}`);
-    console.log(`  key source: ${codexLb.secret_resolution.source}${codexLb.secret_resolution.path ? ` (${codexLb.secret_resolution.path})` : ''}; prompt risk: ${codexLb.secret_resolution.prompt_risk}`);
-    for (const action of codexLb.legacy_keychain_migration?.operator_actions || [])
-        console.log(`  action: ${action}`);
-    for (const warning of codexLb.divergence?.warnings || [])
+    console.log(`Desktop Bridge: ${desktopBridge.ok ? 'ready' : 'blocked'} (${desktopBridge.status?.readiness?.state || 'unavailable'})`);
+    for (const providerId of ['codex-lb', 'openrouter']) {
+        const provider = desktopBridge.providers?.[providerId];
+        if (!provider)
+            continue;
+        console.log(`  ${providerId}: ${provider.enabled ? 'enabled' : 'disabled'}; credential ${provider.credential?.state || 'unknown'} (${provider.credential?.source || 'none'}); endpoint ${provider.endpoint?.configured ? 'configured' : 'missing'}`);
+    }
+    for (const warning of desktopBridge.warnings || [])
         console.log(`  warning: ${warning}`);
-    for (const action of codexLb.divergence?.operator_actions || [])
-        console.log(`  action: ${action}`);
-    if (codexLb.routing_truth) {
-        const routingTruth = codexLb.routing_truth;
-        console.log(`  routing truth: ${codexLb.routing_ok ? 'verified' : 'blocked'} (${routingTruth.actual_host || routingTruth.configured_host || 'host unavailable'}, ${routingTruth.auth_outcome}, ${routingTruth.latency_ms ?? 'unmeasured'} ms at ${routingTruth.checked_at})`);
-    }
-    if (codexLb.tool_output_recovery) {
-        const recovery = codexLb.tool_output_recovery;
-        console.log(`  interrupted tool-output recovery: ${recovery.ok ? 'ready' : 'blocked'} (${recovery.observed_version || recovery.status}; minimum ${recovery.minimum_version})`);
-        if (!recovery.ok)
-            for (const action of recovery.operator_actions || [])
-                console.log(`  action: ${action}`);
-    }
+    for (const blocker of desktopBridge.blockers || [])
+        console.log(`  blocker: ${blocker}`);
+    if (!desktopBridge.ok)
+        for (const action of desktopBridge.recovery_actions || [])
+            console.log(`  action: ${action}`);
     if (localModel) {
         console.log('Local LLM:');
         console.log(`  enabled: ${localModel.enabled ? 'yes' : 'no'}`);
@@ -2253,377 +1868,3 @@ async function runDoctor(args = [], root, doctorFix, deps = {}) {
     if (!result.ok)
         process.exitCode = 1;
 }
-export function buildRuntimeReadiness(matrix) {
-    const defaults = matrix?.invocation_defaults || {};
-    const hookPolicy = defaults.hook_evidence_policy || 'unknown-do-not-count';
-    const agentStrategy = defaults.loop_worker_role_strategy || 'message-role';
-    const multiAgentMode = defaults.multi_agent_mode || 'none';
-    const rolloutBudget = defaults.rollout_budget_strategy || 'sks-local-only';
-    const researchSource = defaults.research_source_strategy || 'local-files';
-    const codexNative = matrix?.ok === true ? 'ok' : matrix?.codex_cli?.available ? 'degraded' : 'blocked';
-    const repairActions = [];
-    if (codexNative !== 'ok') {
-        repairActions.push([
-            'Codex Native managed assets: sks doctor',
-            '--fix',
-            '--repair-codex-native',
-            '--yes'
-        ].join(' '));
-    }
-    if (matrix?.features?.project_memory?.ok !== true)
-        repairActions.push('Project memory: sks codex-native init-deep --apply --directory-local');
-    return {
-        schema: 'sks.runtime-readiness-story.v1',
-        codex_native: codexNative,
-        loop_mesh: agentStrategy === 'agent_type' ? 'ok' : 'fallback',
-        qa_visual: defaults.qa_visual_review_strategy || 'blocked',
-        research_sources: researchSource,
-        image_followup: defaults.image_followup_strategy || 'blocked',
-        hook_evidence_policy: hookPolicy,
-        agent_role_strategy: agentStrategy,
-        multi_agent_mode: multiAgentMode,
-        rollout_budget_strategy: rolloutBudget,
-        current_time_source: defaults.current_time_source || 'external-clock',
-        overload_retry_policy: defaults.overload_retry_policy || 'generic',
-        notes: [
-            ...(hookPolicy !== 'approved-only' ? ['hook-derived evidence will not count'] : []),
-            ...(agentStrategy !== 'agent_type' ? ['message-role fallback active'] : []),
-            ...(multiAgentMode === 'proactive' ? ['Proactive multi-agent mode is available for Naruto-style routes'] : []),
-            ...(rolloutBudget === 'codex-current-shared' ? ['Shared rollout budgeting is available for route proof'] : []),
-            ...(researchSource === 'indexed-web-search' ? ['Indexed web search is selected for source-intelligence routes'] : [])
-        ],
-        repair_actions: [...new Set(repairActions)]
-    };
-}
-function deferredNativeRepair(schema, doctorFix, nextActions) {
-    return {
-        schema,
-        generated_at: nowIso(),
-        ok: true,
-        skipped: true,
-        status: 'deferred_to_explicit_native_capability_probe',
-        attempted: false,
-        apply: doctorFix,
-        recovered: false,
-        blockers: [],
-        next_actions: nextActions,
-        manual_actions: nextActions
-    };
-}
-function fallbackCodexNativeFeatureMatrix(codex, blockers = [], warnings = []) {
-    return {
-        schema: 'sks.codex-native-feature-matrix.v1',
-        ok: blockers.length === 0,
-        skipped: blockers.length === 0,
-        codex_cli: { available: Boolean(codex?.bin || codex?.available), version: codex?.version || null, bin: codex?.bin || null },
-        features: {},
-        invocation_defaults: {
-            loop_worker_role_strategy: 'message-role',
-            multi_agent_mode: 'none',
-            rollout_budget_strategy: 'sks-local-only',
-            qa_visual_review_strategy: 'route-gated',
-            research_source_strategy: 'local-files',
-            image_followup_strategy: 'artifact-path',
-            hook_evidence_policy: 'unknown-do-not-count',
-            skill_bridge_strategy: 'cli-only',
-            current_time_source: 'external-clock',
-            overload_retry_policy: 'generic'
-        },
-        blockers,
-        warnings
-    };
-}
-async function writeJsonReportFile(file, value) {
-    const fsp = await import('node:fs/promises');
-    const path = await import('node:path');
-    await fsp.mkdir(path.dirname(file), { recursive: true });
-    await fsp.writeFile(file, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
-}
-function nativeCapabilityStatus(rows, id, fallback) {
-    const row = rows.find((entry) => entry?.id === id);
-    if (!row)
-        return fallback;
-    if (row.after === 'verified' || row.before === 'verified')
-        return 'verified';
-    if (id === 'image_path_exposure') {
-        if (row.before === 'degraded' || row.after === 'degraded' || row.repairability === 'doctor-fix')
-            return 'fallback';
-        return fallback;
-    }
-    if (id === 'app_handoff')
-        return 'unavailable';
-    if (row.repairability === 'manual-required')
-        return 'manual_required';
-    if (row.before === 'degraded' || row.after === 'degraded')
-        return 'degraded';
-    if (row.repairability === 'doctor-fix')
-        return row.after === 'blocked' ? 'blocked' : 'repair_required';
-    if (row.repairability === 'unavailable')
-        return 'unavailable';
-    return fallback;
-}
-function uniqueNativeManualActions(rows) {
-    return [...new Set(rows
-            .filter((row) => row?.repairability === 'manual-required' && row?.after !== 'verified')
-            .flatMap((row) => Array.isArray(row.repair_actions) ? row.repair_actions : [])
-            .filter((action) => typeof action === 'string' && action.trim()))];
-}
-function doctorSkillStatus(coreSkills) {
-    if (!coreSkills)
-        return 'drift_detected';
-    if (Array.isArray(coreSkills.restored) && coreSkills.restored.length)
-        return 'repaired';
-    if (Array.isArray(coreSkills.blockers) && coreSkills.blockers.length)
-        return 'drift_detected';
-    return 'current';
-}
-function doctorDedupeStatus(skillDedupe) {
-    if (!skillDedupe)
-        return 'manual_required';
-    if (Array.isArray(skillDedupe.actions) && skillDedupe.actions.some((action) => action.action === 'quarantined'))
-        return 'repaired';
-    if (Array.isArray(skillDedupe.blockers) && skillDedupe.blockers.length)
-        return 'manual_required';
-    return 'none';
-}
-async function codexHomeConfigPath() {
-    const path = await import('node:path');
-    const os = await import('node:os');
-    const home = process.env.CODEX_HOME || path.join(process.env.HOME || os.homedir(), '.codex');
-    return path.join(home, 'config.toml');
-}
-async function captureCodexConfigSnapshot() {
-    const fsp = await import('node:fs/promises');
-    const path = await import('node:path');
-    const read = async (p) => {
-        if (!p)
-            return null;
-        try {
-            return await fsp.readFile(p, 'utf8');
-        }
-        catch {
-            return null;
-        }
-    };
-    const root = await projectRoot();
-    const projectPath = root ? path.join(root, '.codex', 'config.toml') : null;
-    const homePath = await codexHomeConfigPath();
-    return {
-        project_path: projectPath,
-        project_text: await read(projectPath),
-        home_path: homePath,
-        home_text: await read(homePath)
-    };
-}
-async function writeFixMigrationJournal(root, preFix, configRepair, setupRepair) {
-    if (!preFix)
-        return null;
-    const fsp = await import('node:fs/promises');
-    const read = async (p) => {
-        if (!p)
-            return null;
-        try {
-            return await fsp.readFile(p, 'utf8');
-        }
-        catch {
-            return null;
-        }
-    };
-    const projectAfter = await read(preFix.project_path);
-    const homeAfter = await read(preFix.home_path);
-    const structureRepairs = Array.isArray(configRepair?.structure_repairs) ? configRepair.structure_repairs : [];
-    const projectStructure = structureRepairs.find((repair) => repair.scope === 'project');
-    const homeStructure = structureRepairs.find((repair) => repair.scope === 'codex_home');
-    const events = [
-        {
-            step: 'doctor_fix_project_config',
-            target: preFix.project_path || '.codex/config.toml',
-            beforeHash: preFix.project_text != null ? hashConfigText(preFix.project_text) : null,
-            afterHash: projectAfter != null ? hashConfigText(projectAfter) : null,
-            backupPath: setupRepair?.config_backup_path || projectStructure?.backup_path || configRepair?.policy?.backup_path || null
-        },
-        {
-            step: 'doctor_fix_codex_home_config',
-            target: preFix.home_path || '~/.codex/config.toml',
-            beforeHash: preFix.home_text != null ? hashConfigText(preFix.home_text) : null,
-            afterHash: homeAfter != null ? hashConfigText(homeAfter) : null,
-            backupPath: homeStructure?.backup_path || null
-        }
-    ].filter((event) => event.beforeHash != null || event.afterHash != null);
-    if (!events.length)
-        return null;
-    return appendMigrationEvents(root, events);
-}
-async function backupProjectConfigBeforeFix() {
-    try {
-        const fsp = await import('node:fs/promises');
-        const path = await import('node:path');
-        const root = await projectRoot();
-        if (!root)
-            return null;
-        const configPath = path.join(root, '.codex', 'config.toml');
-        if (!(await exists(configPath)))
-            return null;
-        const text = await fsp.readFile(configPath, 'utf8');
-        const backupPath = `${configPath}.doctor-pre-fix-${Date.now().toString(36)}.bak`;
-        await fsp.writeFile(backupPath, text);
-        return backupPath;
-    }
-    catch {
-        return null;
-    }
-}
-function installScopeFromArgs(args = []) {
-    if (flag(args, '--project'))
-        return 'project';
-    if (flag(args, '--global'))
-        return 'global';
-    const index = args.indexOf('--install-scope');
-    return normalizeInstallScope(index >= 0 && args[index + 1] ? args[index + 1] : 'global');
-}
-function isMigrationUserOwnedProjectConfigBlocker(blocker) {
-    const value = String(blocker || '').trim();
-    return value === 'user_owned_file_without_sks_marker'
-        || value.endsWith(':user_owned_file_without_sks_marker')
-        || value === 'config_write_guard:blocked_unmanaged_project_config'
-        || value.endsWith(':config_write_guard:blocked_unmanaged_project_config');
-}
-function readOption(args = [], name, fallback = null) {
-    const index = args.indexOf(name);
-    return index >= 0 && args[index + 1] ? args[index + 1] : fallback;
-}
-export function buildCodexAppUiDiagnosticFailure(apply, error) {
-    return {
-        schema: 'sks.codex-app-fast-ui-repair.v1',
-        ok: false,
-        apply,
-        safe_auto_apply: false,
-        requires_confirmation: true,
-        fast_selector: 'manual_action_required',
-        provider_selector: 'manual_action_required',
-        host_owned_config: 'diagnostic_failed',
-        next_action: 'Review Codex App UI config manually.',
-        actions: [],
-        blockers: [error instanceof Error ? error.message : String(error)]
-    };
-}
-export function formatCodexDoctorConsoleStatus(report) {
-    if (!report || report.available !== true)
-        return 'unavailable';
-    return report.disposition || (report.exit_code === 0 ? 'pass' : 'warn');
-}
-export function sksMenuBarRunningVersionConsoleLines(status) {
-    const runningVersion = status?.running_process?.package_version
-        || status?.menubar_version_probe?.running_version
-        || null;
-    const runningPid = status?.running_process?.pid ?? status?.menubar_version_probe?.pid ?? null;
-    if (typeof runningVersion !== 'string' || !runningVersion || !Number.isInteger(runningPid) || runningPid <= 0) {
-        return [];
-    }
-    const expectedVersion = status?.menubar_version_probe?.expected_version
-        || status?.action_target?.expected_version
-        || status?.package_version
-        || null;
-    const installedVersion = status?.installed_version || status?.build_stamp?.package_version || null;
-    return [
-        `  RUNNING: version ${runningVersion} (PID ${runningPid})`,
-        ...(typeof expectedVersion === 'string' && expectedVersion && expectedVersion !== runningVersion
-            ? [`  expected: version ${expectedVersion}`]
-            : []),
-        ...(typeof installedVersion === 'string' && installedVersion && installedVersion !== runningVersion
-            ? [`  installed: version ${installedVersion}`]
-            : [])
-    ];
-}
-export async function rebootstrapSksMenuBarLaunchdForDoctorFix(input, deps = {}) {
-    const env = input.env || process.env;
-    const status = input.status;
-    const expectedVersion = status?.menubar_version_probe?.expected_version
-        || status?.action_target?.expected_version
-        || status?.installed_version
-        || null;
-    const warningOnlyVerifiedProcess = input.fix
-        && !sksMenuBarRestartDeferred(env)
-        && status?.launchd?.checked === true
-        && status?.launchd?.ok === false
-        && Array.isArray(status?.warnings)
-        && status.warnings.includes('launchd_not_running_process_active')
-        && !(Array.isArray(status?.blockers) && status.blockers.includes('launchd_not_running'))
-        && status?.running_process?.ok === true
-        && typeof expectedVersion === 'string'
-        && status.running_process.package_version === expectedVersion;
-    if (!warningOnlyVerifiedProcess) {
-        return { attempted: false, ok: true, status, restart: null };
-    }
-    const paths = sksMenuBarPaths(input.home || env.HOME, input.root);
-    const restartImpl = deps.restartLaunchAgentImpl || restartLaunchAgent;
-    const inspectImpl = deps.inspectSksMenuBarStatusImpl || inspectSksMenuBarStatus;
-    const restart = await restartImpl(paths, env).catch((error) => ({
-        ok: false,
-        error: error instanceof Error ? error.message : String(error)
-    }));
-    if (restart?.ok !== true) {
-        const detail = restart?.error ? `:${restart.error}` : '';
-        return {
-            attempted: true,
-            ok: false,
-            restart,
-            status: {
-                ...status,
-                ok: false,
-                blockers: [...new Set([...(status?.blockers || []), `launchd_rebootstrap_failed${detail}`])]
-            }
-        };
-    }
-    const refreshed = await inspectImpl({
-        root: input.root,
-        ...(input.home ? { home: input.home } : {}),
-        ...(input.env ? { env: input.env } : {})
-    }).catch((error) => ({
-        ...status,
-        ok: false,
-        blockers: [...new Set([
-                ...(status?.blockers || []),
-                `launchd_rebootstrap_status_failed:${error instanceof Error ? error.message : String(error)}`
-            ])]
-    }));
-    if (refreshed?.launchd?.checked !== true || refreshed?.launchd?.ok !== true) {
-        return {
-            attempted: true,
-            ok: false,
-            restart,
-            status: {
-                ...refreshed,
-                ok: false,
-                blockers: [...new Set([...(refreshed?.blockers || []), 'launchd_rebootstrap_not_confirmed'])]
-            }
-        };
-    }
-    return { attempted: true, ok: true, status: refreshed, restart };
-}
-function mergeObservedCodexStartupWarnings(startupRepair, codexDoctor) {
-    const text = `${codexDoctor?.stdout_tail || ''}\n${codexDoctor?.stderr_tail || ''}`;
-    const manual = new Set(Array.isArray(startupRepair?.manual_actions) ? startupRepair.manual_actions : []);
-    const warnings = new Set(Array.isArray(startupRepair?.warnings) ? startupRepair.warnings : []);
-    const blockers = new Set(Array.isArray(startupRepair?.blockers) ? startupRepair.blockers : []);
-    if (/codex_apps[\s\S]{0,500}token_expired|token_expired[\s\S]{0,500}codex_apps/i.test(text)) {
-        manual.add('Codex Apps MCP token is expired; sign in to Codex App/CLI again so the connector can mint a fresh token.');
-        warnings.add('codex_apps_token_expired_observed');
-        blockers.add('codex_apps_token_expired_manual_reauth_required');
-    }
-    if (/SUPABASE_ACCESS_TOKEN[\s\S]{0,500}mcp server ['"`]?supabase['"`]?|mcp server ['"`]?supabase['"`]?[\s\S]{0,500}SUPABASE_ACCESS_TOKEN/i.test(text)) {
-        manual.add('Supabase MCP uses SUPABASE_ACCESS_TOKEN but the variable is unset; export the token or migrate that server to a read-only remote URL.');
-        warnings.add('supabase_access_token_missing_observed');
-        blockers.add('supabase_access_token_missing_manual_auth_required');
-    }
-    if (/node_repl[\s\S]{0,500}No such file or directory|No such file or directory[\s\S]{0,500}node_repl/i.test(text)) {
-        warnings.add('node_repl_missing_command_observed');
-    }
-    return {
-        ...startupRepair,
-        ok: blockers.size === 0 && startupRepair?.ok !== false,
-        manual_actions: [...manual],
-        warnings: [...warnings],
-        blockers: [...blockers]
-    };
-}